Wyłącz analizę aplikacji podczas debugowania

Jak mogę automatycznie wyłączyć szczegółowe informacje o aplikacji podczas korzystania z konfiguracji debugowania i włączyć ją tylko w momencie wydania?
Czy można to zrobić bez tworzenia innego klucza instrumentacji tylko do debugowania?

Mam trackeventinstrukcje rozrzucone po całym kodzie, zamykanie ich wewnątrz sprawdzania preprocesora debugowania nie jest idealnym rozwiązaniem.

Moje obecne rozwiązanie jest ustawienie Build Actionz ApplicationInsights.configpliku Nonetak, że nie jest kopiowany do katalogu wyjściowego projektu, ale nie jest to proces, który można zautomatyzować na podstawie aktywnej konfiguracji kompilacji.

Istnieje tryb programisty, ale należy go zmienić ręcznie (jeśli możliwe było warunkowe ustawienie pliku konfiguracyjnego, opróżnienie klucza instrumentu również rozwiązało problem). Zobacz http://apmtips.com/blog/2015/02/02/developer-mode/

Źródła: http://blogs.msdn.com/b/visualstudioalm/archive/2015/01/07/application-insights-support-for-multiple-environments-stamps-and-app-versions.aspx

Możesz spróbować użyć właściwości TelemetryConfiguration.DisableTelemetry Coś w ten sposób ..

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

Jako dodatek do innych rozwiązań proponuję dodać, powiedzmy, do 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;
}

Zaletą tego jest to, że nie wymaga zmiany konfiguracji i działa lepiej z niektórymi narzędziami, takimi jak ReSharper, które zrozumieją to lepiej niż #-directives.

W przypadku projektów ASP.NET Core usługa App Insights jest domyślnie włączona, co w rzeczywistości rejestruje mnóstwo informacji w oknie debugowania.

Aby go wyłączyć, przejdź do „NARZĘDZIA -> Opcje -> Projekty i rozwiązania -> Projekty sieci Web” i zaznacz opcję „Wyłącz lokalne Application Insights dla projektów sieci Web Asp.Net Core”.

Poniżej znajduje się obraz do wyłączania lokalnych statystyk aplikacji.

Więcej informacji na ten temat można znaleźć w oficjalnym wydaniu Github tutaj

Jak wyjaśniono w pytaniu, nie należy wdrażać ani wdrażać ApplicationInsights.config bez <instrumentationkey>key</instrumentationkey>generowania zdarzeń blokowania. Następnie możesz umieścić klucz instrumentacji w kodzie (tylko po zwolnieniu w moim przypadku)

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

Każdy TelemetryClientutworzony po tym wywołaniu będzie miał prawidłowy klucz i będzie śledził zdarzenia, więc nie musisz zmieniać kodu we wszystkich miejscach. Niewywołanie powyższej metody lub pozostawienie pustego parametru spowoduje zablokowanie zdarzeń, ponieważ nie ma skonfigurowanego klucza.

Zasadniczo ApplicationInsights.configplik zastępuje dowolny kod, który ustawił klucz Instrumentacji, usunięcie jego <instrumentationkey>key</instrumentationkey>wnętrza umożliwi użycie kodu do skonfigurowania klucza. Jeśli usuniesz plik całkowicie, to nie zadziała.

Oto potwierdzenie: „Jeśli chcesz ustawić klucz dynamicznie - na przykład jeśli chcesz wysłać wyniki z aplikacji do różnych zasobów - możesz pominąć klucz w pliku konfiguracyjnym i zamiast tego ustawić go w kodzie”.

Źródła: https://azure.microsoft.com/en-us/documentation/articles/app-insights-configuration-with-applicationinsights-config/#_instrumentationkey

Zdecydowałem się zastosować oba podejścia. Przeniosłem InstrumentationKeydo Web.configi zostanie zastąpiony przez transformację z Web.Release.configlub Web.Debug.config. (nie zapomnij usunąć go z ApplicationInsights.configpliku). Następnie nazwałem tę metodę zApplication_Start()

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

Uruchamianie aplikacji internetowej ASP.NET Core 2.1 z programem Visual Studio 2017 (15.9.2) „Wyłączanie usługi Local Application Insights dla projektów sieci Web Asp.Net Core” nie wyczyściło danych wyjściowych w moim oknie debugowania.

Jednak dodanie następujących elementów do Configure () w Startup.cs wykonało zadanie;

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

Zauważ, że IsTracingDisabled był kluczowym rozwiązaniem , ale zostawiłem DisableTelemetry na dobre! Ponadto umieszczenie obu wierszy obok siebie jest pomocne podczas wyszukiwania podobnych odniesień między projektami .NET Framework i .NET Core w tym samym rozwiązaniu.

Właśnie miałem ten sam problem.

Chcieliśmy kontrolować ustawienie w web.config, więc dodaliśmy klucz DisableAITelemetry w ustawieniach naszej aplikacji:

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

W przypadku kompilacji na żywo i wersji demonstracyjnych nie będziemy uwzględniać wartości (więc domyślnie jest to false).

Moglibyśmy to rozwiązać, dodając to:

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

Nieco inaczej grają niektóre inne rozwiązania. Umieść to w swoim global.asax:

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

Wyłączy dane wyjściowe debugowania statystyk aplikacji, gdy działa w debugerze, ale zezwoli na scenariusze Ctrl + F5 i kompilacje debugowania opublikowane do testowania serwerów

W aplikacji ASP.NET Core można dodać następujące elementy do pliku Startus.cs, aby wyłączyć usługę Application Insights w środowisku programistycznym: 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;
}

Dodaj to do konstruktora, zaraz po builder.AddApplicationInsightsSettings();poleceniu, a nie będziesz już widzieć dzienników AI zatykających konsolę debugowania.

Znaleźliśmy najprostszy sposób, aby zapobiec śledzeniu go w dzienniku debugowania, jest tak prosty, jak:

Extensibility.Implementation.TelemetryDebugWriter.IsTracingDisabled = True

Microsoft.ApplicationInsights.AspNetCore w wersji 2.1

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

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

Od .NET Core 3.1:

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

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

Od ASP.NET Core 3.1:

• Aby wyłączyć rejestrowanie danych telemetrycznych usługi App Insights na platformie Azure :

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

• Aby wyłączyć rejestrowanie zdarzeń telemetrii w oknie Wyjście :

TelemetryDebugWriter.IsTracingDisabled = true;

(powyższe można wywołać z dowolnego miejsca, ale im szybciej w cyklu życia aplikacji, tym lepiej).

Oba mogą być używane razem, aby pomijać wszystkie działania Application Insights w kodzie. #if DEBUGChronię za pomocą dyrektywy, aby upewnić się, że AppInsights nic nie robi na moim komputerze lokalnym, ale emituje zdarzenia po przekazaniu na nasz serwer deweloperski platformy Azure:

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

        TelemetryDebugWriter.IsTracingDisabled = true;
#endif
    }
}