BenchmarkDotNet Tests for OpenTelemetry/Activity

OpenTelemetryTests.cs

using System.Diagnostics;
using BenchmarkDotNet.Attributes;
using OpenTelemetry;
using OpenTelemetry.Trace;

public class OpenTelemetryTests
{
    private readonly Dictionary<string, string> _dictionary = new();
    private readonly ActivitySource _source = new("DummyTest");
    public OpenTelemetryTests()
    {
        _dictionary = new Dictionary<string, string> {
            { "blah", "blah" },
            { "blah1", "blah" }
        };
    }

    private TracerProvider? _tracerProvider;

    [GlobalSetup(Target = nameof(WithActivityAndOpenTelemetry))]
    public void SetupOpenTelemetry()
    {
        _tracerProvider = Sdk.CreateTracerProviderBuilder()
            .AddSource(_source.Name)
            .Build();
    }


    [GlobalSetup(Target = nameof(WithActivityAndOpenTelemetryAndAlwaysSampledOn))]
    public void SetupOpenTelemetryWithAlwaysOnSampler()
    {
        _tracerProvider = Sdk.CreateTracerProviderBuilder()
            .AddSource(_source.Name)
            .SetSampler(new AlwaysOnSampler())
            .Build();
    }

    [GlobalSetup(Target = nameof(WithActivityAndOpenTelemetryWithAddAttributeProcessor))]
    public void SetupOpenTelemetryWithAddAttributeProcessor()
    {
        _tracerProvider = Sdk.CreateTracerProviderBuilder()
           .AddSource(_source.Name)
           .SetSampler(new AlwaysOnSampler())
           .AddProcessor(new AddAttributeProcessor())
           .Build();
    }

    [GlobalCleanup]
    public void DisposeTracerProvider() => _tracerProvider?.Dispose();

    [Benchmark]
    public void WithoutActivity()
    {
        var item = InternalTest();
    }

    [Benchmark]
    public void WithActivity()
    {
        using var activity = _source.StartActivity("WithActivity");
        var item = InternalTest();
    }

    [Benchmark]
    public void WithActivityAndAttributes() => BasicMethodWithActivity();

    [Benchmark]
    public void WithActivityAndOpenTelemetry() => BasicMethodWithActivity();

    [Benchmark]
    public void WithActivityAndOpenTelemetryAndAlwaysSampledOn() => BasicMethodWithActivity();

    [Benchmark]
    public void WithActivityAndOpenTelemetryWithAddAttributeProcessor() => BasicMethodWithActivity();


    private void BasicMethodWithActivity()
    {
        using var activity = _source.StartActivity("WithActivity");
        var item = InternalTest();
        activity?.SetTag("dictionary.item", item);
    }


    private string InternalTest()
    {
        if (_dictionary.ContainsKey("blah"))
            return _dictionary["blah"];

        return "";
    }
}

public class AddAttributeProcessor : BaseProcessor<Activity>
{
    public override void OnStart(Activity data)
    {
        data?.SetTag("blah", true);
        base.OnStart(data!);
    }
}