Disable application insights in debug

Question

How can I disable application insights automatically when using a debug configuration and enable it only on release?
Is it possible to do this without creating another instrumentation key only for debug?

I have trackevent statements scattered all over the code, enclosing them inside a debug preprocessor check is not an ideal solution.

My current solution is to set the Build Action of the ApplicationInsights.config file to None so that it's not copied to the project's output directory, but this isn't a process that can be automated based on the active build configuration.

There is a Developer Mode but needs to be changed manually (if it was possible to conditionally set the config file, emptying the instrumentationkey solved problem as well). See http://apmtips.com/blog/2015/02/02/developer-mode/

Reference: http://blogs.msdn.com/b/visualstudioalm/archive/2015/01/07/application-insights-support-for-multiple-environments-stamps-and-app-versions.aspx

Answer 1

You can try to use TelemetryConfiguration.DisableTelemetry Property Something like this way..

#if DEBUG
            TelemetryConfiguration.Active.DisableTelemetry = true;
#endif

Answer 2

As an addition to the other solutions I would suggest to add the following let's say to the Global.asax:

protected void Application_Start()
{    
    DisableApplicationInsightsOnDebug();
    // do the other stuff
}

/// <summary>
/// Disables the application insights locally.
/// </summary>
[Conditional("DEBUG")]
private static void DisableApplicationInsightsOnDebug()
{
    TelemetryConfiguration.Active.DisableTelemetry = true;
}

The advantage of this is, that it needs no change to the configs and it works better with some tools like ReSharper which will understand it better than #-directives.

Answer 3

NOTE: This option only existed in Visual Studio 2019

For ASP.NET Core projects the App Insights are ON by default, which actually logs a ton of info into debug window.

To disable it go to "TOOLS --> Options --> Projects and Solutions --> Web Projects" and check "Disable local Application Insights for Asp.Net Core web projects."

Below is the image for disabling local app insights.

For more info on the issue you can see the official github issue here

Answer 4

Running an ASP.NET Core 2.1 web application with Visual Studio 2017 (15.9.2) the "Disable local Application Insights for Asp.Net Core web projects" did not clear up the output in my Debug window.

However adding the following to Configure() in Startup.cs did the job;

if (_env.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
    TelemetryConfiguration.Active.DisableTelemetry = true;
    TelemetryDebugWriter.IsTracingDisabled = true;
}

Note that the IsTracingDisabled was the key solution, but I left in DisableTelemetry for good measure! Plus having both lines next to one another is helpful when searching for similar references between .NET Framework & .NET Core projects in the same solution.

Answer 5

As explained in the question not deploying or deploying an ApplicationInsights.config without <instrumentationkey>key</instrumentationkey> block events from being generated. You can then put the instrumentation key in code (only on release in my case)

#if !DEBUG
    Microsoft.ApplicationInsights.Extensibility.TelemetryConfiguration.Active.InstrumentationKey = "instrumentation key";
#endif

Every TelemetryClient created after this call will have the correct key and will track events so you don't have to change the code in all places. Not calling the method above or leaving the parameter empty will block events because there isn't a key configured.

Basically the ApplicationInsights.config file overrides any code that set the instrumentation key, removing the <instrumentationkey>key</instrumentationkey> inside it will let you use code to configure the key. If you remove the file completely it doesn't work.

Here is the confirm: "If you want to set the key dynamically - for example if you want to send results from your application to different resources - you can omit the key from the configuration file, and set it in code instead."

Reference: https://azure.microsoft.com/en-us/documentation/articles/app-insights-configuration-with-applicationinsights-config/#_instrumentationkey

Answer 6

As of ASP.NET Core 3.1:

• To disable logging any App Insights telemetry to Azure:

public void Configure(IApplicationBuilder app, IHostingEnvironment env,
    TelemetryConfiguration configuration)
{
    configuration.DisableTelemetry = true;
}

• To disable logging telemetry events to the Output window:

TelemetryDebugWriter.IsTracingDisabled = true;

(the above can be called from anywhere, but the sooner in your application's lifecycle, the better).

Both can be used together to suppress all Application Insights activity in your code. I guard with an #if DEBUG directive to ensure that AppInsights does nothing on my local machine, but does emit events when published to our dev server in the Azure cloud:

public void Configure(IApplicationBuilder app, IHostingEnvironment env,
    TelemetryConfiguration configuration)
{
    if (env.IsDevelopment())
    {
#if DEBUG
        configuration.DisableTelemetry = true;

        TelemetryDebugWriter.IsTracingDisabled = true;
#endif
    }
}

Answer 7

I have decided to use both approaches. I have moved the InstrumentationKey to the Web.config and it will be replaced by the transformation from Web.Release.config or Web.Debug.config. (don't forget to remove it from the ApplicationInsights.config file). Then I have called this method from the Application_Start()

public static void RegisterTelemetryInstrumentationKey()
{
    if (string.IsNullOrWhiteSpace(WebConfigurationManager.AppSettings["TelemetryInstrumentationKey"])
    {
        TelemetryConfiguration.Active.DisableTelemetry = true;
    }
    else
    {
        TelemetryConfiguration.Active.InstrumentationKey = AppSettings.TelemetryInstrumentationKey;
    }
}

Answer 8

I've just had the same issue.

We wanted to control the setting in the web.config so added a DisableAITelemetry key within our app settings:

  <appSettings>
    <add key="DisableAITelemetry" value="true" />
  </appSettings>

With live and demo builds, we won't include a value (so that it defaults to false).

We could then solve it by adding this:

bool disable;
string disableAiTelemetry = ConfigurationManager.AppSettings["DisableAITelemetry"];
bool.TryParse(disableAiTelemetry, out disable);
TelemetryConfiguration.Active.DisableTelemetry = disable;

Answer 9

Slightly different play on some of the other solutions. Put this in your global.asax:

Microsoft.ApplicationInsights.Extensibility.Implementation.TelemetryDebugWriter.IsTracingDisabled = Debugger.IsAttached;

It will turn off app insights debug output when running under the debugger, but allow it under Ctrl+F5 scenarios and debug builds published to test servers

Answer 10

We've found the easiest way to prevent it from tracing into the Debug log is as simple as:

Extensibility.Implementation.TelemetryDebugWriter.IsTracingDisabled = True

Answer 11

In an ASP.NET Core application, you can add the following to the Startus.cs to turn off Application Insights in the Development environment:

if (env.IsDevelopment()) {
    TelemetryConfiguration.Active.DisableTelemetry = true;
}

Add this to the constructor, right after the builder.AddApplicationInsightsSettings(); command and you'll no longer see AI logs clogging up your debug console.

Answer 12

Microsoft.ApplicationInsights.AspNetCore Version 2.1

services.AddApplicationInsightsTelemetry(options =>
{
    options.EnableDebugLogger = false;
});

Answer 13

The solution suggested above has been deprecated (reference: https://github.com/microsoft/applicationinsights-dotnet/issues/1152). In dotnet core the new way to dynamically disable telemetry is this:

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddApplicationInsightsTelemetry();
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env, TelemetryConfiguration configuration)
    {
        configuration.DisableTelemetry = true;
        ...
    }

(reference: https://learn.microsoft.com/en-us/azure/azure-monitor/app/asp-net-core#disable-telemetry-dynamically)

And if you want to disable telemetry in a custom WebApplicationFactory (when doing integration tests) you can do this:

public class CustomWebApplicationFactory<TStartup> : WebApplicationFactory<TStartup> where TStartup : class
    protected override void ConfigureWebHost(IWebHostBuilder builder)
    {
        builder.ConfigureServices((context, services) =>
        {
            // Disable application insights during testing.
            services.Configure<TelemetryConfiguration>(
                (telemetryConfig) => {
                    telemetryConfig.DisableTelemetry = true;
                });
        });
        base.ConfigureWebHost(builder);
    }
}

For more context about integration testing see https://learn.microsoft.com/en-us/aspnet/core/test/integration-tests?view=aspnetcore-5.0

Answer 14

         public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            #region Disable Application Insights debug informations
#if DEBUG
            TelemetryConfiguration.Active.DisableTelemetry = true;
            TelemetryDebugWriter.IsTracingDisabled = true;
#endif
            #endregion
//...
}

Answer 15

Since .NET Core 3.1:

var telemetryConfiguration = TelemetryConfiguration.CreateDefault();
telemetryConfiguration.DisableTelemetry = true;

var telemetryClient = new TelemetryClient(telemetryConfiguration);   // Use this instance
TelemetryDebugWriter.IsTracingDisabled = true;

Answer 16

We can modify the file “appsetting.json” and add the following attributes

"ApplicationInsights": {
    "EnableRequestTrackingTelemetryModule": false,
    "EnableEventCounterCollectionModule": false,
    "EnableDependencyTrackingTelemetryModule": false,
    "EnablePerformanceCounterCollectionModule": false,
    "EnableDiagnosticsTelemetryModule": false
  }

More information you can find here.