Add ActivityEventAttachingLogProcessor to build ActivityEvents from logs

examples/AspNetCore/Controllers/WeatherForecastController.cs

@@ -20,6 +20,7 @@
 using System.Net.Http;
 using Examples.AspNetCore.Models;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
 
 namespace Examples.AspNetCore.Controllers
 {
@@ -32,23 +33,37 @@ public class WeatherForecastController : ControllerBase
             "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching",
         };
 
-        private static HttpClient httpClient = new HttpClient();
+        private static readonly HttpClient HttpClient = new HttpClient();
+
+        private readonly ILogger<WeatherForecastController> logger;
+
+        public WeatherForecastController(ILogger<WeatherForecastController> logger)
+        {
+            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        }
 
         [HttpGet]
         public IEnumerable<WeatherForecast> Get()
         {
             // Making an http call here to serve as an example of
             // how dependency calls will be captured and treated
             // automatically as child of incoming request.
-            var res = httpClient.GetStringAsync("http://google.com").Result;
+            var res = HttpClient.GetStringAsync("http://google.com").Result;
             var rng = new Random();
-            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
+            var forecast = Enumerable.Range(1, 5).Select(index => new WeatherForecast
             {
                 Date = DateTime.Now.AddDays(index),
                 TemperatureC = rng.Next(-20, 55),
                 Summary = Summaries[rng.Next(Summaries.Length)],
             })
             .ToArray();
+
+            this.logger.LogInformation(
+                "WeatherForecasts generated {count}: {forecasts}",
+                forecast.Length,
+                new { forecast });
+
+            return forecast;
         }
     }
 }

examples/AspNetCore/Program.cs

@@ -15,7 +15,9 @@
 // </copyright>
 
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
 
 namespace Examples.AspNetCore
 {
@@ -31,6 +33,23 @@ public static IHostBuilder CreateHostBuilder(string[] args) =>
                 .ConfigureWebHostDefaults(webBuilder =>
                 {
                     webBuilder.UseStartup<Startup>();
+                })
+                .ConfigureLogging((context, builder) =>
+                {
+                    builder.ClearProviders();
+                    builder.AddConsole();
+
+                    var attachLogsToActivity = context.Configuration.GetValue<bool>("AttachLogsToActivity");
+                    if (attachLogsToActivity)
+                    {
+                        builder.AddOpenTelemetry(options =>
+                        {
+                            options.IncludeScopes = true;
+                            options.ParseStateValues = true;
+                            options.IncludeMessage = true;
+                            options.AddActivityEventAttachingLogProcessor();
+                        });
+                    }
                 });
     }
 }

examples/AspNetCore/appsettings.json

@@ -7,6 +7,7 @@
     }
   },
   "AllowedHosts": "*",
+  "AttachLogsToActivity": true,
   "UseExporter": "console",
   "Jaeger": {
     "ServiceName": "jaeger-test",

src/OpenTelemetry/.publicApi/net461/PublicAPI.Unshipped.txt

@@ -0,0 +1,16 @@
+OpenTelemetry.Logs.ActivityEventAttachingLogProcessorOptions
+OpenTelemetry.Logs.ActivityEventAttachingLogProcessorOptions.ActivityEventAttachingLogProcessorOptions() -> void
+OpenTelemetry.Logs.ActivityEventAttachingLogProcessorOptions.ScopeConverter.get -> System.Action<System.Diagnostics.ActivityTagsCollection, int, object>
+OpenTelemetry.Logs.ActivityEventAttachingLogProcessorOptions.ScopeConverter.set -> void
+OpenTelemetry.Logs.ActivityEventAttachingLogProcessorOptions.StateConverter.get -> System.Action<System.Diagnostics.ActivityTagsCollection, System.Collections.Generic.IReadOnlyList<System.Collections.Generic.KeyValuePair<string, object>>>
+OpenTelemetry.Logs.ActivityEventAttachingLogProcessorOptions.StateConverter.set -> void
+OpenTelemetry.Logs.LogRecord.ForEachScope<TState>(System.Action<object, TState> callback, TState state) -> void
+OpenTelemetry.Logs.LogRecord.Message.get -> string
+OpenTelemetry.Logs.LogRecord.StateValues.get -> System.Collections.Generic.IReadOnlyList<System.Collections.Generic.KeyValuePair<string, object>>
+OpenTelemetry.Logs.OpenTelemetryLoggerOptions.IncludeMessage.get -> bool
+OpenTelemetry.Logs.OpenTelemetryLoggerOptions.IncludeMessage.set -> void
+OpenTelemetry.Logs.OpenTelemetryLoggerOptions.IncludeScopes.get -> bool
+OpenTelemetry.Logs.OpenTelemetryLoggerOptions.IncludeScopes.set -> void
+OpenTelemetry.Logs.OpenTelemetryLoggerOptions.ParseStateValues.get -> bool
+OpenTelemetry.Logs.OpenTelemetryLoggerOptions.ParseStateValues.set -> void
+static Microsoft.Extensions.Logging.OpenTelemetryLoggingExtensions.AddActivityEventAttachingLogProcessor(this OpenTelemetry.Logs.OpenTelemetryLoggerOptions loggerOptions, System.Action<OpenTelemetry.Logs.ActivityEventAttachingLogProcessorOptions> configure = null) -> OpenTelemetry.Logs.OpenTelemetryLoggerOptions

src/OpenTelemetry/.publicApi/netstandard2.0/PublicAPI.Unshipped.txt

@@ -0,0 +1,16 @@
+OpenTelemetry.Logs.ActivityEventAttachingLogProcessorOptions
+OpenTelemetry.Logs.ActivityEventAttachingLogProcessorOptions.ActivityEventAttachingLogProcessorOptions() -> void
+OpenTelemetry.Logs.ActivityEventAttachingLogProcessorOptions.ScopeConverter.get -> System.Action<System.Diagnostics.ActivityTagsCollection, int, object>
+OpenTelemetry.Logs.ActivityEventAttachingLogProcessorOptions.ScopeConverter.set -> void
+OpenTelemetry.Logs.ActivityEventAttachingLogProcessorOptions.StateConverter.get -> System.Action<System.Diagnostics.ActivityTagsCollection, System.Collections.Generic.IReadOnlyList<System.Collections.Generic.KeyValuePair<string, object>>>
+OpenTelemetry.Logs.ActivityEventAttachingLogProcessorOptions.StateConverter.set -> void
+OpenTelemetry.Logs.LogRecord.ForEachScope<TState>(System.Action<object, TState> callback, TState state) -> void
+OpenTelemetry.Logs.LogRecord.Message.get -> string
+OpenTelemetry.Logs.LogRecord.StateValues.get -> System.Collections.Generic.IReadOnlyList<System.Collections.Generic.KeyValuePair<string, object>>
+OpenTelemetry.Logs.OpenTelemetryLoggerOptions.IncludeMessage.get -> bool
+OpenTelemetry.Logs.OpenTelemetryLoggerOptions.IncludeMessage.set -> void
+OpenTelemetry.Logs.OpenTelemetryLoggerOptions.IncludeScopes.get -> bool
+OpenTelemetry.Logs.OpenTelemetryLoggerOptions.IncludeScopes.set -> void
+OpenTelemetry.Logs.OpenTelemetryLoggerOptions.ParseStateValues.get -> bool
+OpenTelemetry.Logs.OpenTelemetryLoggerOptions.ParseStateValues.set -> void
+static Microsoft.Extensions.Logging.OpenTelemetryLoggingExtensions.AddActivityEventAttachingLogProcessor(this OpenTelemetry.Logs.OpenTelemetryLoggerOptions loggerOptions, System.Action<OpenTelemetry.Logs.ActivityEventAttachingLogProcessorOptions> configure = null) -> OpenTelemetry.Logs.OpenTelemetryLoggerOptions

src/OpenTelemetry/Internal/OpenTelemetrySdkEventSource.cs

@@ -89,6 +89,15 @@ public void MetricControllerException(Exception ex)
             }
         }
 
+        [NonEvent]
+        public void LogProcessorException(string @event, Exception ex)
+        {
+            if (this.IsEnabled(EventLevel.Error, (EventKeywords)(-1)))
+            {
+                this.LogProcessorException(@event, ex.ToInvariantString());
+            }
+        }
+
         [NonEvent]
         public void ActivityStarted(Activity activity)
         {
@@ -287,6 +296,12 @@ public void TracerProviderException(string evnt, string ex)
             this.WriteEvent(28, evnt, ex);
         }
 
+        [Event(29, Message = "Unknown error in LogProcessor event '{0}': '{1}'.", Level = EventLevel.Error)]
+        public void LogProcessorException(string @event, string exception)
+        {
+            this.WriteEvent(29, @event, exception);
+        }
+
 #if DEBUG
         public class OpenTelemetryEventListener : EventListener
         {

src/OpenTelemetry/Logs/ActivityEventAttachingLogProcessor.cs

@@ -0,0 +1,112 @@
+// <copyright file="ActivityEventAttachingLogProcessor.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+#if NET461 || NETSTANDARD2_0
+using System;
+using System.Diagnostics;
+using OpenTelemetry.Internal;
+using OpenTelemetry.Trace;
+
+namespace OpenTelemetry.Logs
+{
+    internal class ActivityEventAttachingLogProcessor : BaseProcessor<LogRecord>
+    {
+        private static readonly Action<object, State> ProcessScopeRef = ProcessScope;
+
+        private readonly ActivityEventAttachingLogProcessorOptions options;
+
+        public ActivityEventAttachingLogProcessor(ActivityEventAttachingLogProcessorOptions options)
+        {
+            this.options = options ?? throw new ArgumentNullException(nameof(options));
+        }
+
+        public override void OnEnd(LogRecord data)
+        {
+            Activity activity = Activity.Current;
+
+            if (activity?.IsAllDataRequested == true)
+            {
+                var tags = new ActivityTagsCollection
+                {
+                    { nameof(data.CategoryName), data.CategoryName },
+                    { nameof(data.LogLevel), data.LogLevel },
+                };
+
+                if (data.EventId != 0)
+                {
+                    tags[nameof(data.EventId)] = data.EventId;
+                }
+
+                var activityEvent = new ActivityEvent("log", data.Timestamp, tags);
+
+                data.ForEachScope(
+                    ProcessScopeRef,
+                    new State
+                    {
+                        Tags = tags,
+                        Processor = this,
+                    });
+
+                if (data.StateValues != null)
+                {
+                    try
+                    {
+                        this.options.StateConverter?.Invoke(tags, data.StateValues);
+                    }
+                    catch (Exception ex)
+                    {
+                        OpenTelemetrySdkEventSource.Log.LogProcessorException($"Processing state of type [{data.State.GetType().FullName}]", ex);
+                    }
+                }
+
+                if (!string.IsNullOrEmpty(data.Message))
+                {
+                    tags["Message"] = data.Message;
+                }
+
+                activity.AddEvent(activityEvent);
+
+                if (data.Exception != null)
+                {
+                    activity.RecordException(data.Exception);
+                }
+            }
+        }
+
+        private static void ProcessScope(object scope, State state)
+        {
+            if (scope != null)
+            {
+                try
+                {
+                    state.Processor.options.ScopeConverter?.Invoke(state.Tags, state.Index++, scope);
+                }
+                catch (Exception ex)
+                {
+                    OpenTelemetrySdkEventSource.Log.LogProcessorException($"Processing scope of type [{scope.GetType().FullName}]", ex);
+                }
+            }
+        }
+
+        private class State
+        {
+            public ActivityTagsCollection Tags;
+            public int Index;
+            public ActivityEventAttachingLogProcessor Processor;
+        }
+    }
+}
+#endif

src/OpenTelemetry/Logs/ActivityEventAttachingLogProcessorOptions.cs

@@ -0,0 +1,37 @@
+// <copyright file="ActivityEventAttachingLogProcessorOptions.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+#if NET461 || NETSTANDARD2_0
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace OpenTelemetry.Logs
+{
+    public class ActivityEventAttachingLogProcessorOptions
+    {
+        /// <summary>
+        /// Gets or sets the callback action used to convert log state to tags.
+        /// </summary>
+        public Action<ActivityTagsCollection, IReadOnlyList<KeyValuePair<string, object>>> StateConverter { get; set; } = DefaultLogStateConverter.ConvertState;
+
+        /// <summary>
+        /// Gets or sets the callback action used to convert log scopes to tags.
+        /// </summary>
+        public Action<ActivityTagsCollection, int, object> ScopeConverter { get; set; } = DefaultLogStateConverter.ConvertScope;
+    }
+}
+#endif