Trace Azure Functions written in .NET

using Dynatrace.OpenTelemetry;
using Dynatrace.OpenTelemetry.Instrumentation.AzureFunctions;
using Microsoft.Azure.Functions.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;
using OpenTelemetry.Trace;

[assembly: FunctionsStartup(typeof(Examples.AzureFunctionApp.Startup))]

namespace Examples.AzureFunctionApp
{
    internal class Startup : FunctionsStartup
    {
        public override void Configure(IFunctionsHostBuilder builder)
        {
            builder.Services.AddOpenTelemetryTracing(sdk => sdk
                .AddAzureFunctionsInstrumentation()
                .AddAspNetCoreInstrumentation()
                // ... any custom OTel setup ...
                .AddDynatrace()
                // ... if you need custom resources, set them after AddDynatrace & call AddTelemetrySdk (see below)
              );
        }
    }
}

using System.Diagnostics;
using System.Threading.Tasks;
using Dynatrace.OpenTelemetry;
using Dynatrace.OpenTelemetry.Instrumentation.AzureFunctions;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Extensions.Logging;

namespace Examples.AzureFunctionApp
{
    public class Function
    {
        public Function(ILoggerFactory loggerFactory)
        {
            // This is needed in every function in your app.
            DynatraceSetup.InitializeLogging(loggerFactory);
        }

        [FunctionName("MyFunction")]
        public async Task<IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequest request,
            Microsoft.Azure.WebJobs.ExecutionContext ctx)
        {
            // This adds the required attributes to make the activity recognizable as an Azure function invocation.
            // Put this line first - there should be minimal time elapsing between the Activity being created
            // by the ASP.NET core instrumentation and the call to this method.
            AzureFunctionsInstrumentation.AddIncomingHttpAzureFunctionCallInfo(Activity.Current, ctx);

            // Your handler code...
        }
    }
}

{
  "version": "2.0",
  "logging": {
    // ...
   "logLevel": {
      "Dynatrace.OpenTelemetry": "Debug"
    }
  }
}

using Dynatrace.OpenTelemetry;
using Dynatrace.OpenTelemetry.Instrumentation.AzureFunctions;
using Dynatrace.OpenTelemetry.Instrumentation.AzureFunctions.Worker;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

DynatraceSetup.InitializeLogging();

var host = new HostBuilder()
    .ConfigureFunctionsWebApplication(fw => fw.UseTracingMiddleware())
    .ConfigureServices(services => services
        .AddOpenTelemetry()
        .WithTracing(tracing => tracing
            .AddAzureFunctionsInstrumentation()
            // ... any custom OTel setup ...
            .AddDynatrace()
            // ... if you need custom resources, set them after AddDynatrace (see below)
        ))
    .Build();

host.Run();

using Dynatrace.OpenTelemetry;
using Dynatrace.OpenTelemetry.Instrumentation.AzureFunctions;
using OpenTelemetry.Trace;

// ...
// (call DynatraceSetup.InitializeLogging before or after AddDynatrace depending on runtime)
// ...

TracerProvider tracerProvider = Sdk.CreateTracerProviderBuilder().AddDynatrace().Build();

public class HttpExample {
    private readonly TracerProvider _tracerProvider;

    public HttpExample(TracerProvider tracerProvider) {
        _tracerProvider = tracerProvider;
    }

    [Function("HttpExample")]
    public IActionResult Run([HttpTrigger(AuthorizationLevel.Function, "get")] HttpRequestData req, FunctionContext ctx)
    {
        var parent = ExtractParentContext(req, ctx); // See further below after this code snippet
        return AzureFunctionsCoreInstrumentation.Trace(_tracerProvider, ctx.FunctionDefinition.Name, () => RunInternal(req), parent);
    }


    public IActionResult RunInternal(HttpRequestData req)
    {
        // ... your actual handler code ...
        return new OkObjectResult("Your result");
    }
}

private static ActivityContext ExtractParentContext(HttpRequest request)
{
    var context = Propagators.DefaultTextMapPropagator.Extract(default, request, HeaderValuesGetter);
    return context.ActivityContext;
}

private static IEnumerable<string> HeaderValuesGetter(HttpRequest request, string name) =>
    request.Headers.TryGetValue(name, out var values) ? values : (IEnumerable<string>)null;

private static ActivityContext ExtractParentContext(HttpRequestData request, FunctionContext context) {
    ActivityContext parent = default;

    PropagationContext ctx = Propagators.DefaultTextMapPropagator.Extract(
        default,
        request.Headers,
        (c, k) => c.TryGetValues(k, out var value) ? value : null);
    parent = ctx.ActivityContext;
    if (parent == default)
    {
        PropagationContext ctx2 = Propagators.DefaultTextMapPropagator.Extract(
            default,
            context.TraceContext,
            (c, k) =>
            {
                string? result =
                    k.Equals("traceparent", StringComparison.OrdinalIgnoreCase) ? c.TraceParent :
                    k.Equals("tracestate", StringComparison.OrdinalIgnoreCase) ? c.TraceState :
                    null;
                return result == null ? null : new[] { result };
            });
        parent = ctx2.ActivityContext;
    }
    return parent;
}