DataDog · thedavl · Aug 7, 2023 · May 27, 2023 · Jun 1, 2023 · Jun 1, 2023
@@ -199,6 +199,8 @@
       <type fullname="System.Diagnostics.DiagnosticListener" />
    </assembly>
    <assembly fullname="System.Diagnostics.Process">
+      <type fullname="System.Diagnostics.DataReceivedEventArgs" />
+      <type fullname="System.Diagnostics.DataReceivedEventHandler" />
       <type fullname="System.Diagnostics.Process" />
       <type fullname="System.Diagnostics.ProcessStartInfo" />
       <type fullname="System.Diagnostics.ProcessThreadCollection" />

@@ -0,0 +1,165 @@
+// <copyright file="ServerlessMiniAgent.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>
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using Datadog.Trace.Configuration;
+using Datadog.Trace.Logging;
+using Datadog.Trace.Util;
+
+namespace Datadog.Trace.ClrProfiler.ServerlessInstrumentation;
+
+internal static class ServerlessMiniAgent
+{
+    private static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(ServerlessMiniAgent));
+
+    internal static string GetMiniAgentPath(PlatformID os, ImmutableTracerSettings settings)
+    {
+        if (!settings.IsRunningInGCPFunctions && !settings.IsRunningInAzureFunctionsConsumptionPlan)
+        {
+            return null;
+        }
+
+        if (EnvironmentHelpers.GetEnvironmentVariable("DD_MINI_AGENT_PATH") is { } path)
+        {
+            return path;
+        }
+
+        // Environment.OSVersion.Platform can return PlatformID.Unix on MacOS, this is OK as GCP & Azure don't have MacOs functions.
+        if (os != PlatformID.Unix && os != PlatformID.Win32NT)
+        {
+            Log.Error("Serverless Mini Agent is only supported on Windows and Linux.");
+            return null;
+        }
+
+        string rustBinaryPathRoot;
+        if (settings.IsRunningInGCPFunctions)
+        {
+            rustBinaryPathRoot = Path.Combine(Path.DirectorySeparatorChar.ToString(), "layers", "google.dotnet.publish", "publish", "bin");
+        }
+        else
+        {
+            rustBinaryPathRoot = Path.Combine(Path.DirectorySeparatorChar.ToString(), "home", "site", "wwwroot");
+        }
+
+        var isWindows = os == PlatformID.Win32NT;
+
+        string rustBinaryPathOsFolder = isWindows ? "datadog-serverless-agent-windows-amd64" : "datadog-serverless-agent-linux-amd64";
+        string rustBinaryName = isWindows ? "datadog-serverless-trace-mini-agent.exe" : "datadog-serverless-trace-mini-agent";
+        return Path.Combine(rustBinaryPathRoot, rustBinaryPathOsFolder, rustBinaryName);
+    }
+
+    internal static void StartServerlessMiniAgent(ImmutableTracerSettings settings)
+    {
+        var serverlessMiniAgentPath = ServerlessMiniAgent.GetMiniAgentPath(Environment.OSVersion.Platform, settings);
+        if (string.IsNullOrEmpty(serverlessMiniAgentPath))
+        {
+            return;
+        }
+
+        if (!File.Exists(serverlessMiniAgentPath))
+        {
+            Log.Error("Serverless Mini Agent does not exist: {Path}", serverlessMiniAgentPath);
+            return;
+        }
+
+        try
+        {
+            Log.Debug("Trying to spawn the Serverless Mini Agent at path: {Path}", serverlessMiniAgentPath);
+            Process process = new Process();
+            process.StartInfo.FileName = serverlessMiniAgentPath;
+            process.StartInfo.UseShellExecute = false;
+            process.StartInfo.RedirectStandardOutput = true;
+            process.OutputDataReceived += MiniAgentDataReceivedHandler;
+
+            process.Start();
+            process.BeginOutputReadLine();
+        }
+        catch (Exception ex)
+        {
+            Log.Error(ex, "Error spawning the Serverless Mini Agent.");
+        }
+    }
+
+    // Tries to clean Mini Agent logs and log to the correct level, otherwise just logs the data as-is to Info
+    // Mini Agent logs will be prefixed with "[Datadog Serverless Mini Agent]"
+    private static void MiniAgentDataReceivedHandler(object sender, DataReceivedEventArgs outLine)
+    {
+        var data = outLine.Data;
+        if (string.IsNullOrEmpty(data))
+        {
+            return;
+        }
+
+        var level = "INFO";
+        var log = data;
+        ProcessMiniAgentLog(data, out level, out log);
+
+        switch (level)
+        {
+            case "ERROR":
+                Log.Error("[Datadog Serverless Mini Agent] {Data}", log);
+                break;
+            case "WARN":
+                Log.Warning("[Datadog Serverless Mini Agent] {Data}", log);
+                break;
+            case "INFO":
+                Log.Information("[Datadog Serverless Mini Agent] {Data}", log);
+                break;
+            case "DEBUG":
+                Log.Debug("[Datadog Serverless Mini Agent] {Data}", log);
+                break;
+            default:
+                Log.Information("[Datadog Serverless Mini Agent] {Data}", data);
+                break;
+        }
+    }
+
+    // Processes a raw log from the mini agent, modifying two "out" parameters level and log.
+    // For example, given this raw log:
+    // [2023-06-06T01:31:30Z DEBUG datadog_trace_mini_agent::mini_agent] Random log
+    // level and log will be the following values:
+    // level == "DEBUG", log == "Random log"
+    internal static void ProcessMiniAgentLog(string rawLog, out string level, out string log)
+    {
+        level = "INFO";
+        log = rawLog;
+
+        int logPrefixCutoff = rawLog.IndexOf("]");
+        if (logPrefixCutoff < 0 || logPrefixCutoff == rawLog.Length - 1)
+        {
+            return;
+        }
+
+        int levelLeftBound = rawLog.IndexOf(" ");
+        if (levelLeftBound < 0)
+        {
+            return;
+        }
+
+        int levelRightBound = rawLog.IndexOf(" ", levelLeftBound + 1);
+        if (levelRightBound < 0 || levelRightBound - levelLeftBound < 1)
+        {
+            return;
+        }
+
+        string parsedLevel = rawLog.Substring(levelLeftBound + 1, levelRightBound - levelLeftBound - 1);
+
+        if (!(parsedLevel is "ERROR" or "WARN" or "INFO" or "DEBUG"))
+        {
+            return;
+        }
+
+        level = parsedLevel;
+        log = rawLog.Substring(logPrefixCutoff + 2);
+
+        if (level is "DEBUG")
+        {
+            level = "INFO";
+            log = $"[DEBUG] {log}";
+        }
+    }
+}
@@ -75,6 +75,12 @@ internal class AzureAppService
             /// Used to force the loader to start dogstatsd (in case automatic instrumentation is disabled)
             /// </summary>
             public const string AasEnableCustomMetrics = "DD_AAS_ENABLE_CUSTOM_METRICS";
+
+            /// <summary>
+            /// Used to identify consumption plan functions. Consumption plans will either not have this variable,
+            /// or will have a value of "dynamic".
+            /// </summary>
+            public const string WebsiteSKU = "WEBSITE_SKU";
         }
     }
 }
@@ -0,0 +1,36 @@
+// <copyright file="ConfigurationKeys.GCPFunction.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>
+
+namespace Datadog.Trace.Configuration
+{
+    internal partial class ConfigurationKeys
+    {
+        // GCP Function auto-set env var reference: https://cloud.google.com/functions/docs/configuring/env-var#runtime_environment_variables_set_automatically
+        internal class GCPFunction
+        {
+            /// <summary>
+            /// The name of functions running deprecated runtimes.
+            /// </summary>
+            internal const string DeprecatedFunctionNameKey = "FUNCTION_NAME";
+
+            /// <summary>
+            /// The name of the gcp project a deprecated function belongs to. Only set in functions running deprecated runtimes.
+            /// Used to tell whether or not we are in a deprecated function environment.
+            /// </summary>
+            internal const string DeprecatedProjectKey = "GCP_PROJECT";
+
+            /// <summary>
+            /// The name of functions running non-deprecated runtimes.
+            /// </summary>
+            internal const string FunctionNameKey = "K_SERVICE";
+
+            /// <summary>
+            /// The name of the function handler to be executed when the function is invoked. Only set in functions running non-deprecated runtimes.
+            /// Used to tell whether or not we are in a non-deprecated function environment.
+            /// </summary>
+            internal const string FunctionTargetKey = "FUNCTION_TARGET";
+        }
+    }
+}
@@ -57,6 +57,8 @@ public ImmutableAzureAppServiceSettings(IConfigurationSource? source, IConfigura
             FunctionsWorkerRuntime = config.WithKeys(ConfigurationKeys.AzureAppService.FunctionsWorkerRuntimeKey).AsString();
             FunctionsExtensionVersion = config.WithKeys(ConfigurationKeys.AzureAppService.FunctionsExtensionVersionKey).AsString();
 
+            WebsiteSKU = config.WithKeys(ConfigurationKeys.AzureAppService.WebsiteSKU).AsString();
+
             if (FunctionsWorkerRuntime is not null || FunctionsExtensionVersion is not null)
             {
                 AzureContext = AzureContext.AzureFunctions;
@@ -68,6 +70,7 @@ public ImmutableAzureAppServiceSettings(IConfigurationSource? source, IConfigura
                     SiteKind = "functionapp";
                     SiteType = "function";
                     IsFunctionsApp = true;
+                    IsFunctionsAppConsumptionPlan = GetIsFunctionsAppConsumptionPlan(source, telemetry);
                     IsIsolatedFunctionsApp = FunctionsWorkerRuntime?.EndsWith("-isolated", StringComparison.OrdinalIgnoreCase) == true;
                     PlatformStrategy.ShouldSkipClientSpan = ShouldSkipClientSpanWithinFunctions;
                     break;
@@ -115,6 +118,10 @@ public ImmutableAzureAppServiceSettings(IConfigurationSource? source, IConfigura
 
         public bool IsFunctionsApp { get; private set; }
 
+        public bool IsFunctionsAppConsumptionPlan { get; }
+
+        public string? WebsiteSKU { get; }
+
         public string? FunctionsExtensionVersion { get; }
 
         public string? FunctionsWorkerRuntime { get; }
@@ -183,5 +190,17 @@ private static bool ShouldSkipClientSpanWithinFunctions(Scope? scope)
 
             return null;
         }
+
+        public static bool GetIsFunctionsAppConsumptionPlan(IConfigurationSource source, IConfigurationTelemetry telemetry)
+        {
+            var config = new ConfigurationBuilder(source, telemetry);
+            var websiteSKU = config.WithKeys(ConfigurationKeys.AzureAppService.WebsiteSKU).AsString();
+
+            var functionsExtensionVersion = config.WithKeys(ConfigurationKeys.AzureAppService.FunctionsExtensionVersionKey).AsString();
+            var functionsWorkerRuntime = config.WithKeys(ConfigurationKeys.AzureAppService.FunctionsWorkerRuntimeKey).AsString();
+            var isFunctionApp = functionsExtensionVersion is not null || functionsWorkerRuntime is not null;
+
+            return websiteSKU is "Dynamic" or null && isFunctionApp;
+        }
     }
 }
@@ -0,0 +1,42 @@
+// <copyright file="ImmutableGCPFunctionSettings.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
+
+using System;
+using Datadog.Trace.Configuration.Telemetry;
+
+namespace Datadog.Trace.Configuration
+{
+    /// <summary>
+    /// Settings class for gathering metadata about the execution context in Google Cloud Functions
+    /// References:
+    /// https://cloud.google.com/functions/docs/configuring/env-var#runtime_environment_variables_set_automatically
+    /// </summary>
+    internal class ImmutableGCPFunctionSettings
+    {
+        public ImmutableGCPFunctionSettings(IConfigurationSource? source, IConfigurationTelemetry telemetry)
+        {
+            source ??= NullConfigurationSource.Instance;
+            var config = new ConfigurationBuilder(source, telemetry);
+
+            var deprecatedFunctionKey = config.WithKeys(ConfigurationKeys.GCPFunction.DeprecatedFunctionNameKey).AsString();
+            var deprecatedProjectKey = config.WithKeys(ConfigurationKeys.GCPFunction.DeprecatedProjectKey).AsString();
+            IsDeprecatedFunction = deprecatedFunctionKey != null && deprecatedProjectKey != null;
+
+            var functionNameKey = config.WithKeys(ConfigurationKeys.GCPFunction.FunctionNameKey).AsString();
+            var functionTargetKey = config.WithKeys(ConfigurationKeys.GCPFunction.FunctionTargetKey).AsString();
+            IsNewerFunction = functionNameKey != null && functionTargetKey != null;
+
+            IsGCPFunction = IsDeprecatedFunction || IsNewerFunction;
+        }
+
+        public bool IsGCPFunction { get; }
+
+        public bool IsDeprecatedFunction { get; }
+
+        public bool IsNewerFunction { get; }
+    }
+}
@@ -152,6 +152,10 @@ internal ImmutableTracerSettings(TracerSettings settings, bool unusedParamNotToU
             IsRunningInAzureAppService = settings.IsRunningInAzureAppService;
             AzureAppServiceMetadata = settings.AzureAppServiceMetadata;
 
+            IsRunningInAzureFunctionsConsumptionPlan = settings.IsRunningInAzureFunctionsConsumptionPlan;
+
+            IsRunningInGCPFunctions = settings.IsRunningInGCPFunctions;
+
             TraceId128BitGenerationEnabled = settings.TraceId128BitGenerationEnabled;
             TraceId128BitLoggingEnabled = settings.TraceId128BitLoggingEnabled;
 
@@ -492,6 +496,17 @@ internal ImmutableTracerSettings(TracerSettings settings, bool unusedParamNotToU
         /// </summary>
         internal bool IsRunningInAzureAppService { get; }
 
+        /// <summary>
+        /// Gets a value indicating whether the tracer is running in Azure Functions
+        /// on a consumption plan
+        /// </summary>
+        internal bool IsRunningInAzureFunctionsConsumptionPlan { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether the tracer is running in Google Cloud Functions
+        /// </summary>
+        internal bool IsRunningInGCPFunctions { get; }
+
         /// <summary>
         /// Gets a value indicating whether the tracer should propagate service data in db queries
         /// </summary>
@@ -515,6 +530,11 @@ internal ImmutableTracerSettings(TracerSettings settings, bool unusedParamNotToU
         /// </summary>
         internal ImmutableAzureAppServiceSettings? AzureAppServiceMetadata { get; }
 
+        /// <summary>
+        /// Gets the GCP Function settings
+        /// </summary>
+        internal ImmutableGCPFunctionSettings? GCPFunctionSettings { get; }
+
         /// <summary>
         /// Gets a value indicating whether to calculate the peer.service tag from predefined precursor attributes when using the v0 schema.
         /// </summary>