[geneva] Add support for exporting otlp metrics via user_events on Linux

src/OpenTelemetry.Exporter.Geneva/CHANGELOG.md

@@ -5,6 +5,12 @@
 * Drop support for .NET 6 as this target is no longer supported.
   ([#2117](https://github.com/open-telemetry/opentelemetry-dotnet-contrib/pull/2117))
 
+* Added support for exporting metrics via
+  [user_events](https://docs.kernel.org/trace/user_events.html) on Linux when
+  OTLP protobuf encoding is enabled via the
+  `PrivatePreviewEnableOtlpProtobufEncoding=true` connection string switch.
+  ([#2113](https://github.com/open-telemetry/opentelemetry-dotnet-contrib/pull/2113))
+
 ## 1.9.0
 
 Released 2024-Jun-21

src/OpenTelemetry.Exporter.Geneva/Internal/ExporterEventSource.cs

@@ -18,6 +18,8 @@ internal sealed class ExporterEventSource : EventSource
     private const int EVENT_ID_ERROR = 4; // Other common exporter exceptions
     private const int EVENT_ID_OTLP_PROTOBUF_METRIC = 5; // Failed to serialize metric
     private const int EVENT_ID_COMPLETED_EXPORT = 6; // Completed export
+    private const int EVENT_ID_TRANSPORT_ERROR = 7; // Transport error
+    private const int EVENT_ID_TRANSPORT_EXCEPTION = 8; // Transport exception
 
     [NonEvent]
     public void FailedToSendTraceData(Exception ex)
@@ -76,6 +78,16 @@ public void FailedToSerializeMetric(string metricName, Exception ex)
         }
     }
 
+    [NonEvent]
+    public void TransportException(string transportType, string message, Exception ex)
+    {
+        if (Log.IsEnabled(EventLevel.Error, EventKeywords.All))
+        {
+            // TODO: Do not hit ETW size limit even for external library exception stack.
+            this.TransportException(transportType, message, ex.ToInvariantString());
+        }
+    }
+
     [Event(EVENT_ID_TRACE, Message = "Exporter failed to send trace data. Exception: {0}", Level = EventLevel.Error)]
     public void FailedToSendTraceData(string error)
     {
@@ -111,4 +123,16 @@ public void ExportCompleted(string exporterName)
     {
         this.WriteEvent(EVENT_ID_COMPLETED_EXPORT, exporterName);
     }
+
+    [Event(EVENT_ID_TRANSPORT_ERROR, Message = "Transport '{0}' error. Message: {1}", Level = EventLevel.Error)]
+    public void TransportError(string transportType, string error)
+    {
+        this.WriteEvent(EVENT_ID_TRANSPORT_ERROR, transportType, error);
+    }
+
+    [Event(EVENT_ID_TRANSPORT_EXCEPTION, Message = "Transport '{0}' error. Message: {1}, Exception: {2}", Level = EventLevel.Error)]
+    public void TransportException(string transportType, string error, string ex)
+    {
+        this.WriteEvent(EVENT_ID_TRANSPORT_EXCEPTION, transportType, error, ex);
+    }
 }

src/OpenTelemetry.Exporter.Geneva/Internal/Transports/UnixDomainSocketDataTransport.cs

@@ -73,7 +73,7 @@ private bool Connect()
         }
         catch (Exception ex)
         {
-            ExporterEventSource.Log.ExporterException("UDS Connect failed.", ex);
+            ExporterEventSource.Log.TransportException(nameof(UnixDomainSocketDataTransport), "Connection failure", ex);
 
             return false;
         }

src/OpenTelemetry.Exporter.Geneva/Metrics/OtlpProtobuf/OtlpProtobufMetricExporter.cs

@@ -1,6 +1,7 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 using OpenTelemetry.Metrics;
 using OpenTelemetry.Resources;
@@ -15,17 +16,32 @@ internal sealed class OtlpProtobufMetricExporter : IDisposable
 
     private readonly Func<Resource> getResource;
 
-    public OtlpProtobufMetricExporter(Func<Resource> getResource, ConnectionStringBuilder connectionStringBuilder, IReadOnlyDictionary<string, object> prepopulatedMetricDimensions)
+    public OtlpProtobufMetricExporter(
+        Func<Resource> getResource,
+        ConnectionStringBuilder connectionStringBuilder,
+        IReadOnlyDictionary<string, object> prepopulatedMetricDimensions)
     {
+        Debug.Assert(getResource != null, "getResource was null");
+
+        this.getResource = getResource;
+
+#if NET6_0_OR_GREATER
+        IMetricDataTransport transport = !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+            ? MetricUnixUserEventsDataTransport.Instance
+            : MetricWindowsEventTracingDataTransport.Instance;
+#else
         if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
         {
-            // Temporary until we add support for user_events.
             throw new NotSupportedException("Exporting data in protobuf format is not supported on Linux.");
         }
 
-        this.getResource = getResource;
+        var transport = MetricWindowsEventTracingDataTransport.Instance;
+#endif
 
-        this.otlpProtobufSerializer = new OtlpProtobufSerializer(MetricWindowsEventTracingDataTransport.Instance, connectionStringBuilder, prepopulatedMetricDimensions);
+        this.otlpProtobufSerializer = new OtlpProtobufSerializer(
+            transport,
+            connectionStringBuilder,
+            prepopulatedMetricDimensions);
     }
 
     public ExportResult Export(in Batch<Metric> batch)

src/OpenTelemetry.Exporter.Geneva/Metrics/Transport/MetricUnixUserEventsDataTransport.cs

@@ -0,0 +1,63 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#if NET
+
+#nullable enable
+
+using System.Text;
+using Microsoft.LinuxTracepoints.Provider;
+
+namespace OpenTelemetry.Exporter.Geneva;
+
+internal sealed class MetricUnixUserEventsDataTransport : IMetricDataTransport
+{
+    public const uint MetricsProtocol = 0U;
+    public const string MetricsVersion = "v0.19.00";
+    public const string MetricsTracepointName = "otlp_metrics";
+    public const string MetricsTracepointNameArgs = $"{MetricsTracepointName} u32 protocol;char[8] version;__rel_loc u8[] buffer";
+
+    private static readonly ReadOnlyMemory<byte> MetricsVersionUtf8 = Encoding.UTF8.GetBytes(MetricsVersion);
+    private readonly PerfTracepoint metricsTracepoint;
+
+    private MetricUnixUserEventsDataTransport()
+    {
+        this.metricsTracepoint = new PerfTracepoint(MetricsTracepointNameArgs);
+        if (this.metricsTracepoint.RegisterResult != 0)
+        {
+            ExporterEventSource.Log.TransportError(
+                nameof(MetricUnixUserEventsDataTransport),
+                $"Tracepoint for 'otlp_metrics' user events could not be registered: '{this.metricsTracepoint.RegisterResult}'");
+        }
+    }
+
+    public static MetricUnixUserEventsDataTransport Instance { get; } = new();
+
+    public void Send(MetricEventType eventType, byte[] body, int size)
+    {
+        throw new NotSupportedException();
+    }
+
+    public void SendOtlpProtobufEvent(byte[] body, int size)
+    {
+        if (this.metricsTracepoint.IsEnabled)
+        {
+            var buffer = new ReadOnlySpan<byte>(body, 0, size);
+
+            var bufferRelLoc = 0u | ((uint)buffer.Length << 16);
+
+            this.metricsTracepoint.Write(
+                [MetricsProtocol],
+                MetricsVersionUtf8.Span,
+                [bufferRelLoc],
+                buffer);
+        }
+    }
+
+    public void Dispose()
+    {
+        this.metricsTracepoint.Dispose();
+    }
+}
+
+#endif