Add Multi-Azure Function Unique Named Pipe Configuration

tracer/build/_build/Honeypot/IntegrationGroups.cs

@@ -129,7 +129,10 @@ static IntegrationMap()
             NugetPackages.Add("Datadog.Trace", new string[] { });
             NugetPackages.Add("Datadog.Trace.Manual", new string[] { });
             NugetPackages.Add("Datadog.Trace.OpenTracing", new string[] { });
-
+
+            // Serverless
+            NugetPackages.Add("Datadog.Serverless.Compat", new string[] { });
+
             // Feature Flags
             NugetPackages.Add("Datadog.FeatureFlags.OpenFeature", new string[] { });
             NugetPackages.Add("OpenFeature", new string[] { });

tracer/build/supported_calltargets.g.json

@@ -16459,6 +16459,50 @@
     "IsAdoNetIntegration": false,
     "InstrumentationCategory": 1
   },
+  {
+    "IntegrationName": "ServerlessCompat",
+    "AssemblyName": "Datadog.Serverless.Compat",
+    "TargetTypeName": "Datadog.Serverless.CompatibilityLayer",
+    "TargetMethodName": "CalculateDogStatsDPipeName",
+    "TargetReturnType": "System.String",
+    "TargetParameterTypes": [],
+    "MinimumVersion": {
+      "Item1": 0,
+      "Item2": 0,
+      "Item3": 0
+    },
+    "MaximumVersion": {
+      "Item1": 1,
+      "Item2": 65535,
+      "Item3": 65535
+    },
+    "InstrumentationTypeName": "Datadog.Trace.ClrProfiler.AutoInstrumentation.Serverless.CompatibilityLayer_CalculateDogStatsDPipeName_Integration",
+    "IntegrationKind": 0,
+    "IsAdoNetIntegration": false,
+    "InstrumentationCategory": 1
+  },
+  {
+    "IntegrationName": "ServerlessCompat",
+    "AssemblyName": "Datadog.Serverless.Compat",
+    "TargetTypeName": "Datadog.Serverless.CompatibilityLayer",
+    "TargetMethodName": "CalculateTracePipeName",
+    "TargetReturnType": "System.String",
+    "TargetParameterTypes": [],
+    "MinimumVersion": {
+      "Item1": 0,
+      "Item2": 0,
+      "Item3": 0
+    },
+    "MaximumVersion": {
+      "Item1": 1,
+      "Item2": 65535,
+      "Item3": 65535
+    },
+    "InstrumentationTypeName": "Datadog.Trace.ClrProfiler.AutoInstrumentation.Serverless.CompatibilityLayer_CalculateTracePipeName_Integration",
+    "IntegrationKind": 0,
+    "IsAdoNetIntegration": false,
+    "InstrumentationCategory": 1
+  },
   {
     "IntegrationName": "ServiceStackRedis",
     "AssemblyName": "ServiceStack.Redis",

tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml

@@ -16,6 +16,7 @@
    <assembly fullname="Couchbase.NetClient" />
    <assembly fullname="coverlet.core" />
    <assembly fullname="Datadog.FeatureFlags.OpenFeature" />
+   <assembly fullname="Datadog.Serverless.Compat" />
    <assembly fullname="Datadog.Trace" />
    <assembly fullname="Datadog.Trace.Manual" />
    <assembly fullname="Datadog.Trace.OpenTracing" />

tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/Serverless/CompatibilityLayer_CalculateDogStatsDPipeName_Integration.cs

@@ -0,0 +1,87 @@
+// <copyright file="CompatibilityLayer_CalculateDogStatsDPipeName_Integration.cs" company="Datadog">
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc.
+// </copyright>
+
+#nullable enable
+
+#if !NETFRAMEWORK
+using System;
+using System.ComponentModel;
+using Datadog.Trace.ClrProfiler.CallTarget;
+using Datadog.Trace.Configuration;
+using Datadog.Trace.Logging;
+
+namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Serverless
+{
+    /// <summary>
+    /// Instrumentation for Datadog.Serverless.CompatibilityLayer.CalculateDogStatsDPipeName method.
+    /// This instrumentation overrides the return value with the tracer's pre-generated pipe name,
+    /// ensuring the tracer's runtime metrics and the compat layer use the same pipe name.
+    /// Version range 0.0.0–1.*.* matches all 0.x and 1.x versions, including the 0.0.0 dev build.
+    /// If the target method doesn't exist (e.g. older/newer compat assembly), the native profiler
+    /// silently skips instrumentation — no exception is thrown.
+    /// </summary>
+    [InstrumentMethod(
+        AssemblyName = "Datadog.Serverless.Compat",
+        TypeName = "Datadog.Serverless.CompatibilityLayer",
+        MethodName = "CalculateDogStatsDPipeName",
+        ReturnTypeName = ClrNames.String,
+        ParameterTypeNames = [],
+        MinimumVersion = "0.0.0",
+        MaximumVersion = "1.*.*",
+        IntegrationName = nameof(IntegrationId.ServerlessCompat),
+        InstrumentationCategory = InstrumentationCategory.Tracing)]
+    [Browsable(false)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public sealed class CompatibilityLayer_CalculateDogStatsDPipeName_Integration
+    {
+        private static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(CompatibilityLayer_CalculateDogStatsDPipeName_Integration));
+
+        /// <summary>
+        /// OnMethodEnd callback - intercepts the return value and overrides it with a unique pipe name
+        /// </summary>
+        /// <typeparam name="TTarget">Type of the target</typeparam>
+        /// <param name="instance">Instance value, aka `this` of the instrumented method (null for static methods)</param>
+        /// <param name="returnValue">The pipe name calculated by the compat layer</param>
+        /// <param name="exception">Exception instance in case the original code threw an exception</param>
+        /// <param name="state">Calltarget state value</param>
+        /// <returns>A unique pipe name for coordination between tracer and compat layer</returns>
+        internal static CallTargetReturn<string> OnMethodEnd<TTarget>(
+            TTarget instance,
+            string returnValue,
+            Exception exception,
+            in CallTargetState state)
+        {
+            if (exception is not null)
+            {
+                // If there was an exception, pass it through
+                return new CallTargetReturn<string>(returnValue);
+            }
+
+            try
+            {
+                // Use the tracer's configured pipe name, which in Azure Functions will be the
+                // unique name generated by ExporterSettings. Fall back to the compat layer's
+                // own calculated name if the tracer isn't initialized yet.
+                var pipeName = Tracer.Instance.Settings?.Manager?.InitialExporterSettings?.MetricsPipeName ?? returnValue;
+
+                Log.Debug(
+                    "ServerlessCompat integration: Overriding compat layer DogStatsD pipe name. " +
+                    "Compat layer calculated: {CompatPipeName}, Tracer using: {TracerPipeName}",
+                    returnValue,
+                    pipeName);
+
+                return new CallTargetReturn<string>(pipeName);
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex, "ServerlessCompat integration: Error overriding DogStatsD pipe name");
+            }
+
+            // Fallback to compat layer's original value
+            return new CallTargetReturn<string>(returnValue);
+        }
+    }
+}
+#endif

tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/Serverless/CompatibilityLayer_CalculateTracePipeName_Integration.cs

@@ -0,0 +1,87 @@
+// <copyright file="CompatibilityLayer_CalculateTracePipeName_Integration.cs" company="Datadog">
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc.
+// </copyright>
+
+#nullable enable
+
+#if !NETFRAMEWORK
+using System;
+using System.ComponentModel;
+using Datadog.Trace.ClrProfiler.CallTarget;
+using Datadog.Trace.Configuration;
+using Datadog.Trace.Logging;
+
+namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Serverless
+{
+    /// <summary>
+    /// Instrumentation for Datadog.Serverless.CompatibilityLayer.CalculateTracePipeName method.
+    /// This instrumentation overrides the return value with the tracer's pre-generated pipe name,
+    /// ensuring both the tracer and the compat layer use the same pipe name for communication.
+    /// Version range 0.0.0–1.*.* matches all 0.x and 1.x versions, including the 0.0.0 dev build.
+    /// If the target method doesn't exist (e.g. older/newer compat assembly), the native profiler
+    /// silently skips instrumentation — no exception is thrown.
+    /// </summary>
+    [InstrumentMethod(
+        AssemblyName = "Datadog.Serverless.Compat",
+        TypeName = "Datadog.Serverless.CompatibilityLayer",
+        MethodName = "CalculateTracePipeName",
+        ReturnTypeName = ClrNames.String,
+        ParameterTypeNames = [],
+        MinimumVersion = "0.0.0",
+        MaximumVersion = "1.*.*",
+        IntegrationName = nameof(IntegrationId.ServerlessCompat),
+        InstrumentationCategory = InstrumentationCategory.Tracing)]
+    [Browsable(false)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public sealed class CompatibilityLayer_CalculateTracePipeName_Integration
+    {
+        private static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(CompatibilityLayer_CalculateTracePipeName_Integration));
+
+        /// <summary>
+        /// OnMethodEnd callback - intercepts the return value and overrides it with a unique pipe name
+        /// </summary>
+        /// <typeparam name="TTarget">Type of the target</typeparam>
+        /// <param name="instance">Instance value, aka `this` of the instrumented method (null for static methods)</param>
+        /// <param name="returnValue">The pipe name calculated by the compat layer</param>
+        /// <param name="exception">Exception instance in case the original code threw an exception</param>
+        /// <param name="state">Calltarget state value</param>
+        /// <returns>A unique pipe name for coordination between tracer and compat layer</returns>
+        internal static CallTargetReturn<string> OnMethodEnd<TTarget>(
+            TTarget instance,
+            string returnValue,
+            Exception exception,
+            in CallTargetState state)
+        {
+            if (exception is not null)
+            {
+                // If there was an exception, pass it through
+                return new CallTargetReturn<string>(returnValue);
+            }
+
+            try
+            {
+                // Use the tracer's configured pipe name, which in Azure Functions will be the
+                // unique name generated by ExporterSettings. Fall back to the compat layer's
+                // own calculated name if the tracer isn't initialized yet.
+                var pipeName = Tracer.Instance.Settings?.Manager?.InitialExporterSettings?.TracesPipeName ?? returnValue;
+
+                Log.Debug(
+                    "ServerlessCompat integration: Overriding compat layer trace pipe name. " +
+                    "Compat layer calculated: {CompatPipeName}, Tracer using: {TracerPipeName}",
+                    returnValue,
+                    pipeName);
+
+                return new CallTargetReturn<string>(pipeName);
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex, "ServerlessCompat integration: Error overriding trace pipe name");
+            }
+
+            // Fallback to compat layer's original value
+            return new CallTargetReturn<string>(returnValue);
+        }
+    }
+}
+#endif

tracer/src/Datadog.Trace/Configuration/ExporterSettings.cs

@@ -14,6 +14,7 @@
 using Datadog.Trace.Configuration.ConfigurationSources;
 using Datadog.Trace.Configuration.ConfigurationSources.Telemetry;
 using Datadog.Trace.Configuration.Telemetry;
+using Datadog.Trace.Logging;
 using Datadog.Trace.SourceGenerators;
 using Datadog.Trace.Telemetry;
 using Datadog.Trace.Telemetry.Metrics;
@@ -27,6 +28,8 @@ namespace Datadog.Trace.Configuration
     /// </summary>
     public sealed partial class ExporterSettings
     {
+        private static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(ExporterSettings));
+
         /// <summary>
         /// Allows overriding of file system access for tests.
         /// </summary>
@@ -88,12 +91,31 @@ internal ExporterSettings(Raw rawSettings, Func<string, bool> fileExists, IConfi
 
             ValidationWarnings = new List<string>();
 
+            // In Azure Functions (without AAS Site Extension), generate unique pipe names so each
+            // function instance gets its own pipe even when sharing a hosting plan. The generated names
+            // use the user-configured base name (from any config source) with a unique GUID suffix.
+            string? tracesPipeName;
+            string? metricsPipeName;
+
+            if (Util.EnvironmentHelpers.IsAzureFunctions()
+                && !Util.EnvironmentHelpers.IsUsingAzureAppServicesSiteExtension()
+                && Serverless.ServerlessCompatPipeNameHelper.IsCompatLayerAvailableWithPipeSupport())
+            {
+                tracesPipeName = GenerateUniquePipeName(rawSettings.TracesPipeName, "dd_trace", ConfigurationKeys.TracesPipeName);
+                metricsPipeName = GenerateUniquePipeName(rawSettings.MetricsPipeName, "dd_dogstatsd", ConfigurationKeys.MetricsPipeName);
+            }
+            else
+            {
+                tracesPipeName = rawSettings.TracesPipeName;
+                metricsPipeName = rawSettings.MetricsPipeName;
+            }
+
             var traceSettings = GetTraceTransport(
-                        agentUri: rawSettings.TraceAgentUri,
-                        tracesPipeName: rawSettings.TracesPipeName,
-                        agentHost: rawSettings.TraceAgentHost,
-                        agentPort: rawSettings.TraceAgentPort,
-                        tracesUnixDomainSocketPath: rawSettings.TracesUnixDomainSocketPath);
+                agentUri: rawSettings.TraceAgentUri,
+                tracesPipeName: tracesPipeName,
+                agentHost: rawSettings.TraceAgentHost,
+                agentPort: rawSettings.TraceAgentPort,
+                tracesUnixDomainSocketPath: rawSettings.TracesUnixDomainSocketPath);
 
             TracesEncoding = TracesEncoding.DatadogV0_4;
             TracesTransport = traceSettings.Transport;
@@ -130,7 +152,7 @@ internal ExporterSettings(Raw rawSettings, Func<string, bool> fileExists, IConfi
                 traceAgentUrl: rawSettings.TraceAgentUri,
                 agentHost: rawSettings.TraceAgentHost,
                 dogStatsdPort: rawSettings.DogStatsdPort,
-                metricsPipeName: rawSettings.MetricsPipeName,
+                metricsPipeName: metricsPipeName,
                 metricsUnixDomainSocketPath: rawSettings.MetricsUnixDomainSocketPath);
 
             MetricsHostname = metricsSettings.Hostname;
@@ -325,6 +347,15 @@ private static string GetMetricsHostNameFromAgentUri(Uri agentUri)
             return string.IsNullOrEmpty(traceHostname) ? DefaultDogstatsdHostname : traceHostname;
         }
 
+        private string GenerateUniquePipeName(string? configuredBaseName, string defaultBaseName, string configKey)
+        {
+            var baseName = StringUtil.IsNullOrEmpty(configuredBaseName) ? defaultBaseName : configuredBaseName;
+            var name = Serverless.ServerlessCompatPipeNameHelper.GenerateUniquePipeName(baseName, "ExporterSettings");
+            Log.Information("Azure Functions environment detected. Using pipe base name '{BaseName}', generated unique pipe name: {PipeName}", baseName, name);
+            _telemetry.Record(configKey, name, recordValue: true, ConfigurationOrigins.Calculated);
+            return name;
+        }
+
         private MetricsTransportSettings ConfigureMetricsTransport(string? metricsUrl, string? traceAgentUrl, string? agentHost, int dogStatsdPort, string? metricsPipeName, string? metricsUnixDomainSocketPath)
         {
             if (!string.IsNullOrEmpty(metricsUrl) && TryGetMetricsUriAndTransport(metricsUrl!, out var settingsFromUri))

tracer/src/Datadog.Trace/Configuration/IntegrationId.cs

@@ -90,6 +90,7 @@ internal enum IntegrationId
         AzureEventHubs,
         DatadogTraceVersionConflict,
         Hangfire,
-        OpenFeature
+        OpenFeature,
+        ServerlessCompat
     }
 }

tracer/src/Datadog.Trace/Configuration/supported-configurations.yaml

@@ -1468,6 +1468,15 @@ supportedConfigurations:
       Match all spans that start with "cart" without any limits and any operation name.
           "[{"service": "cart*"}]"
       <seealso cref="Datadog.Trace.Configuration.TracerSettings.SpanSamplingRules"/>
+  DD_SERVERLESS_COMPAT_PATH:
+  - implementation: A
+    type: string
+    default: null
+    const_name: ServerlessCompatPath
+    documentation: |-
+      Overrides the default path to the serverless compatibility layer binary.
+      Default value in windows is <c>C:\home\site\wwwroot\datadog\bin\windows-amd64\datadog-serverless-compat.exe</c>.
+      Default value in linux is <c>/bin/linux-amd64/datadog-serverless-compat</c>.
   DD_SYMBOL_DATABASE_BATCH_SIZE_BYTES:
   - implementation: A
     type: int

tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.g.cs

@@ -242,6 +242,13 @@ internal static partial class ConfigurationKeys
     /// </summary>
     public const string RuntimeMetricsEnabled = "DD_RUNTIME_METRICS_ENABLED";
 
+    /// <summary>
+    /// Overrides the default path to the serverless compatibility layer binary.
+    /// Default value in windows is <c>C:\home\site\wwwroot\datadog\bin\windows-amd64\datadog-serverless-compat.exe</c>.
+    /// Default value in linux is <c>/bin/linux-amd64/datadog-serverless-compat</c>.
+    /// </summary>
+    public const string ServerlessCompatPath = "DD_SERVERLESS_COMPAT_PATH";
+
     /// <summary>
     /// Configuration key for the application's default service name.
     /// Used as the service name for top-level spans,

tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/EnumExtensionsGenerator/IntegrationIdExtensions_EnumExtensions.g.cs

@@ -17,7 +17,7 @@ internal static partial class IntegrationIdExtensions
     /// The number of members in the enum.
     /// This is a non-distinct count of defined names.
     /// </summary>
-    public const int Length = 79;
+    public const int Length = 80;
 
     /// <summary>
     /// Returns the string representation of the <see cref="Datadog.Trace.Configuration.IntegrationId"/> value.
@@ -109,6 +109,7 @@ public static string ToStringFast(this Datadog.Trace.Configuration.IntegrationId
             Datadog.Trace.Configuration.IntegrationId.DatadogTraceVersionConflict => nameof(Datadog.Trace.Configuration.IntegrationId.DatadogTraceVersionConflict),
             Datadog.Trace.Configuration.IntegrationId.Hangfire => nameof(Datadog.Trace.Configuration.IntegrationId.Hangfire),
             Datadog.Trace.Configuration.IntegrationId.OpenFeature => nameof(Datadog.Trace.Configuration.IntegrationId.OpenFeature),
+            Datadog.Trace.Configuration.IntegrationId.ServerlessCompat => nameof(Datadog.Trace.Configuration.IntegrationId.ServerlessCompat),
             _ => value.ToString(),
         };
 
@@ -201,6 +202,7 @@ public static Datadog.Trace.Configuration.IntegrationId[] GetValues()
             Datadog.Trace.Configuration.IntegrationId.DatadogTraceVersionConflict,
             Datadog.Trace.Configuration.IntegrationId.Hangfire,
             Datadog.Trace.Configuration.IntegrationId.OpenFeature,
+            Datadog.Trace.Configuration.IntegrationId.ServerlessCompat,
         };
 
     /// <summary>
@@ -293,5 +295,6 @@ public static string[] GetNames()
             nameof(Datadog.Trace.Configuration.IntegrationId.DatadogTraceVersionConflict),
             nameof(Datadog.Trace.Configuration.IntegrationId.Hangfire),
             nameof(Datadog.Trace.Configuration.IntegrationId.OpenFeature),
+            nameof(Datadog.Trace.Configuration.IntegrationId.ServerlessCompat),
         };
 }