How to Collect, Process, and Visualize .NET MAUI Traces with Edge Delta

Edge Delta Telemetry Pipeline

Edge Delta can be deployed either as a Linux agent or as a cloud pipeline, which both use the same OTLP input concept. On Linux, you deploy the Edge Delta agent (for example, as a systemd service or container) and configure an OTLP input node in the agent’s pipeline YAML. This input is typically bound to a local port (e.g., 0.0.0.0:4317 for gRPC or 4318 for HTTP) and set to accept OTLP signals (logs, metrics, and traces). 

Your .NET MAUI app (or any OTel-instrumented service) is then configured to use the Edge Delta agent’s address as its OTLP endpoint. Once data arrives, the pipeline can enrich, transform, filter, and route telemetry data to downstream systems such as SIEMs, observability platforms, or object storage.

In a cloud deployment, Edge Delta’s Cloud Pipeline plays the same role but runs centrally instead of on the host. You define an OTLP input in the Cloud Pipeline configuration, expose it through a secure endpoint (often behind TLS and an API gateway or load balancer), and point your OTel exporters at that URL. This pattern works well when you want multiple apps or environments (including MAUI clients, backend services, and infrastructure) to send OTLP data to a single, shared Edge Delta pipeline. 

In both Linux and cloud deployments, the OTLP input acts as the standard ingest point, and the rest of the Edge Delta pipeline handles normalization, analytics, and routing — giving you a consistent way to handle OTel data regardless of where it originates.

In the example below, we are leveraging one of Edge Delta’s Cloud Pipelines, which comes provisioned with an OTLP input node:

Double-clicking on the node exposes the gRPC endpoint address, as well as the TCP port and protocol the node is listening on:

OpenTelemetry Requirements

Because .NET MAUI is built on top of the standard .NET runtime, MAUI applications can use the official OpenTelemetry .NET SDK to generate traces, metrics, and logs. However, OpenTelemetry does not yet provide MAUI-specific documentation or templates, and certain mobile behaviors — such as app lifecycle constraints on Android and iOS — may require additional configuration. 

In practice, this means that MAUI applications can use the same .NET OpenTelemetry APIs (ActivitySource, Meter, and ILogger) as other .NET workloads, but teams should validate behavior on each target platform and be aware that some features, especially metrics on mobile, may vary by runtime or require platform-specific adjustments. Overall, MAUI is compatible with OpenTelemetry, but it should be treated as a general .NET integration rather than a fully first-class, mobile-optimized OTel scenario.

The following requirements outline the key packages, configuration settings, and platform considerations needed to successfully instrument a .NET MAUI application with OpenTelemetry and export data via OTLP. You can also consult the OpenTelemetry documentation for more information.

• Required packages:
  • OpenTelemetry
  • OpenTelemetry.Exporter.OpenTelemetryProtocol
  • OpenTelemetry.Extensions.Hosting
  • OpenTelemetry.Instrumentation.Http
  • OpenTelemetry.Instrumentation.Runtime
  • (Optional) OpenTelemetry.Exporter.Console for local debugging.
• Resource configuration:
  • Set standard resource attributes such as service.name and service.version via ResourceBuilder.
  • In this example, the service is configured as WeatherTwentyOne, version 1.0.0, with namespace maui and environment demo.
• OTLP endpoint and protocol:
  • Configure the OTLP exporter to send data to a collector or Edge Delta OTLP endpoint using gRPC.
  • The endpoint is resolved from the ED_TRACE_ENDPOINT environment variable, defaulting to http://10.0.2.2:4317 for Android emulators and http://localhost:4317 for other platforms.
  • For HTTPS endpoints, configure the secure URL and omit the cleartext HTTP/2 setting.
• Exporter configuration:
  • Use AddOtlpExporter to set the endpoint and protocol (OtlpExportProtocol.Grpc).
  • If authentication is required, configure request headers.
• Tracing configuration:
  • Set the W3C trace context format:
    • Activity.DefaultIdFormat = ActivityIdFormat.W3C
    • Activity.ForceDefaultIdFormat = true
  • Use a single ActivitySource (for example, WeatherTwentyOne.App) for manual spans.
  • Enable auto-instrumentation with AddHttpClientInstrumentation().
  • Configure sampling using AlwaysOnSampler().
• Provider startup:
  • Build tracer and meter providers eagerly at application startup.
  • Register providers as singletons to ensure spans and metrics are captured as soon as the app starts.
• Android-specific requirements:
  • Add the following permissions to the Android manifest:
    • android.permission.INTERNET
    • android.permission.ACCESS_NETWORK_STATE
  • Enable cleartext traffic if using HTTP endpoints:
    • <application android:usesCleartextTraffic="true" />
  • Enable unencrypted HTTP/2 support when using HTTP endpoints:
    • AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
• Optional debugging:
  • Configure a simple span processor to log spans to Logcat (for example, using the tag WeatherSpans) to verify that spans are being created correctly.

OTLP Endpoint and Protocol

Now that we’ve covered the requirements for instrumenting a .NET MAUI application with OpenTelemetry, this section will walk through how to configure the OTLP exporter so that traces can be sent to Edge Delta for processing and visualization.

First, we set the OTLP gRPC endpoint in MauiProgram.cs, with an environment override for Edge Delta SaaS:

// Defaults (local collector/agent)
#if ANDROID
    private const string DefaultOtlpEndpoint = "http://10.0.2.2:4317";
#else
    private const string DefaultOtlpEndpoint = "http://localhost:4317";
#endif

// Helper to resolve the endpoint (env wins)
private static Uri GetOtlpEndpoint()
{
    var endpoint = Environment.GetEnvironmentVariable("ED_TRACE_ENDPOINT") ?? DefaultOtlpEndpoint;
    return new Uri(endpoint);
}

Here is our exporter configuration:

Action<OtlpExporterOptions> configureExporter = options =>
{
    var endpoint = GetOtlpEndpoint();
    options.Endpoint = endpoint;
    options.Protocol = OtlpExportProtocol.Grpc;

    var apiKey = Environment.GetEnvironmentVariable("ED_API_KEY");
    if (!string.IsNullOrWhiteSpace(apiKey))
    {
        // Edge Delta SaaS ingestion header
        options.Headers = $"x-ed-api-key={apiKey}";
    }

    if (options.Endpoint.Scheme.Equals("http", StringComparison.OrdinalIgnoreCase))
    {
        AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
    }
};

The exporter will use http://10.0.2.2:4317 on Android, or http://localhost:4317 elsewhere.