При использовании выборки Application Insights можно сохранить связанные записи вместе с исключенными элементами

В приведенном ниже коде используется Microsoft Application Insights для мониторинга и регистрации в консольном приложении с использованием интерфейса ITelemetryProcessor из Application Insights. Класс RelatedTelemetryProcessor реализует ITelemetryProcessor и сохраняет связанные записи вместе с исключенными элементами при использовании Application Insights.

Я ссылался на этот документ для фильтрации и предварительной обработки в Azure Monitor SDK Application Insights.

• Используется специальный процессор телеметрии (RelatedTelemetryProcessor), который сохраняет все элементы телеметрии, связанные с исключениями, на основе их идентификатора операции. Выборка также используется при исключении исключений (excludedTypes: "Exception") с цепочкой процессора телеметрии по умолчанию.

   private const string AppInsightConnectionString = "<connection string>";
    private const double SamplingPercentage = 50;

    public static async Task Main(string[] args)
    {
        // Create a ServiceCollection
        var services = new ServiceCollection();

        // Configure Application Insights telemetry
        services.AddApplicationInsightsTelemetryWorkerService(options =>
        {
            options.EnableAdaptiveSampling = false;
            options.ConnectionString = AppInsightConnectionString;
        });

        // Configure logging
        services.AddLogging(loggingBuilder =>
        {
            loggingBuilder.AddConsole();
            loggingBuilder.AddApplicationInsights(AppInsightConnectionString);
        });

        // Build the service provider
        var serviceProvider = services.BuildServiceProvider();

        // Configure telemetry pipeline with custom processor and sampling
        var telemetryConfiguration = serviceProvider.GetRequiredService<TelemetryConfiguration>();
        var telemetryProcessorChainBuilder = telemetryConfiguration.DefaultTelemetrySink.TelemetryProcessorChainBuilder;

        // Use custom processor and sampling
        telemetryProcessorChainBuilder.Use((next) => new CustomTelemetryProcessor(next));
        telemetryProcessorChainBuilder.UseSampling(SamplingPercentage, excludedTypes: "Exception");
        telemetryProcessorChainBuilder.Build();

        // Get logger
        var logger = serviceProvider.GetRequiredService<ILogger<Program>>();

        // Perform work
        DoWork(logger);

        // Flush telemetry
        var telemetryClient = serviceProvider.GetRequiredService<TelemetryClient>();
        telemetryClient.Flush();
        await Task.Delay(5000); // Wait for telemetry to be sent

        Console.WriteLine("Done. Press any key to exit.");
        Console.ReadKey();
    }

    static void DoWork(ILogger logger)
    {
        const int iterations = 50;
        const int errors = 10;

        var random = new Random();
        var errorsSet = new HashSet<int>();
        while (errorsSet.Count < errors)
        {
            errorsSet.Add(random.Next(0, iterations));
        }

        // Perform operations with logging
        for (int i = 0; i < iterations; i++)
        {
            string operationId = Guid.NewGuid().ToString();
            logger.LogInformation($"Begin operation: {operationId}");

            if (errorsSet.Contains(i))
            {
                logger.LogError(new Exception("Sample exception"), $"Error in operation: {operationId}");
            }

            logger.LogInformation($"End operation: {operationId}");
        }
    }
}

public class CustomTelemetryProcessor : ITelemetryProcessor
{
    private readonly ITelemetryProcessor _next;
    private readonly HashSet<string> _preservedOperationIds = new HashSet<string>();

    public CustomTelemetryProcessor(ITelemetryProcessor next)
    {
        _next = next;
    }

    public void Process(ITelemetry item)
    {
        // Get the operation ID of the telemetry item
        string operationId = item.Context.Operation.Id;

        // Check if the telemetry item is an exception
        if (item is ExceptionTelemetry exceptionTelemetry)
        {
            // Add the operation ID to the set of preserved operation IDs
            _preservedOperationIds.Add(operationId);
        }

        // Check if the operation ID is in the set of preserved operation IDs
        if (_preservedOperationIds.Contains(operationId))
        {
            // Pass the item through without sampling
            _next.Process(item);
        }
        else
        {
            // Apply your desired sampling here
            // If you decide to keep the item, pass it to the next processor
            _next.Process(item);
        }
    }

Чтобы обеспечить сохранение связанных трассировок в случае возникновения исключения при применении выборки к другим элементам телеметрии, вы можете настроить собственный процессор телеметрии для правильной обработки обоих случаев.

public class CustomTelemetryProcessor : ITelemetryProcessor
{
    private ITelemetryProcessor _next;
    private HashSet<string> _preservedOperationIds = new HashSet<string>();

    public CustomTelemetryProcessor(ITelemetryProcessor next)
    {
        _next = next;
    }

    public void Process(ITelemetry item)
    {
        if (item is ExceptionTelemetry exceptionTelemetry)
        {
            // Add the operation ID to the set of preserved IDs
            _preservedOperationIds.Add(exceptionTelemetry.Context.Operation.Id);
        }

        // Check if the operation ID is in the preserved set
        if (_preservedOperationIds.Contains(item.Context.Operation.Id))
        {
            // Pass the item through without sampling
            _next.Process(item);
        }
        else
        {
            // Apply sampling or other processing as usual
            _next.Process(item);
        }
    }
}

В вашем методе Main:

// Configure telemetry pipeline with custom processor and sampling
var telemetryConfiguration = serviceProvider.GetRequiredService<TelemetryConfiguration>();
var telemetryProcessorChainBuilder = telemetryConfiguration.DefaultTelemetrySink.TelemetryProcessorChainBuilder;

// Use custom processor and sampling
telemetryProcessorChainBuilder.Use((next) => new CustomTelemetryProcessor(next));
telemetryProcessorChainBuilder.UseSampling(SamplingPercentage, excludedTypes: "Exception");
telemetryProcessorChainBuilder.Build();

Пользовательский ITelemetryProcessor обрабатывает по одному элементу телеметрии за раз, что может затруднить обеспечение сохранения связанных трассировок при возникновении исключений.

Просто хотел опубликовать то, что я придумал после более подробного изучения реализации специального процессора телеметрии. Идея продолжать накапливать сегменты телеметрии в течение некоторого времени, прежде чем принимать решение о выборке. Это создает небольшую задержку, но это лучшее, что у меня есть на данный момент.

using Microsoft.ApplicationInsights.Channel;
using Microsoft.ApplicationInsights.DataContracts;
using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Primitives;
using System.Collections.Concurrent;
using System.Diagnostics;

/// <summary>
/// Sampes only successful telemetry chains
/// </summary>
public class SuccessfulSamplingTelemetryProcessor : ITelemetryProcessor
{
    private readonly TimeSpan _bufferedTime;
    private readonly ITelemetryProcessor _next;
    private readonly SamplingTelemetryProcessor _samplingTelemetryProcessor;
    private readonly MemoryCache _cache;

    public SuccessfulSamplingTelemetryProcessor(double successfulSamplingPercentage, TimeSpan bufferedTime, ITelemetryProcessor next)
    {
        _bufferedTime = bufferedTime;
        _next = next;
        _samplingTelemetryProcessor = new SamplingTelemetryProcessor(next)
        {
            SamplingPercentage = successfulSamplingPercentage
        };
        _cache = new MemoryCache(new MemoryCacheOptions());
    }

    public void Process(ITelemetry item)
    {
        // get operation id 
        var operationId = item.Context.Operation.Id;
        if (string.IsNullOrEmpty(operationId))
        {
            // sample by default without correlation id
            _samplingTelemetryProcessor.Process(item);
            return;
        }

        var queue = _cache.GetOrCreate(operationId, entry =>
        {
            // expiration doesnt work as I'd expected, so use cancellation token instead
            // see https://stackoverflow.com/questions/42535408/net-core-memorycache-postevictioncallback-not-working-properly
            var expirationToken = new CancellationChangeToken(new CancellationTokenSource(_bufferedTime).Token);
            entry.AbsoluteExpirationRelativeToNow = _bufferedTime;
            entry.Priority = CacheItemPriority.NeverRemove;
            entry.AddExpirationToken(expirationToken);
            entry.PostEvictionCallbacks.Add(new PostEvictionCallbackRegistration
            {
                EvictionCallback = OnPostEviction
            });
            return new ConcurrentQueue<ITelemetry>();
        });

        // just add to the queue for now
        queue.Enqueue(item);
    }

    private void OnPostEviction(object key, object? value, EvictionReason reason, object? state)
    {
        var queue = (ConcurrentQueue<ITelemetry>)value;

        // check if there is exception in the chain 
        var hasException = queue.Any(t => t is ExceptionTelemetry);
        while (queue.TryDequeue(out var telemetry))
        {
            if (hasException)
            {
                // pass through
                _next.Process(telemetry);
            }
            else
            {
                // apply sampling
                _samplingTelemetryProcessor.Process(telemetry);
            }
        }   
    }
}