feat(libdatadog-logger): integrate libdatadog logging (#7075)

## Summary of changes

Fixes https://datadoghq.atlassian.net/browse/APMSP-1835

This PR adds enabling the file based logging for libdatadog, ie we start
to write the logs to the configured file as it happens.

## Reason for change

This is missing feature in the native exporter and must have for
troubleshooting.

## Implementation details

This PR DataDog/libdatadog#1018 does the bulk of
the logging setup. In this, we are only calling the exposed APIs.

## Test coverage

Since all the coverage is done in libdatadog there nothing to test in
CI, however I verified manually that log file is created and written.

## Other details
<!-- Fixes #{issue} -->

We will need DataDog/libdatadog#1088 for fully
support the file based logging practices.

Also, we will need a release of libdatadog to pass the CI.

<!-- ⚠️ Note: where possible, please obtain 2 approvals prior to
merging. Unless CODEOWNERS specifies otherwise, for external teams it is
typically best to have one review from a team member, and one review
from apm-dotnet. Trivial changes do not require 2 reviews. -->

---------

Co-authored-by: Andrew Lock <[email protected]>
Co-authored-by: Steven Bouwkamp <[email protected]>

Author: 3 people

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

@@ -107,6 +107,8 @@ internal static void SetDebugEnabledInternal(bool enabled)
                 DatadogLogging.UseDefaultLevel();
             }
 
+            LibDatadog.Logger.Instance.SetLogLevel(debugEnabled: enabled);
+
             TelemetryFactory.Config.Record(ConfigurationKeys.DebugEnabled, enabled, ConfigurationOrigins.Code);
         }
 
@@ -119,6 +121,7 @@ public static void Reload()
         {
             TelemetryFactory.Metrics.Record(PublicApiUsage.GlobalSettings_Reload);
             DatadogLogging.Reset();
+            LibDatadog.Logger.Instance.SetLogLevel(debugEnabled: false);
             GlobalConfigurationSource.Reload();
             Instance = CreateFromDefaultSources();
         }

tracer/src/Datadog.Trace/LibDatadog/Error.cs

@@ -4,6 +4,7 @@
 // </copyright>
 
 #nullable enable
+
 using System;
 using System.Runtime.InteropServices;
 using System.Text;
@@ -12,23 +13,17 @@
 namespace Datadog.Trace.LibDatadog;
 
 /// <summary>
+/// Represents a generic error with message returned by the libdatadog library.
 /// Do not change the values of this enum unless you really need to update the interop mapping.
 /// Libdatadog interop mapping of https://github.com/DataDog/libdatadog/blob/60583218a8de6768f67d04fcd5bc6443f67f516b/ddcommon-ffi/src/error.rs#L14
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
-internal struct Error
+internal readonly struct Error
 {
-    public VecU8 ErrorMessage;
+    internal readonly VecU8 Message;
 
-    internal static string Read(ref Error resultErr)
+    public LibDatadogException ToException()
     {
-        var message = resultErr.ErrorMessage;
-        if (message.Length == 0)
-        {
-            return string.Empty;
-        }
-
-        var errorMessage = NativeStringHelpers.ReadUtf8NativeString(resultErr.ErrorMessage);
-        return errorMessage;
+        return new LibDatadogException(Message.ToUtf8String());
     }
 }

tracer/src/Datadog.Trace/LibDatadog/ErrorHandle.cs

@@ -11,47 +11,35 @@
 
 namespace Datadog.Trace.LibDatadog;
 
-internal class ErrorHandle : SafeHandle
+internal class ErrorHandle() : SafeHandle(IntPtr.Zero, true)
 {
     private static readonly IDatadogLogger Logger = DatadogLogging.GetLoggerFor<ErrorHandle>();
 
-    public ErrorHandle()
-        : base(IntPtr.Zero, true)
-    {
-    }
-
-    public ErrorHandle(IntPtr handle)
-        : base(handle, true)
-    {
-        SetHandle(handle);
-    }
-
     public override bool IsInvalid => handle == IntPtr.Zero;
 
-    protected override bool ReleaseHandle()
+    public void ThrowIfError()
     {
-        try
-        {
-            NativeInterop.Exporter.FreeError(handle);
-        }
-        catch (Exception ex)
+        if (!IsInvalid)
         {
-            Logger.Error(ex, "An error occurred while releasing the handle for ErrorHandle.");
+            var error = Marshal.PtrToStructure<Error>(handle);
+            throw error.ToException();
         }
-
-        return true;
-    }
-
-    public TraceExporterException ToException()
-    {
-        return new TraceExporterException(Marshal.PtrToStructure<TraceExporterError>(handle));
     }
 
-    public void ThrowIfError()
+    protected override bool ReleaseHandle()
     {
         if (!IsInvalid)
         {
-            throw ToException();
+            try
+            {
+                NativeInterop.Common.Drop(this);
+            }
+            catch (Exception ex)
+            {
+                Logger.Error(ex, "Failed to drop error handle");
+            }
         }
+
+        return true;
     }
 }

tracer/src/Datadog.Trace/LibDatadog/FileConfig.cs

@@ -0,0 +1,36 @@
+// <copyright file="FileConfig.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.Runtime.InteropServices;
+
+namespace Datadog.Trace.LibDatadog;
+
+/// <summary>
+/// Represents a configuration for a file logger.
+/// </summary>
+[StructLayout(LayoutKind.Sequential)]
+internal struct FileConfig
+{
+    /// <summary>
+    /// The path to the log file.
+    /// If the intermediate directory does not exist, it will be created while configuring the logger.
+    /// </summary>
+    public CharSlice Path;
+
+    /// <summary>
+    /// The maximum total number of files (current + rotated) to keep on disk.
+    /// When this limit is exceeded, the oldest rotated files are deleted.
+    /// Set to 0 to disable file cleanup.
+    /// </summary>
+    public ulong MaxFiles;
+
+    /// <summary>
+    /// The maximum size in bytes for each log file.
+    /// Set to 0 to disable size-based rotation.
+    /// </summary>
+    public ulong MaxSizeBytes;
+}

tracer/src/Datadog.Trace/LibDatadog/LibDatadogException.cs

@@ -0,0 +1,23 @@
+// <copyright file="LibDatadogException.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;
+
+namespace Datadog.Trace.LibDatadog;
+
+internal class LibDatadogException : Exception
+{
+    public LibDatadogException(string message)
+        : base(message)
+    {
+    }
+
+    public LibDatadogException(string message, Exception innerException)
+        : base(message, innerException)
+    {
+    }
+}

tracer/src/Datadog.Trace/LibDatadog/LogEventLevel.cs

@@ -0,0 +1,24 @@
+// <copyright file="LogEventLevel.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
+
+namespace Datadog.Trace.LibDatadog;
+
+/// <summary>
+/// Represents the level of a log event.
+/// <remarks>
+/// The levels are mapped to the levels defined in the libdatadog library.
+/// In case of a missing direct mapping, the closest level should be used.
+/// </remarks>
+/// </summary>
+internal enum LogEventLevel
+{
+    Trace = 0,
+    Debug = 1,
+    Info = 2,
+    Warn = 3,
+    Error = 4,
+}

tracer/src/Datadog.Trace/LibDatadog/LogEventLevelExtension.cs

@@ -0,0 +1,25 @@
+// <copyright file="LogEventLevelExtension.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;
+
+namespace Datadog.Trace.LibDatadog;
+
+internal static class LogEventLevelExtension
+{
+    public static LogEventLevel ToLogEventLevel(this Vendors.Serilog.Events.LogEventLevel level)
+        => level switch
+        {
+            Vendors.Serilog.Events.LogEventLevel.Verbose => LogEventLevel.Trace,
+            Vendors.Serilog.Events.LogEventLevel.Debug => LogEventLevel.Debug,
+            Vendors.Serilog.Events.LogEventLevel.Information => LogEventLevel.Info,
+            Vendors.Serilog.Events.LogEventLevel.Warning => LogEventLevel.Warn,
+            // We don't have a "Fatal" level in libdatadog, so we map everything else to Error
+            // We also don't want to risk throwing
+            _ => LogEventLevel.Error,
+        };
+}

tracer/src/Datadog.Trace/LibDatadog/Logger.cs

@@ -0,0 +1,102 @@
+// <copyright file="Logger.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 System.Globalization;
+using System.IO;
+using Datadog.Trace.Logging;
+using Datadog.Trace.Logging.Internal.Configuration;
+using Datadog.Trace.Util;
+
+namespace Datadog.Trace.LibDatadog;
+
+internal sealed class Logger
+{
+    private static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor<Logger>();
+
+    private bool _loggingEnabled = false;
+
+    public static Logger Instance { get; } = new();
+
+    public void Enable(FileLoggingConfiguration fileConfig, DomainMetadata domainMetadata)
+    {
+        // Rebuild the logger even if it has already been enabled, in case any configuration has changed
+
+        var filePath = Path.Combine(
+            fileConfig.LogDirectory,
+            $"dotnet-tracer-libdatadog-{domainMetadata.ProcessName}-{domainMetadata.ProcessId.ToString(CultureInfo.InvariantCulture)}.log");
+
+        using var path = new CharSlice(filePath);
+        var cfg = new FileConfig
+        {
+            Path = path,
+            MaxFiles = 31, // Matches existing Serilog configuration
+            MaxSizeBytes = (ulong)fileConfig.MaxLogFileSizeBytes,
+        };
+
+        try
+        {
+            Log.Debug("Enabling libdatadog logger");
+            using var error = NativeInterop.Logger.ConfigureFile(cfg);
+            error.ThrowIfError();
+            _loggingEnabled = true;
+        }
+        catch (Exception ex)
+        {
+            _loggingEnabled = false;
+            Log.Error(ex, "Failed to configure libdatadog logger");
+        }
+    }
+
+    public void Disable()
+    {
+        if (!_loggingEnabled)
+        {
+            Log.Debug("Libdatadog logging is not enabled, skipping disable operation.");
+            return;
+        }
+
+        try
+        {
+            Log.Debug("Disabling libdatadog logger");
+            using var error = NativeInterop.Logger.DisableFile();
+            error.ThrowIfError();
+            _loggingEnabled = false;
+        }
+        catch (Exception ex)
+        {
+            Log.Error(ex, "Failed to disable libdatadog logger");
+        }
+    }
+
+    public void SetLogLevel(bool debugEnabled)
+    {
+        var logLevel = debugEnabled ? Vendors.Serilog.Events.LogEventLevel.Debug : DatadogLogging.DefaultLogLevel;
+        SetLogLevel(logLevel);
+    }
+
+    private void SetLogLevel(Vendors.Serilog.Events.LogEventLevel logLevel)
+    {
+        if (!_loggingEnabled)
+        {
+            // This could happen if, for example, datapipeline is enabled, and we trigger a tracer flare to change the log level.
+            Log.Information("Attempted to set libdatadog log level to {LogLevel} without enabling logging first", logLevel);
+            return;
+        }
+
+        var level = logLevel.ToLogEventLevel();
+        try
+        {
+            using var error = NativeInterop.Logger.SetLogLevel(level);
+            error.ThrowIfError();
+        }
+        catch (Exception ex)
+        {
+            Log.Error(ex, "Failed to set libdatadog log level");
+        }
+    }
+}