App Insights : Désactiver la télémétrie des dépendances SQL

Question

J'utilise Azure Application Insights pour un site web (Azure App Service). Sur ce site, j'utilise une installation Umbraco en cluster et hangfire. À eux seuls, ces deux éléments frappent la base de données toutes les minutes et inondent mes "App Insights".

Ma question est donc la suivante : comment désactiver le Sql Dependency Tracker ? J'ai jeté un coup d'œil au fichier ApplicationInsights.config et je n'ai rien trouvé d'évident. Je peux voir Microsoft.ApplicationInsights.DependencyCollector qui est probablement responsable, mais je ne veux pas supprimer tous les types de télémétrie de dépendance, seulement sql.

Merci

Answer 1

La meilleure solution consiste à utiliser un processeur de télémétrie pour filtrer certains types de demandes de dépendance. Consultez les ressources ci-dessous pour plus d'informations.

Echantillonnage, filtrage et prétraitement de la télémétrie dans le SDK d'Application Insights

Demander le filtrage dans Application Insights avec processeur de télémétrie

Un exemple de processeur pourrait ressembler à ceci.

using Microsoft.ApplicationInsights.Channel;
using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights.DataContracts;

public class NoSQLDependencies : ITelemetryProcessor
{
    private ITelemetryProcessor Next { get; set; }

    // Link processors to each other in a chain.
    public NoSQLDependencies(ITelemetryProcessor next)
    {
        this.Next = next;
    }
    public void Process(ITelemetry item)
    {
        if (IsSQLDependency(item)) { return; }
        this.Next.Process(item);
    }

    private bool IsSQLDependency(ITelemetry item)
    {
        var dependency = item as DependencyTelemetry;
        if (dependency?.DependencyTypeName == "SQL")
        {
            return true;
        }
        return false;
    }
}

Answer 2

Nous filtrons juste le SQL hangfire en utilisant un processeur de télémétrie comme celui-ci, dans un projet .net5 asp.net. Notez que nous utilisons une base de données différente pour Hangfire, de sorte que le processeur de télémétrie peut facilement éliminer Hangfire SQL en vérifiant s'il se connecte à la base de données Hangfire.

A l'intérieur Startup.Configure() :

var hangFireConnectionString = // ... get from somewhere

configuration.TelemetryProcessorChainBuilder
    .Use(next => new IgnoreHangfireTelemetry(next,hangFireConnectionString))
    .Build();

Voici la classe de processeurs :

public class IgnoreHangfireTelemetry : ITelemetryProcessor
{
    private readonly ITelemetryProcessor next;
    private readonly string hangfireDashboardPath;
    private readonly string sqlDatabase;  // name of the hangfire db

    public IgnoreHangfireTelemetry(
        ITelemetryProcessor next,
        string sqlConnectionString = null,
        string hangfireDashboardPath = "/hangfire")
    {
        this.next = next ?? throw new ArgumentNullException(nameof(next));

        if (!string.IsNullOrEmpty(sqlConnectionString))
        {
            var builder = new SqlConnectionStringBuilder(sqlConnectionString);

            sqlDatabase = builder.InitialCatalog;
        }

        this.hangfireDashboardPath = hangfireDashboardPath ?? throw new ArgumentNullException(nameof(hangfireDashboardPath));
    }

    public void Process(ITelemetry item)
    {
        var request = item as RequestTelemetry;

        // If it's a request for Hangfire Dashboard don't record it
        if (request != null
            && request.Url.AbsolutePath.StartsWith(hangfireDashboardPath))
        {
            return;
        }

        var telemetry = item as DependencyTelemetry;

        // If it's a SQL dependency to the Hangfire db don't record it
        if (telemetry != null)
        {
            if (sqlDatabase != null  && telemetry.Type == "SQL"
                && telemetry.Target.EndsWith($"| {sqlDatabase}", StringComparison.OrdinalIgnoreCase))
            {
                return;
            }

            if (telemetry.Type == "SQL"
                && telemetry.Name.ToLower().Contains("hangfire")
                && telemetry.Success.GetValueOrDefault(false))
            {
                return;
            }
        }

        // Looks like it's not Hangfire, process the telemetry as usual.
        next.Process(item);
    }
}

Si vous n'utilisez pas une base de données Hangfire séparée, vous pouvez réaliser la même chose en inspectant d'autres fichiers DépendanceTélémétrie par exemple, regarder DependencyTelemetry.Data ou .CommandName (qui contient l'instruction SQL) et vérifier s'il contient [Hangfire] (ou un autre nom de schéma de la base de données si vous avez modifié Hangfire pour utiliser un schéma différent). Si vous ne filtrez que sur sql, vous devrez filtrer quelques commandes supplémentaires. Il suffit d'utiliser le débogueur et de voir celles que vous devez exclure. Par exemple, dans le code ci-dessus, mon sqlBackend ressemble à ceci (notez que "." est le nom de mon serveur SQL, c'est-à-dire qu'il est exécuté localement, et "Hangfire" est le nom de la base de données où se trouvent mes tables Hangfire) :

Parfois, la propriété sqlBackend.Name a des valeurs telles que . | Hangfire | Open ou . | Hangfire | sp_getapplock mais le Target est toujours ``. | Hangfire`, par exemple :