392 lines
16 KiB
C#
392 lines
16 KiB
C#
// <copyright file="OpenTelemetryEventSourceLogEmitterTests.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>
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Diagnostics.Tracing;
|
|
using System.Globalization;
|
|
using Microsoft.Extensions.Logging;
|
|
using OpenTelemetry.Logs;
|
|
using Xunit;
|
|
|
|
namespace OpenTelemetry.Extensions.EventSource.Tests
|
|
{
|
|
public class OpenTelemetryEventSourceLogEmitterTests
|
|
{
|
|
[Theory]
|
|
[InlineData(true)]
|
|
[InlineData(false)]
|
|
public void OpenTelemetryEventSourceLogEmitterDisposesProviderTests(bool dispose)
|
|
{
|
|
List<LogRecord> exportedItems = new();
|
|
|
|
#pragma warning disable CA2000 // Dispose objects before losing scope
|
|
var openTelemetryLoggerProvider = new WrappedOpenTelemetryLoggerProvider(options =>
|
|
{
|
|
options.AddInMemoryExporter(exportedItems);
|
|
});
|
|
#pragma warning restore CA2000 // Dispose objects before losing scope
|
|
|
|
using (var openTelemetryEventSourceLogEmitter = new OpenTelemetryEventSourceLogEmitter(
|
|
openTelemetryLoggerProvider,
|
|
(name) => null,
|
|
disposeProvider: dispose))
|
|
{
|
|
}
|
|
|
|
Assert.Equal(dispose, openTelemetryLoggerProvider.Disposed);
|
|
|
|
if (!dispose)
|
|
{
|
|
openTelemetryLoggerProvider.Dispose();
|
|
}
|
|
|
|
Assert.True(openTelemetryLoggerProvider.Disposed);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("OpenTelemetry.Extensions.EventSource.Tests", EventLevel.LogAlways, 2)]
|
|
[InlineData("OpenTelemetry.Extensions.EventSource.Tests", EventLevel.Warning, 1)]
|
|
[InlineData("_invalid_", EventLevel.LogAlways, 0)]
|
|
public void OpenTelemetryEventSourceLogEmitterFilterTests(string sourceName, EventLevel? eventLevel, int expectedNumberOfLogRecords)
|
|
{
|
|
List<LogRecord> exportedItems = new();
|
|
|
|
#pragma warning disable CA2000 // Dispose objects before losing scope
|
|
var openTelemetryLoggerProvider = new WrappedOpenTelemetryLoggerProvider(options =>
|
|
{
|
|
options.AddInMemoryExporter(exportedItems);
|
|
});
|
|
#pragma warning restore CA2000 // Dispose objects before losing scope
|
|
|
|
using (var openTelemetryEventSourceLogEmitter = new OpenTelemetryEventSourceLogEmitter(
|
|
openTelemetryLoggerProvider,
|
|
(name) => name == sourceName ? eventLevel : null))
|
|
{
|
|
TestEventSource.Log.SimpleEvent();
|
|
TestEventSource.Log.ComplexEvent("Test_Message", 18);
|
|
}
|
|
|
|
Assert.Equal(expectedNumberOfLogRecords, exportedItems.Count);
|
|
}
|
|
|
|
[Fact]
|
|
public void OpenTelemetryEventSourceLogEmitterCapturesExistingSourceTest()
|
|
{
|
|
List<LogRecord> exportedItems = new();
|
|
|
|
#pragma warning disable CA2000 // Dispose objects before losing scope
|
|
var openTelemetryLoggerProvider = new WrappedOpenTelemetryLoggerProvider(options =>
|
|
{
|
|
options.AddInMemoryExporter(exportedItems);
|
|
});
|
|
#pragma warning restore CA2000 // Dispose objects before losing scope
|
|
|
|
TestEventSource.Log.SimpleEvent();
|
|
|
|
using (var openTelemetryEventSourceLogEmitter = new OpenTelemetryEventSourceLogEmitter(
|
|
openTelemetryLoggerProvider,
|
|
(name) => name == "OpenTelemetry.Extensions.EventSource.Tests" ? EventLevel.LogAlways : null))
|
|
{
|
|
TestEventSource.Log.SimpleEvent();
|
|
}
|
|
|
|
Assert.Single(exportedItems);
|
|
}
|
|
|
|
[Fact]
|
|
public void OpenTelemetryEventSourceLogEmitterSimpleEventTest()
|
|
{
|
|
List<LogRecord> exportedItems = new();
|
|
|
|
#pragma warning disable CA2000 // Dispose objects before losing scope
|
|
var openTelemetryLoggerProvider = new WrappedOpenTelemetryLoggerProvider(options =>
|
|
{
|
|
options.AddInMemoryExporter(exportedItems);
|
|
});
|
|
#pragma warning restore CA2000 // Dispose objects before losing scope
|
|
|
|
using (var openTelemetryEventSourceLogEmitter = new OpenTelemetryEventSourceLogEmitter(
|
|
openTelemetryLoggerProvider,
|
|
(name) => name == "OpenTelemetry.Extensions.EventSource.Tests" ? EventLevel.LogAlways : null))
|
|
{
|
|
TestEventSource.Log.SimpleEvent();
|
|
}
|
|
|
|
Assert.Single(exportedItems);
|
|
|
|
var logRecord = exportedItems[0];
|
|
|
|
Assert.NotEqual(DateTime.MinValue, logRecord.Timestamp);
|
|
Assert.Equal(TestEventSource.SimpleEventMessage, logRecord.FormattedMessage);
|
|
Assert.Equal(TestEventSource.SimpleEventId, logRecord.EventId.Id);
|
|
Assert.Equal(nameof(TestEventSource.SimpleEvent), logRecord.EventId.Name);
|
|
Assert.Equal(LogLevel.Warning, logRecord.LogLevel);
|
|
Assert.Null(logRecord.CategoryName);
|
|
Assert.Null(logRecord.Exception);
|
|
|
|
Assert.Equal(default, logRecord.TraceId);
|
|
Assert.Equal(default, logRecord.SpanId);
|
|
Assert.Null(logRecord.TraceState);
|
|
Assert.Equal(ActivityTraceFlags.None, logRecord.TraceFlags);
|
|
|
|
Assert.NotNull(logRecord.StateValues);
|
|
Assert.Contains(logRecord.StateValues, kvp => kvp.Key == "event_source.name" && (string?)kvp.Value == "OpenTelemetry.Extensions.EventSource.Tests");
|
|
}
|
|
|
|
[Fact]
|
|
public void OpenTelemetryEventSourceLogEmitterSimpleEventWithActivityTest()
|
|
{
|
|
using var activity = new Activity("Test");
|
|
activity.Start();
|
|
|
|
List<LogRecord> exportedItems = new();
|
|
|
|
#pragma warning disable CA2000 // Dispose objects before losing scope
|
|
var openTelemetryLoggerProvider = new WrappedOpenTelemetryLoggerProvider(options =>
|
|
{
|
|
options.AddInMemoryExporter(exportedItems);
|
|
});
|
|
#pragma warning restore CA2000 // Dispose objects before losing scope
|
|
|
|
using (var openTelemetryEventSourceLogEmitter = new OpenTelemetryEventSourceLogEmitter(
|
|
openTelemetryLoggerProvider,
|
|
(name) => name == "OpenTelemetry.Extensions.EventSource.Tests" ? EventLevel.LogAlways : null))
|
|
{
|
|
TestEventSource.Log.SimpleEvent();
|
|
}
|
|
|
|
Assert.Single(exportedItems);
|
|
|
|
var logRecord = exportedItems[0];
|
|
|
|
Assert.NotEqual(default, logRecord.TraceId);
|
|
|
|
Assert.Equal(activity.TraceId, logRecord.TraceId);
|
|
Assert.Equal(activity.SpanId, logRecord.SpanId);
|
|
Assert.Equal(activity.TraceStateString, logRecord.TraceState);
|
|
Assert.Equal(activity.ActivityTraceFlags, logRecord.TraceFlags);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(true)]
|
|
[InlineData(false)]
|
|
public void OpenTelemetryEventSourceLogEmitterComplexEventTest(bool formatMessage)
|
|
{
|
|
List<LogRecord> exportedItems = new();
|
|
|
|
#pragma warning disable CA2000 // Dispose objects before losing scope
|
|
var openTelemetryLoggerProvider = new WrappedOpenTelemetryLoggerProvider(options =>
|
|
{
|
|
options.IncludeFormattedMessage = formatMessage;
|
|
options.AddInMemoryExporter(exportedItems);
|
|
});
|
|
#pragma warning restore CA2000 // Dispose objects before losing scope
|
|
|
|
using (var openTelemetryEventSourceLogEmitter = new OpenTelemetryEventSourceLogEmitter(
|
|
openTelemetryLoggerProvider,
|
|
(name) => name == "OpenTelemetry.Extensions.EventSource.Tests" ? EventLevel.LogAlways : null))
|
|
{
|
|
TestEventSource.Log.ComplexEvent("Test_Message", 18);
|
|
}
|
|
|
|
Assert.Single(exportedItems);
|
|
|
|
var logRecord = exportedItems[0];
|
|
|
|
Assert.NotEqual(DateTime.MinValue, logRecord.Timestamp);
|
|
if (!formatMessage)
|
|
{
|
|
Assert.Equal(TestEventSource.ComplexEventMessageStructured, logRecord.FormattedMessage);
|
|
}
|
|
else
|
|
{
|
|
string expectedMessage = string.Format(CultureInfo.InvariantCulture, TestEventSource.ComplexEventMessage, "Test_Message", 18);
|
|
Assert.Equal(expectedMessage, logRecord.FormattedMessage);
|
|
}
|
|
|
|
Assert.Equal(TestEventSource.ComplexEventId, logRecord.EventId.Id);
|
|
Assert.Equal(nameof(TestEventSource.ComplexEvent), logRecord.EventId.Name);
|
|
Assert.Equal(LogLevel.Information, logRecord.LogLevel);
|
|
Assert.Null(logRecord.CategoryName);
|
|
Assert.Null(logRecord.Exception);
|
|
|
|
Assert.Equal(default, logRecord.TraceId);
|
|
Assert.Equal(default, logRecord.SpanId);
|
|
Assert.Null(logRecord.TraceState);
|
|
Assert.Equal(ActivityTraceFlags.None, logRecord.TraceFlags);
|
|
|
|
Assert.NotNull(logRecord.StateValues);
|
|
Assert.Contains(logRecord.StateValues, kvp => kvp.Key == "event_source.name" && (string?)kvp.Value == "OpenTelemetry.Extensions.EventSource.Tests");
|
|
Assert.Contains(logRecord.StateValues, kvp => kvp.Key == "arg1" && (string?)kvp.Value == "Test_Message");
|
|
Assert.Contains(logRecord.StateValues, kvp => kvp.Key == "arg2" && (int?)kvp.Value == 18);
|
|
}
|
|
|
|
[Theory(Skip = "Not runnable in CI, see note.")]
|
|
[InlineData(true)]
|
|
[InlineData(false)]
|
|
public void OpenTelemetryEventSourceLogEmitterActivityIdTest(bool enableTplListener)
|
|
{
|
|
/*
|
|
* Note:
|
|
*
|
|
* To enable Activity ID the 'System.Threading.Tasks.TplEventSource'
|
|
* source must be enabled see:
|
|
* https://docs.microsoft.com/en-us/dotnet/core/diagnostics/eventsource-activity-ids#tracking-work-using-an-activity-id
|
|
*
|
|
* Once enabled, it cannot be turned off:
|
|
* https://github.com/dotnet/runtime/blob/0fbdb1ed6e076829e4693a61ae5d11c4cb23e7ee/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/ActivityTracker.cs#L208
|
|
*
|
|
* That behavior makes testing it difficult.
|
|
*/
|
|
using var tplListener = enableTplListener ? new TplEventSourceListener() : null;
|
|
|
|
List<LogRecord> exportedItems = new();
|
|
|
|
#pragma warning disable CA2000 // Dispose objects before losing scope
|
|
var openTelemetryLoggerProvider = new WrappedOpenTelemetryLoggerProvider(options =>
|
|
{
|
|
options.AddInMemoryExporter(exportedItems);
|
|
});
|
|
#pragma warning restore CA2000 // Dispose objects before losing scope
|
|
|
|
using (var openTelemetryEventSourceLogEmitter = new OpenTelemetryEventSourceLogEmitter(
|
|
openTelemetryLoggerProvider,
|
|
(name) => name == "OpenTelemetry.Extensions.EventSource.Tests" ? EventLevel.LogAlways : null))
|
|
{
|
|
TestEventSource.Log.WorkStart();
|
|
|
|
TestEventSource.Log.SubworkStart();
|
|
|
|
TestEventSource.Log.SubworkStop();
|
|
|
|
TestEventSource.Log.WorkStop();
|
|
}
|
|
|
|
Assert.Equal(4, exportedItems.Count);
|
|
|
|
var logRecord = exportedItems[1];
|
|
|
|
if (enableTplListener)
|
|
{
|
|
Assert.Contains(logRecord.StateValues, kvp => kvp.Key == "event_source.activity_id");
|
|
Assert.Contains(logRecord.StateValues, kvp => kvp.Key == "event_source.related_activity_id");
|
|
}
|
|
else
|
|
{
|
|
Assert.DoesNotContain(logRecord.StateValues, kvp => kvp.Key == "event_source.activity_id");
|
|
Assert.DoesNotContain(logRecord.StateValues, kvp => kvp.Key == "event_source.related_activity_id");
|
|
}
|
|
}
|
|
|
|
private sealed class WrappedOpenTelemetryLoggerProvider : OpenTelemetryLoggerProvider
|
|
{
|
|
public WrappedOpenTelemetryLoggerProvider(Action<OpenTelemetryLoggerOptions> configure)
|
|
: base(configure)
|
|
{
|
|
}
|
|
|
|
public bool Disposed { get; private set; }
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
this.Disposed = true;
|
|
|
|
base.Dispose(disposing);
|
|
}
|
|
}
|
|
|
|
[EventSource(Name = "OpenTelemetry.Extensions.EventSource.Tests")]
|
|
private sealed class TestEventSource : System.Diagnostics.Tracing.EventSource
|
|
{
|
|
public const int SimpleEventId = 1;
|
|
public const string SimpleEventMessage = "Warning event with no arguments.";
|
|
|
|
public const int ComplexEventId = 2;
|
|
public const string ComplexEventMessage = "Information event with two arguments: '{0}' & '{1}'.";
|
|
public const string ComplexEventMessageStructured = "Information event with two arguments: '{arg1}' & '{arg2}'.";
|
|
|
|
public static TestEventSource Log { get; } = new();
|
|
|
|
[Event(SimpleEventId, Message = SimpleEventMessage, Level = EventLevel.Warning)]
|
|
public void SimpleEvent()
|
|
{
|
|
this.WriteEvent(SimpleEventId);
|
|
}
|
|
|
|
[Event(ComplexEventId, Message = ComplexEventMessage, Level = EventLevel.Informational)]
|
|
public void ComplexEvent(string arg1, int arg2)
|
|
{
|
|
this.WriteEvent(ComplexEventId, arg1, arg2);
|
|
}
|
|
|
|
[Event(3, Level = EventLevel.Verbose)]
|
|
public void WorkStart()
|
|
{
|
|
this.WriteEvent(3);
|
|
}
|
|
|
|
[Event(4, Level = EventLevel.Verbose)]
|
|
public void WorkStop()
|
|
{
|
|
this.WriteEvent(4);
|
|
}
|
|
|
|
[Event(5, Level = EventLevel.Verbose)]
|
|
public void SubworkStart()
|
|
{
|
|
this.WriteEvent(5);
|
|
}
|
|
|
|
[Event(6, Level = EventLevel.Verbose)]
|
|
public void SubworkStop()
|
|
{
|
|
this.WriteEvent(6);
|
|
}
|
|
}
|
|
|
|
private sealed class TplEventSourceListener : EventListener
|
|
{
|
|
private readonly List<System.Diagnostics.Tracing.EventSource> eventSources = new();
|
|
|
|
/// <inheritdoc/>
|
|
public override void Dispose()
|
|
{
|
|
foreach (System.Diagnostics.Tracing.EventSource eventSource in this.eventSources)
|
|
{
|
|
this.DisableEvents(eventSource);
|
|
}
|
|
|
|
this.eventSources.Clear();
|
|
|
|
base.Dispose();
|
|
}
|
|
|
|
protected override void OnEventSourceCreated(System.Diagnostics.Tracing.EventSource eventSource)
|
|
{
|
|
if (eventSource.Name == "System.Threading.Tasks.TplEventSource")
|
|
{
|
|
// Activity IDs aren't enabled by default.
|
|
// Enabling Keyword 0x80 on the TplEventSource turns them on
|
|
this.EnableEvents(eventSource, EventLevel.LogAlways, (EventKeywords)0x80);
|
|
this.eventSources.Add(eventSource);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|