open-telemetry
/
opentelemetry-dotnet
mirror of https://github.com/open-telemetry/opentelemetry-dotnet.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Move LoggerProvider and friends (OTEL1000) to a stable API (#5648)

This commit is contained in:
Mikel Blanchard 2024-06-05 16:06:17 -07:00 committed by GitHub
parent 248043a74d
commit 2710c427f0
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
52 changed files with 508 additions and 1011 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
build/Common.nonprod.props
View File

@ -44,4 +44,24 @@
<Message Importance="high" Text="Skipping test execution for '$(TargetPath)' because it does not contain the '$(TargetFramework)' target." Condition="'$(_SkipTests)' == 'true'" />
</Target>
<Target Name="ResolveExposedExperimentalFeatures" BeforeTargets="CoreCompile">
<!-- Note: What this does is look for $(ProjectReferenceName).BuildFlags.txt
files for all the dependencies of the project being compiled. If
ExposeExperimentalFeatures=true is found in those files we set compiler
constants for each project where experimental features were exposed.
Example:
OPENTELEMETRY_EXPORTER_INMEMORY_EXPERIMENTAL_FEATURES_EXPOSED;OPENTELEMETRY_EXPERIMENTAL_FEATURES_EXPOSED;OPENTELEMETRY_API_EXPERIMENTAL_FEATURES_EXPOSED;OPENTELEMETRY_API_PROVIDERBUILDEREXTENSIONS_EXPERIMENTAL_FEATURES_EXPOSED
-->
<ItemGroup>
<DependenciesWithExposedExperimentalFeatures
Include="@(_ResolvedProjectReferencePaths->'%(Filename)')"
Condition="$([System.IO.File]::Exists('%(RootDir)%(Directory)%(Filename).BuildFlags.txt')) AND $([System.IO.File]::ReadAllText('%(RootDir)%(Directory)%(Filename).BuildFlags.txt').Contains('ExposeExperimentalFeatures=true'))" />
<CompilerConstantsForDependenciesWithExposedExperimentalFeatures Include="@(DependenciesWithExposedExperimentalFeatures->'$([System.String]::Copy('%(DependenciesWithExposedExperimentalFeatures.Identity)').ToUpper().Replace('.', '_'))_EXPERIMENTAL_FEATURES_EXPOSED')" />
</ItemGroup>
<PropertyGroup Condition="'@(CompilerConstantsForDependenciesWithExposedExperimentalFeatures)' != ''">
<DefineConstants>$(DefineConstants);@(CompilerConstantsForDependenciesWithExposedExperimentalFeatures)</DefineConstants>
</PropertyGroup>
</Target>
</Project>

13
build/Common.prod.props
View File

@ -39,6 +39,10 @@
<ItemGroup>
<None Include="$(MSBuildThisFileDirectory)opentelemetry-icon-color.png" Pack="true" PackagePath="\" />
<SourceRoot Condition="'$(Deterministic)'=='true'" Include="$(MSBuildThisFileDirectory)/" />
<None Include="$(IntermediateOutputPath)$(ProjectName).BuildFlags.txt"
Link="$(ProjectName).BuildFlags.txt"
CopyToOutputDirectory="PreserveNewest"
Visible="false" />
<!-- Note: This includes all the PublicApiAnalyzers files in projects to make editing easier in the IDE -->
<None Include=".publicApi\**\PublicAPI.*.txt" />
</ItemGroup>
@ -82,6 +86,15 @@
<DefineConstants>$(DefineConstants);EXPOSE_EXPERIMENTAL_FEATURES</DefineConstants>
</PropertyGroup>
<!-- Note: We write a file into the output dir which captures the state of
ExposeExperimentalFeatures for the current compilation. This is used by
consuming projects (tests, benchmarks, examples, etc) to add compiler
constants which can be used to detect experimental APIs -->
<WriteLinesToFile
File="$(IntermediateOutputPath)$(ProjectName).BuildFlags.txt"
Lines="ExposeExperimentalFeatures=$(ExposeExperimentalFeatures)"
Overwrite="true"/>
<!-- Note: This selects the correct PublicApiAnalyzers files based on $(ExposeExperimentalFeatures) -->
<ItemGroup>
<AdditionalFiles Include=".publicApi\Stable\PublicAPI.*.txt" />

10
docs/diagnostics/experimental-apis/OTEL1000.md
View File

@ -4,11 +4,17 @@
This is an Experimental API diagnostic covering the following APIs:
* `ILoggingBuilder.UseOpenTelemetry`
Experimental APIs may be changed or removed in the future.
The following portions of `OTEL1000` were released stable in `1.9.0` and are no
longer considered experimental:
* `LoggerProviderBuilder`
* `LoggerProvider`
* `IDeferredLoggerProviderBuilder`
Experimental APIs may be changed or removed in the future.
* `OpenTelemetryBuilder.WithLogging`
## Details

1
docs/diagnostics/experimental-apis/OTEL1001.md
View File

@ -9,6 +9,7 @@ This is an Experimental API diagnostic covering the following APIs:
* `LogRecordAttributeList`
* `LogRecordData`
* `LogRecordSeverity`
* `Sdk.CreateLoggerProviderBuilder`
Experimental APIs may be changed or removed in the future.

23
docs/logs/dedicated-pipeline/DedicatedLogging/DedicatedLoggingServiceCollectionExtensions.cs
View File

@ -11,20 +11,25 @@ public static class DedicatedLoggingServiceCollectionExtensions
public static IServiceCollection AddDedicatedLogging(
this IServiceCollection services,
IConfiguration configuration,
Action<OpenTelemetryLoggerOptions> configureOpenTelemetry)
Action<LoggerProviderBuilder> configureOpenTelemetry)
{
ArgumentNullException.ThrowIfNull(configureOpenTelemetry);
services.TryAddSingleton(sp =>
services.TryAddSingleton(_ =>
{
var loggerFactory = LoggerFactory.Create(builder =>
var services = new ServiceCollection();
services.AddLogging(builder =>
{
builder.AddConfiguration(configuration);
builder.AddOpenTelemetry(configureOpenTelemetry);
builder.AddOpenTelemetry();
});
return new DedicatedLoggerFactory(loggerFactory);
services.ConfigureOpenTelemetryLoggerProvider(configureOpenTelemetry);
var sp = services.BuildServiceProvider();
return new DedicatedLoggerFactory(sp);
});
services.TryAdd(ServiceDescriptor.Singleton(typeof(IDedicatedLogger<>), typeof(DedicatedLogger<>)));
@ -54,11 +59,13 @@ public static class DedicatedLoggingServiceCollectionExtensions
private sealed class DedicatedLoggerFactory : ILoggerFactory
{
private readonly ServiceProvider serviceProvider;
private readonly ILoggerFactory innerLoggerFactory;
public DedicatedLoggerFactory(ILoggerFactory loggerFactory)
public DedicatedLoggerFactory(ServiceProvider serviceProvider)
{
this.innerLoggerFactory = loggerFactory;
this.serviceProvider = serviceProvider;
this.innerLoggerFactory = serviceProvider.GetRequiredService<ILoggerFactory>();
}
public void AddProvider(ILoggerProvider provider)
@ -68,6 +75,6 @@ public static class DedicatedLoggingServiceCollectionExtensions
=> this.innerLoggerFactory.CreateLogger(categoryName);
public void Dispose()
=> this.innerLoggerFactory.Dispose();
=> this.serviceProvider.Dispose();
}
}

15
docs/logs/dedicated-pipeline/Program.cs
View File

@ -8,18 +8,19 @@ var builder = WebApplication.CreateBuilder(args);
builder.Logging.ClearProviders();
builder.Logging.AddOpenTelemetry(options =>
{
// Set up primary pipeline for common app logs
options.AddConsoleExporter();
});
builder.Services.AddOpenTelemetry()
.WithLogging(logging =>
{
// Set up primary pipeline for common app logs
logging.AddConsoleExporter();
});
builder.Services.AddDedicatedLogging(
builder.Configuration.GetSection("DedicatedLogging"), // Bind configuration for dedicated logging pipeline
options =>
logging =>
{
// Set up secondary pipeline for dedicated logs
options.AddConsoleExporter();
logging.AddConsoleExporter();
});
var app = builder.Build();

28
docs/logs/getting-started-aspnetcore/Program.cs
View File

@ -6,25 +6,21 @@ using OpenTelemetry.Resources;
var builder = WebApplication.CreateBuilder(args);
// Remove default providers and add OpenTelemetry logging provider.
// For instructional purposes only, disable the default .NET console logging provider to
// use the verbose OpenTelemetry console exporter instead. For most development
// and production scenarios the default console provider works well and there is no need to
// For instructional purposes only, disable the default .NET logging providers.
// We remove the console logging provider in this demo to use the verbose
// OpenTelemetry console exporter instead. For most development and production
// scenarios the default console provider works well and there is no need to
// clear these providers.
builder.Logging.ClearProviders();
builder.Logging.AddOpenTelemetry(logging =>
{
var resourceBuilder = ResourceBuilder
.CreateDefault()
.AddService(builder.Environment.ApplicationName);
logging.SetResourceBuilder(resourceBuilder)
// ConsoleExporter is used for demo purpose only.
// In production environment, ConsoleExporter should be replaced with other exporters (e.g. OTLP Exporter).
.AddConsoleExporter();
});
// Add OpenTelemetry logging provider by calling the WithLogging extension.
builder.Services.AddOpenTelemetry()
.ConfigureResource(r => r.AddService(builder.Environment.ApplicationName))
.WithLogging(logging => logging
/* Note: ConsoleExporter is used for demo purpose only. In production
environment, ConsoleExporter should be replaced with other exporters
(e.g. OTLP Exporter). */
.AddConsoleExporter());
var app = builder.Build();

62
examples/AspNetCore/Program.cs
View File

@ -24,20 +24,21 @@ var logExporter = appBuilder.Configuration.GetValue("UseLogExporter", defaultVal
// Note: Switch between Explicit/Exponential by setting HistogramAggregation in appsettings.json
var histogramAggregation = appBuilder.Configuration.GetValue("HistogramAggregation", defaultValue: "explicit")!.ToLowerInvariant();
// Build a resource configuration action to set service information.
Action<ResourceBuilder> configureResource = r => r.AddService(
serviceName: appBuilder.Configuration.GetValue("ServiceName", defaultValue: "otel-test")!,
serviceVersion: typeof(Program).Assembly.GetName().Version?.ToString() ?? "unknown",
serviceInstanceId: Environment.MachineName);
// Create a service to expose ActivitySource, and Metric Instruments
// for manual instrumentation
appBuilder.Services.AddSingleton<Instrumentation>();
// Configure OpenTelemetry tracing & metrics with auto-start using the
// Clear default logging providers used by WebApplication host.
appBuilder.Logging.ClearProviders();
// Configure OpenTelemetry logging, metrics, & tracing with auto-start using the
// AddOpenTelemetry extension from OpenTelemetry.Extensions.Hosting.
appBuilder.Services.AddOpenTelemetry()
.ConfigureResource(configureResource)
.ConfigureResource(r => r
.AddService(
serviceName: appBuilder.Configuration.GetValue("ServiceName", defaultValue: "otel-test")!,
serviceVersion: typeof(Program).Assembly.GetName().Version?.ToString() ?? "unknown",
serviceInstanceId: Environment.MachineName))
.WithTracing(builder =>
{
// Tracing
@ -121,34 +122,25 @@ appBuilder.Services.AddOpenTelemetry()
builder.AddConsoleExporter();
break;
}
});
// Clear default logging providers used by WebApplication host.
appBuilder.Logging.ClearProviders();
// Configure OpenTelemetry Logging.
appBuilder.Logging.AddOpenTelemetry(options =>
{
// Note: See appsettings.json Logging:OpenTelemetry section for configuration.
var resourceBuilder = ResourceBuilder.CreateDefault();
configureResource(resourceBuilder);
options.SetResourceBuilder(resourceBuilder);
switch (logExporter)
})
.WithLogging(builder =>
{
case "otlp":
options.AddOtlpExporter(otlpOptions =>
{
// Use IConfiguration directly for Otlp exporter endpoint option.
otlpOptions.Endpoint = new Uri(appBuilder.Configuration.GetValue("Otlp:Endpoint", defaultValue: "http://localhost:4317")!);
});
break;
default:
options.AddConsoleExporter();
break;
}
});
// Note: See appsettings.json Logging:OpenTelemetry section for configuration.
switch (logExporter)
{
case "otlp":
builder.AddOtlpExporter(otlpOptions =>
{
// Use IConfiguration directly for Otlp exporter endpoint option.
otlpOptions.Endpoint = new Uri(appBuilder.Configuration.GetValue("Otlp:Endpoint", defaultValue: "http://localhost:4317")!);
});
break;
default:
builder.AddConsoleExporter();
break;
}
});
appBuilder.Services.AddControllers();

9
src/OpenTelemetry.Api.ProviderBuilderExtensions/.publicApi/Experimental/PublicAPI.Unshipped.txt
View File

@ -1,9 +0,0 @@
OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions
OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggingServiceCollectionExtensions
static OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions.AddInstrumentation<T>(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions.AddInstrumentation<T>(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder, System.Func<System.IServiceProvider!, OpenTelemetry.Logs.LoggerProvider!, T!>! instrumentationFactory) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions.AddInstrumentation<T>(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder, System.Func<System.IServiceProvider!, T!>! instrumentationFactory) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions.AddInstrumentation<T>(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder, T! instrumentation) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions.ConfigureServices(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder, System.Action<Microsoft.Extensions.DependencyInjection.IServiceCollection!>! configure) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggingServiceCollectionExtensions.ConfigureOpenTelemetryLoggerProvider(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, System.Action<OpenTelemetry.Logs.LoggerProviderBuilder!>! configure) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
static OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggingServiceCollectionExtensions.ConfigureOpenTelemetryLoggerProvider(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, System.Action<System.IServiceProvider!, OpenTelemetry.Logs.LoggerProviderBuilder!>! configure) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!

9
src/OpenTelemetry.Api.ProviderBuilderExtensions/.publicApi/Stable/PublicAPI.Unshipped.txt
View File

@ -0,0 +1,9 @@
OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions
OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggingServiceCollectionExtensions
static OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions.AddInstrumentation<T>(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions.AddInstrumentation<T>(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder, System.Func<System.IServiceProvider!, OpenTelemetry.Logs.LoggerProvider!, T!>! instrumentationFactory) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions.AddInstrumentation<T>(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder, System.Func<System.IServiceProvider!, T!>! instrumentationFactory) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions.AddInstrumentation<T>(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder, T! instrumentation) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions.ConfigureServices(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder, System.Action<Microsoft.Extensions.DependencyInjection.IServiceCollection!>! configure) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggingServiceCollectionExtensions.ConfigureOpenTelemetryLoggerProvider(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, System.Action<OpenTelemetry.Logs.LoggerProviderBuilder!>! configure) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
static OpenTelemetry.Logs.OpenTelemetryDependencyInjectionLoggingServiceCollectionExtensions.ConfigureOpenTelemetryLoggerProvider(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, System.Action<System.IServiceProvider!, OpenTelemetry.Logs.LoggerProviderBuilder!>! configure) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!

6
src/OpenTelemetry.Api.ProviderBuilderExtensions/CHANGELOG.md
View File

@ -2,6 +2,12 @@
## Unreleased
* The experimental APIs previously covered by `OTEL1000`
(`LoggerProviderBuilder` `AddInstrumentation` & `ConfigureServices` extensions
and `IServiceCollection.ConfigureOpenTelemetryLoggerProvider` extension) will
now be part of the public API and supported in stable builds.
([#5648](https://github.com/open-telemetry/opentelemetry-dotnet/pull/5648))
## 1.9.0-alpha.1
Released 2024-May-20

72
src/OpenTelemetry.Api.ProviderBuilderExtensions/Logs/OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions.cs
View File

@ -13,29 +13,8 @@ namespace OpenTelemetry.Logs;
/// <summary>
/// Contains extension methods for the <see cref="LoggerProviderBuilder"/> class.
/// </summary>
#if EXPOSE_EXPERIMENTAL_FEATURES
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
internal
#endif
static class OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions
public static class OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions
{
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds instrumentation to the provider.
/// </summary>
/// <remarks>
/// <para><inheritdoc cref="AddInstrumentation{T}(LoggerProviderBuilder, T)" path="/remarks"/></para>
/// Note: The type specified by <typeparamref name="T"/> will be
/// registered as a singleton service into application services.
/// </remarks>
/// <typeparam name="T">Instrumentation type.</typeparam>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <returns>The supplied <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#else
/// <summary>
/// Adds instrumentation to the provider.
/// </summary>
@ -46,7 +25,6 @@ static class OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions
/// <typeparam name="T">Instrumentation type.</typeparam>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <returns>The supplied <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#endif
public static LoggerProviderBuilder AddInstrumentation<
#if NET6_0_OR_GREATER
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]
@ -64,16 +42,6 @@ static class OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions
return loggerProviderBuilder;
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds instrumentation to the provider.
/// </summary>
/// <typeparam name="T">Instrumentation type.</typeparam>
/// <remarks><b>WARNING</b>: This is an experimental API which might change or be removed in the future. Use at your own risk.</remarks>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="instrumentation">Instrumentation instance.</param>
/// <returns>The supplied <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#else
/// <summary>
/// Adds instrumentation to the provider.
/// </summary>
@ -81,7 +49,6 @@ static class OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="instrumentation">Instrumentation instance.</param>
/// <returns>The supplied <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#endif
public static LoggerProviderBuilder AddInstrumentation<T>(this LoggerProviderBuilder loggerProviderBuilder, T instrumentation)
where T : class
{
@ -95,16 +62,6 @@ static class OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions
return loggerProviderBuilder;
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds instrumentation to the provider.
/// </summary>
/// <typeparam name="T">Instrumentation type.</typeparam>
/// <remarks><inheritdoc cref="AddInstrumentation{T}(LoggerProviderBuilder, T)" path="/remarks"/></remarks>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="instrumentationFactory">Instrumentation factory.</param>
/// <returns>The supplied <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#else
/// <summary>
/// Adds instrumentation to the provider.
/// </summary>
@ -112,7 +69,6 @@ static class OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="instrumentationFactory">Instrumentation factory.</param>
/// <returns>The supplied <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#endif
public static LoggerProviderBuilder AddInstrumentation<T>(
this LoggerProviderBuilder loggerProviderBuilder,
Func<IServiceProvider, T> instrumentationFactory)
@ -128,16 +84,6 @@ static class OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions
return loggerProviderBuilder;
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds instrumentation to the provider.
/// </summary>
/// <typeparam name="T">Instrumentation type.</typeparam>
/// <remarks><inheritdoc cref="AddInstrumentation{T}(LoggerProviderBuilder, T)" path="/remarks"/></remarks>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="instrumentationFactory">Instrumentation factory.</param>
/// <returns>The supplied <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#else
/// <summary>
/// Adds instrumentation to the provider.
/// </summary>
@ -145,7 +91,6 @@ static class OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="instrumentationFactory">Instrumentation factory.</param>
/// <returns>The supplied <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#endif
public static LoggerProviderBuilder AddInstrumentation<T>(
this LoggerProviderBuilder loggerProviderBuilder,
Func<IServiceProvider, LoggerProvider, T> instrumentationFactory)
@ -165,20 +110,6 @@ static class OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions
return loggerProviderBuilder;
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Register a callback action to configure the <see
/// cref="IServiceCollection"/> where logging services are configured.
/// </summary>
/// <remarks>
/// <para><inheritdoc cref="AddInstrumentation{T}(LoggerProviderBuilder, T)" path="/remarks"/></para>
/// Note: Logging services are only available during the application
/// configuration phase.
/// </remarks>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="configure">Configuration callback.</param>
/// <returns>The supplied <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#else
/// <summary>
/// Register a callback action to configure the <see
/// cref="IServiceCollection"/> where logging services are configured.
@ -190,7 +121,6 @@ static class OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="configure">Configuration callback.</param>
/// <returns>The supplied <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#endif
public static LoggerProviderBuilder ConfigureServices(
this LoggerProviderBuilder loggerProviderBuilder,
Action<IServiceCollection> configure)

73
src/OpenTelemetry.Api.ProviderBuilderExtensions/Logs/OpenTelemetryDependencyInjectionLoggingServiceCollectionExtensions.cs
View File

@ -1,9 +1,6 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
#if EXPOSE_EXPERIMENTAL_FEATURES && NET8_0_OR_GREATER
using System.Diagnostics.CodeAnalysis;
#endif
using Microsoft.Extensions.DependencyInjection;
using OpenTelemetry.Internal;
@ -12,40 +9,8 @@ namespace OpenTelemetry.Logs;
/// <summary>
/// Extension methods for setting up OpenTelemetry logging services in an <see cref="IServiceCollection" />.
/// </summary>
#if EXPOSE_EXPERIMENTAL_FEATURES
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
internal
#endif
static class OpenTelemetryDependencyInjectionLoggingServiceCollectionExtensions
public static class OpenTelemetryDependencyInjectionLoggingServiceCollectionExtensions
{
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Registers an action used to configure the OpenTelemetry <see
/// cref="LoggerProviderBuilder"/>.
/// </summary>
/// <remarks>
/// <para><inheritdoc cref="OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions.AddInstrumentation{T}(LoggerProviderBuilder, T)" path="/remarks"/></para>
/// Notes:
/// <list type="bullet">
/// <item>This is safe to be called multiple times and by library authors.
/// Each registered configuration action will be applied
/// sequentially.</item>
/// <item>A <see cref="LoggerProvider"/> will NOT be created automatically
/// using this method. To begin collecting logs use the
/// <c>IServiceCollection.AddOpenTelemetry</c> extension in the
/// <c>OpenTelemetry.Extensions.Hosting</c> package.</item>
/// </list>
/// </remarks>
/// <param name="services"><see cref="IServiceCollection" />.</param>
/// <param name="configure">Callback action to configure the <see
/// cref="LoggerProviderBuilder"/>.</param>
/// <returns>The <see cref="IServiceCollection"/> so that additional calls
/// can be chained.</returns>
#else
/// <summary>
/// Registers an action used to configure the OpenTelemetry <see
/// cref="LoggerProviderBuilder"/>.
@ -67,7 +32,6 @@ static class OpenTelemetryDependencyInjectionLoggingServiceCollectionExtensions
/// cref="LoggerProviderBuilder"/>.</param>
/// <returns>The <see cref="IServiceCollection"/> so that additional calls
/// can be chained.</returns>
#endif
public static IServiceCollection ConfigureOpenTelemetryLoggerProvider(
this IServiceCollection services,
Action<LoggerProviderBuilder> configure)
@ -80,40 +44,6 @@ static class OpenTelemetryDependencyInjectionLoggingServiceCollectionExtensions
return services;
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Registers an action used to configure the OpenTelemetry <see
/// cref="LoggerProviderBuilder"/> once the <see cref="IServiceProvider"/>
/// is available.
/// </summary>
/// <remarks>
/// <para><inheritdoc cref="OpenTelemetryDependencyInjectionLoggerProviderBuilderExtensions.AddInstrumentation{T}(LoggerProviderBuilder, T)" path="/remarks"/></para>
/// Notes:
/// <list type="bullet">
/// <item>This is safe to be called multiple times and by library authors.
/// Each registered configuration action will be applied
/// sequentially.</item>
/// <item>A <see cref="LoggerProvider"/> will NOT be created automatically
/// using this method. To begin collecting logs use the
/// <c>IServiceCollection.AddOpenTelemetry</c> extension in the
/// <c>OpenTelemetry.Extensions.Hosting</c> package.</item>
/// <item>The supplied configuration delegate is called once the <see
/// cref="IServiceProvider"/> is available. Services may NOT be added to a
/// <see cref="LoggerProviderBuilder"/> once the <see
/// cref="IServiceProvider"/> has been created. Many helper extensions
/// register services and may throw if invoked inside the configuration
/// delegate. If you don't need access to the <see cref="IServiceProvider"/>
/// call <see cref="ConfigureOpenTelemetryLoggerProvider(IServiceCollection,
/// Action{LoggerProviderBuilder})"/> instead which is safe to be used with
/// helper extensions.</item>
/// </list>
/// </remarks>
/// <param name="services"><see cref="IServiceCollection" />.</param>
/// <param name="configure">Callback action to configure the <see
/// cref="LoggerProviderBuilder"/>.</param>
/// <returns>The <see cref="IServiceCollection"/> so that additional calls
/// can be chained.</returns>
#else
/// <summary>
/// Registers an action used to configure the OpenTelemetry <see
/// cref="LoggerProviderBuilder"/> once the <see cref="IServiceProvider"/>
@ -145,7 +75,6 @@ static class OpenTelemetryDependencyInjectionLoggingServiceCollectionExtensions
/// cref="LoggerProviderBuilder"/>.</param>
/// <returns>The <see cref="IServiceCollection"/> so that additional calls
/// can be chained.</returns>
#endif
public static IServiceCollection ConfigureOpenTelemetryLoggerProvider(
this IServiceCollection services,
Action<IServiceProvider, LoggerProviderBuilder> configure)

7
src/OpenTelemetry.Api/.publicApi/Experimental/PublicAPI.Unshipped.txt
View File

@ -1,19 +1,12 @@
abstract OpenTelemetry.Logs.Logger.EmitLog(in OpenTelemetry.Logs.LogRecordData data, in OpenTelemetry.Logs.LogRecordAttributeList attributes) -> void
abstract OpenTelemetry.Logs.LoggerProviderBuilder.AddInstrumentation<TInstrumentation>(System.Func<TInstrumentation>! instrumentationFactory) -> OpenTelemetry.Logs.LoggerProviderBuilder!
OpenTelemetry.Logs.IDeferredLoggerProviderBuilder
OpenTelemetry.Logs.IDeferredLoggerProviderBuilder.Configure(System.Action<System.IServiceProvider!, OpenTelemetry.Logs.LoggerProviderBuilder!>! configure) -> OpenTelemetry.Logs.LoggerProviderBuilder!
OpenTelemetry.Logs.Logger
OpenTelemetry.Logs.Logger.EmitLog(in OpenTelemetry.Logs.LogRecordData data) -> void
OpenTelemetry.Logs.Logger.Logger(string? name) -> void
OpenTelemetry.Logs.Logger.Name.get -> string!
OpenTelemetry.Logs.Logger.Version.get -> string?
OpenTelemetry.Logs.LoggerProvider
OpenTelemetry.Logs.LoggerProvider.GetLogger() -> OpenTelemetry.Logs.Logger!
OpenTelemetry.Logs.LoggerProvider.GetLogger(string? name) -> OpenTelemetry.Logs.Logger!
OpenTelemetry.Logs.LoggerProvider.GetLogger(string? name, string? version) -> OpenTelemetry.Logs.Logger!
OpenTelemetry.Logs.LoggerProvider.LoggerProvider() -> void
OpenTelemetry.Logs.LoggerProviderBuilder
OpenTelemetry.Logs.LoggerProviderBuilder.LoggerProviderBuilder() -> void
OpenTelemetry.Logs.LogRecordAttributeList
OpenTelemetry.Logs.LogRecordAttributeList.Add(string! key, object? value) -> void
OpenTelemetry.Logs.LogRecordAttributeList.Add(System.Collections.Generic.KeyValuePair<string!, object?> attribute) -> void

7
src/OpenTelemetry.Api/.publicApi/Stable/PublicAPI.Unshipped.txt
View File

@ -0,0 +1,7 @@
abstract OpenTelemetry.Logs.LoggerProviderBuilder.AddInstrumentation<TInstrumentation>(System.Func<TInstrumentation>! instrumentationFactory) -> OpenTelemetry.Logs.LoggerProviderBuilder!
OpenTelemetry.Logs.IDeferredLoggerProviderBuilder
OpenTelemetry.Logs.IDeferredLoggerProviderBuilder.Configure(System.Action<System.IServiceProvider!, OpenTelemetry.Logs.LoggerProviderBuilder!>! configure) -> OpenTelemetry.Logs.LoggerProviderBuilder!
OpenTelemetry.Logs.LoggerProvider
OpenTelemetry.Logs.LoggerProvider.LoggerProvider() -> void
OpenTelemetry.Logs.LoggerProviderBuilder
OpenTelemetry.Logs.LoggerProviderBuilder.LoggerProviderBuilder() -> void

5
src/OpenTelemetry.Api/CHANGELOG.md
View File

@ -2,6 +2,11 @@
## Unreleased
* The experimental APIs previously covered by `OTEL1000` (`LoggerProvider`,
`LoggerProviderBuilder`, & `IDeferredLoggerProviderBuilder`) will now be part
of the public API and supported in stable builds.
([#5648](https://github.com/open-telemetry/opentelemetry-dotnet/pull/5648))
## 1.9.0-alpha.1
Released 2024-May-20

21
src/OpenTelemetry.Api/Logs/IDeferredLoggerProviderBuilder.cs
View File

@ -3,33 +3,14 @@
#nullable enable
#if NET8_0_OR_GREATER && EXPOSE_EXPERIMENTAL_FEATURES
using System.Diagnostics.CodeAnalysis;
using OpenTelemetry.Internal;
#endif
namespace OpenTelemetry.Logs;
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Describes a logger provider builder that supports deferred
/// initialization using an <see cref="IServiceProvider"/> to perform
/// dependency injection.
/// </summary>
/// <remarks><inheritdoc cref="Logger" path="/remarks"/></remarks>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// Describes a logger provider builder that supports deferred
/// initialization using an <see cref="IServiceProvider"/> to perform
/// dependency injection.
/// </summary>
internal
#endif
interface IDeferredLoggerProviderBuilder
public interface IDeferredLoggerProviderBuilder
{
/// <summary>
/// Register a callback action to configure the <see

48
src/OpenTelemetry.Api/Logs/LoggerProvider.cs
View File

@ -6,28 +6,16 @@
#if NETSTANDARD2_1_OR_GREATER || NET6_0_OR_GREATER
using System.Diagnostics.CodeAnalysis;
#endif
#if NET8_0_OR_GREATER
#if EXPOSE_EXPERIMENTAL_FEATURES && NET8_0_OR_GREATER
using OpenTelemetry.Internal;
#endif
namespace OpenTelemetry.Logs;
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// LoggerProvider is the entry point of the OpenTelemetry API. It provides access to <see cref="Logger"/>.
/// </summary>
/// <remarks><inheritdoc cref="Logger" path="/remarks"/></remarks>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// LoggerProvider is the entry point of the OpenTelemetry API. It provides access to <see cref="Logger"/>.
/// </summary>
internal
#endif
class LoggerProvider : BaseProvider
public class LoggerProvider : BaseProvider
{
private static readonly NoopLogger NoopLogger = new();
@ -38,37 +26,55 @@ internal
{
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Gets a logger.
/// </summary>
/// <remarks><inheritdoc cref="Logger" path="/remarks"/></remarks>
/// <returns><see cref="Logger"/> instance.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LogsBridgeExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public Logger GetLogger()
public
#else
internal
#endif
Logger GetLogger()
=> this.GetLogger(name: null, version: null);
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Gets a logger with the given name.
/// </summary>
/// <remarks><inheritdoc cref="Logger" path="/remarks"/></remarks>
/// <param name="name">Optional name identifying the instrumentation library.</param>
/// <returns><see cref="Logger"/> instance.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LogsBridgeExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public Logger GetLogger(string? name)
public
#else
internal
#endif
Logger GetLogger(string? name)
=> this.GetLogger(name, version: null);
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Gets a logger with the given name and version.
/// </summary>
/// <remarks><inheritdoc cref="Logger" path="/remarks"/></remarks>
/// <param name="name">Optional name identifying the instrumentation library.</param>
/// <param name="version">Optional version of the instrumentation library.</param>
/// <returns><see cref="Logger"/> instance.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LogsBridgeExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public Logger GetLogger(string? name, string? version)
public
#else
internal
#endif
Logger GetLogger(string? name, string? version)
{
if (!this.TryCreateLogger(name, out var logger))
{
@ -80,16 +86,22 @@ internal
return logger;
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Try to create a logger with the given name.
/// </summary>
/// <remarks><inheritdoc cref="Logger" path="/remarks"/></remarks>
/// <param name="name">Optional name identifying the instrumentation library.</param>
/// <param name="logger"><see cref="Logger"/>.</param>
/// <returns><see langword="true"/> if the logger was created.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LogsBridgeExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
protected virtual bool TryCreateLogger(
protected
#else
internal
#endif
virtual bool TryCreateLogger(
string? name,
#if NETSTANDARD2_1_OR_GREATER || NET6_0_OR_GREATER
[NotNullWhen(true)]

19
src/OpenTelemetry.Api/Logs/LoggerProviderBuilder.cs
View File

@ -3,29 +3,12 @@
#nullable enable
#if NET8_0_OR_GREATER && EXPOSE_EXPERIMENTAL_FEATURES
using System.Diagnostics.CodeAnalysis;
using OpenTelemetry.Internal;
#endif
namespace OpenTelemetry.Logs;
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// LoggerProviderBuilder base class.
/// </summary>
/// <remarks><inheritdoc cref="Logger" path="/remarks"/></remarks>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// LoggerProviderBuilder base class.
/// </summary>
internal
#endif
abstract class LoggerProviderBuilder
public abstract class LoggerProviderBuilder
{
/// <summary>
/// Initializes a new instance of the <see cref="LoggerProviderBuilder"/> class.

3
src/OpenTelemetry.Exporter.Console/.publicApi/Experimental/PublicAPI.Unshipped.txt
View File

@ -1,3 +0,0 @@
static OpenTelemetry.Logs.ConsoleExporterLoggingExtensions.AddConsoleExporter(this OpenTelemetry.Logs.LoggerProviderBuilder loggerProviderBuilder) -> OpenTelemetry.Logs.LoggerProviderBuilder
static OpenTelemetry.Logs.ConsoleExporterLoggingExtensions.AddConsoleExporter(this OpenTelemetry.Logs.LoggerProviderBuilder loggerProviderBuilder, string name, System.Action<OpenTelemetry.Exporter.ConsoleExporterOptions> configure) -> OpenTelemetry.Logs.LoggerProviderBuilder
static OpenTelemetry.Logs.ConsoleExporterLoggingExtensions.AddConsoleExporter(this OpenTelemetry.Logs.LoggerProviderBuilder loggerProviderBuilder, System.Action<OpenTelemetry.Exporter.ConsoleExporterOptions> configure) -> OpenTelemetry.Logs.LoggerProviderBuilder

3
src/OpenTelemetry.Exporter.Console/.publicApi/Stable/PublicAPI.Unshipped.txt
View File

@ -0,0 +1,3 @@
static OpenTelemetry.Logs.ConsoleExporterLoggingExtensions.AddConsoleExporter(this OpenTelemetry.Logs.LoggerProviderBuilder loggerProviderBuilder) -> OpenTelemetry.Logs.LoggerProviderBuilder
static OpenTelemetry.Logs.ConsoleExporterLoggingExtensions.AddConsoleExporter(this OpenTelemetry.Logs.LoggerProviderBuilder loggerProviderBuilder, string name, System.Action<OpenTelemetry.Exporter.ConsoleExporterOptions> configure) -> OpenTelemetry.Logs.LoggerProviderBuilder
static OpenTelemetry.Logs.ConsoleExporterLoggingExtensions.AddConsoleExporter(this OpenTelemetry.Logs.LoggerProviderBuilder loggerProviderBuilder, System.Action<OpenTelemetry.Exporter.ConsoleExporterOptions> configure) -> OpenTelemetry.Logs.LoggerProviderBuilder

5
src/OpenTelemetry.Exporter.Console/CHANGELOG.md
View File

@ -2,6 +2,11 @@
## Unreleased
* The experimental APIs previously covered by `OTEL1000`
(`LoggerProviderBuilder.AddConsoleExporter` extension) will now be part of the
public API and supported in stable builds.
([#5648](https://github.com/open-telemetry/opentelemetry-dotnet/pull/5648))
## 1.9.0-alpha.1
Released 2024-May-20

58
src/OpenTelemetry.Exporter.Console/ConsoleExporterLoggingExtensions.cs
View File

@ -1,9 +1,6 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
#if EXPOSE_EXPERIMENTAL_FEATURES && NET8_0_OR_GREATER
using System.Diagnostics.CodeAnalysis;
#endif
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using OpenTelemetry.Exporter;
@ -18,7 +15,7 @@ public static class ConsoleExporterLoggingExtensions
/// </summary>
/// <param name="loggerOptions"><see cref="OpenTelemetryLoggerOptions"/> options to use.</param>
/// <returns>The instance of <see cref="OpenTelemetryLoggerOptions"/> to chain the calls.</returns>
/// todo: [Obsolete("Call LoggerProviderBuilder.AddConsoleExporter instead this method will be removed in a future version.")]
// TODO: [Obsolete("Call LoggerProviderBuilder.AddConsoleExporter instead this method will be removed in a future version.")]
public static OpenTelemetryLoggerOptions AddConsoleExporter(this OpenTelemetryLoggerOptions loggerOptions)
=> AddConsoleExporter(loggerOptions, configure: null);
@ -28,7 +25,7 @@ public static class ConsoleExporterLoggingExtensions
/// <param name="loggerOptions"><see cref="OpenTelemetryLoggerOptions"/> options to use.</param>
/// <param name="configure">Callback action for configuring <see cref="ConsoleExporterOptions"/>.</param>
/// <returns>The instance of <see cref="OpenTelemetryLoggerOptions"/> to chain the calls.</returns>
/// todo: [Obsolete("Call LoggerProviderBuilder.AddConsoleExporter instead this method will be removed in a future version.")]
// TODO: [Obsolete("Call LoggerProviderBuilder.AddConsoleExporter instead this method will be removed in a future version.")]
public static OpenTelemetryLoggerOptions AddConsoleExporter(this OpenTelemetryLoggerOptions loggerOptions, Action<ConsoleExporterOptions> configure)
{
Guard.ThrowIfNull(loggerOptions);
@ -38,69 +35,26 @@ public static class ConsoleExporterLoggingExtensions
return loggerOptions.AddProcessor(new SimpleLogRecordExportProcessor(new ConsoleLogRecordExporter(options)));
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds Console exporter with LoggerProviderBuilder.
/// </summary>
/// <remarks><b>WARNING</b>: This is an experimental API which might change or be removed in the future. Use at your own risk.</remarks>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <returns>The supplied instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// Adds Console exporter with LoggerProviderBuilder.
/// </summary>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <returns>The supplied instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
internal
#endif
static LoggerProviderBuilder AddConsoleExporter(
public static LoggerProviderBuilder AddConsoleExporter(
this LoggerProviderBuilder loggerProviderBuilder)
=> AddConsoleExporter(loggerProviderBuilder, name: null, configure: null);
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds Console exporter with LoggerProviderBuilder.
/// </summary>
/// <remarks><inheritdoc cref="AddConsoleExporter(LoggerProviderBuilder)" path="/remarks"/></remarks>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="configure">Callback action for configuring <see cref="ConsoleExporterOptions"/>.</param>
/// <returns>The supplied instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// Adds Console exporter with LoggerProviderBuilder.
/// </summary>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="configure">Callback action for configuring <see cref="ConsoleExporterOptions"/>.</param>
/// <returns>The supplied instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
internal
#endif
static LoggerProviderBuilder AddConsoleExporter(
public static LoggerProviderBuilder AddConsoleExporter(
this LoggerProviderBuilder loggerProviderBuilder,
Action<ConsoleExporterOptions> configure)
=> AddConsoleExporter(loggerProviderBuilder, name: null, configure);
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds Console exporter with LoggerProviderBuilder.
/// </summary>
/// <remarks><inheritdoc cref="AddConsoleExporter(LoggerProviderBuilder)" path="/remarks"/></remarks>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="name">Name which is used when retrieving options.</param>
/// <param name="configure">Callback action for configuring <see cref="ConsoleExporterOptions"/>.</param>
/// <returns>The supplied instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// Adds Console exporter with LoggerProviderBuilder.
/// </summary>
@ -108,9 +62,7 @@ public static class ConsoleExporterLoggingExtensions
/// <param name="name">Name which is used when retrieving options.</param>
/// <param name="configure">Callback action for configuring <see cref="ConsoleExporterOptions"/>.</param>
/// <returns>The supplied instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
internal
#endif
static LoggerProviderBuilder AddConsoleExporter(
public static LoggerProviderBuilder AddConsoleExporter(
this LoggerProviderBuilder loggerProviderBuilder,
string name,
Action<ConsoleExporterOptions> configure)

1
src/OpenTelemetry.Exporter.InMemory/.publicApi/Experimental/PublicAPI.Unshipped.txt
View File

@ -1 +0,0 @@
static OpenTelemetry.Logs.InMemoryExporterLoggingExtensions.AddInMemoryExporter(this OpenTelemetry.Logs.LoggerProviderBuilder loggerProviderBuilder, System.Collections.Generic.ICollection<OpenTelemetry.Logs.LogRecord> exportedItems) -> OpenTelemetry.Logs.LoggerProviderBuilder

1
src/OpenTelemetry.Exporter.InMemory/.publicApi/Stable/PublicAPI.Unshipped.txt
View File

@ -0,0 +1 @@
static OpenTelemetry.Logs.InMemoryExporterLoggingExtensions.AddInMemoryExporter(this OpenTelemetry.Logs.LoggerProviderBuilder loggerProviderBuilder, System.Collections.Generic.ICollection<OpenTelemetry.Logs.LogRecord> exportedItems) -> OpenTelemetry.Logs.LoggerProviderBuilder

5
src/OpenTelemetry.Exporter.InMemory/CHANGELOG.md
View File

@ -2,6 +2,11 @@
## Unreleased
* The experimental APIs previously covered by `OTEL1000`
(`LoggerProviderBuilder.AddInMemoryExporter` extension) will now be part of
the public API and supported in stable builds.
([#5648](https://github.com/open-telemetry/opentelemetry-dotnet/pull/5648))
## 1.9.0-alpha.1
Released 2024-May-20

22
src/OpenTelemetry.Exporter.InMemory/InMemoryExporterLoggingExtensions.cs
View File

@ -1,9 +1,6 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
#if EXPOSE_EXPERIMENTAL_FEATURES && NET8_0_OR_GREATER
using System.Diagnostics.CodeAnalysis;
#endif
using OpenTelemetry.Exporter;
using OpenTelemetry.Internal;
@ -17,7 +14,7 @@ public static class InMemoryExporterLoggingExtensions
/// <param name="loggerOptions"><see cref="OpenTelemetryLoggerOptions"/> options to use.</param>
/// <param name="exportedItems">Collection which will be populated with the exported <see cref="LogRecord"/>.</param>
/// <returns>The supplied instance of <see cref="OpenTelemetryLoggerOptions"/> to chain the calls.</returns>
/// todo: [Obsolete("Call LoggerProviderBuilder.AddInMemoryExporter instead this method will be removed in a future version.")]
// TODO: [Obsolete("Call LoggerProviderBuilder.AddInMemoryExporter instead this method will be removed in a future version.")]
public static OpenTelemetryLoggerOptions AddInMemoryExporter(
this OpenTelemetryLoggerOptions loggerOptions,
ICollection<LogRecord> exportedItems)
@ -31,28 +28,13 @@ public static class InMemoryExporterLoggingExtensions
new SimpleLogRecordExportProcessor(logExporter));
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds InMemory exporter to the LoggerProviderBuilder.
/// </summary>
/// <remarks><b>WARNING</b>: This is an experimental API which might change or be removed in the future. Use at your own risk.</remarks>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="exportedItems">Collection which will be populated with the exported <see cref="LogRecord"/>.</param>
/// <returns>The supplied instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// Adds InMemory exporter to the LoggerProviderBuilder.
/// </summary>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="exportedItems">Collection which will be populated with the exported <see cref="LogRecord"/>.</param>
/// <returns>The supplied instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
internal
#endif
static LoggerProviderBuilder AddInMemoryExporter(
public static LoggerProviderBuilder AddInMemoryExporter(
this LoggerProviderBuilder loggerProviderBuilder,
ICollection<LogRecord> exportedItems)
{

5
src/OpenTelemetry.Exporter.OpenTelemetryProtocol/.publicApi/Experimental/PublicAPI.Unshipped.txt
View File

@ -1,5 +0,0 @@
static OpenTelemetry.Logs.OtlpLogExporterHelperExtensions.AddOtlpExporter(this OpenTelemetry.Logs.LoggerProviderBuilder! builder) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OtlpLogExporterHelperExtensions.AddOtlpExporter(this OpenTelemetry.Logs.LoggerProviderBuilder! builder, string? name, System.Action<OpenTelemetry.Exporter.OtlpExporterOptions!, OpenTelemetry.Logs.LogRecordExportProcessorOptions!>? configureExporterAndProcessor) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OtlpLogExporterHelperExtensions.AddOtlpExporter(this OpenTelemetry.Logs.LoggerProviderBuilder! builder, string? name, System.Action<OpenTelemetry.Exporter.OtlpExporterOptions!>? configureExporter) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OtlpLogExporterHelperExtensions.AddOtlpExporter(this OpenTelemetry.Logs.LoggerProviderBuilder! builder, System.Action<OpenTelemetry.Exporter.OtlpExporterOptions!, OpenTelemetry.Logs.LogRecordExportProcessorOptions!>! configureExporterAndProcessor) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OtlpLogExporterHelperExtensions.AddOtlpExporter(this OpenTelemetry.Logs.LoggerProviderBuilder! builder, System.Action<OpenTelemetry.Exporter.OtlpExporterOptions!>! configureExporter) -> OpenTelemetry.Logs.LoggerProviderBuilder!

5
src/OpenTelemetry.Exporter.OpenTelemetryProtocol/.publicApi/Stable/PublicAPI.Unshipped.txt
View File

@ -0,0 +1,5 @@
static OpenTelemetry.Logs.OtlpLogExporterHelperExtensions.AddOtlpExporter(this OpenTelemetry.Logs.LoggerProviderBuilder! builder) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OtlpLogExporterHelperExtensions.AddOtlpExporter(this OpenTelemetry.Logs.LoggerProviderBuilder! builder, string? name, System.Action<OpenTelemetry.Exporter.OtlpExporterOptions!, OpenTelemetry.Logs.LogRecordExportProcessorOptions!>? configureExporterAndProcessor) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OtlpLogExporterHelperExtensions.AddOtlpExporter(this OpenTelemetry.Logs.LoggerProviderBuilder! builder, string? name, System.Action<OpenTelemetry.Exporter.OtlpExporterOptions!>? configureExporter) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OtlpLogExporterHelperExtensions.AddOtlpExporter(this OpenTelemetry.Logs.LoggerProviderBuilder! builder, System.Action<OpenTelemetry.Exporter.OtlpExporterOptions!, OpenTelemetry.Logs.LogRecordExportProcessorOptions!>! configureExporterAndProcessor) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.OtlpLogExporterHelperExtensions.AddOtlpExporter(this OpenTelemetry.Logs.LoggerProviderBuilder! builder, System.Action<OpenTelemetry.Exporter.OtlpExporterOptions!>! configureExporter) -> OpenTelemetry.Logs.LoggerProviderBuilder!

5
src/OpenTelemetry.Exporter.OpenTelemetryProtocol/CHANGELOG.md
View File

@ -2,6 +2,11 @@
## Unreleased
* The experimental APIs previously covered by `OTEL1000`
(`LoggerProviderBuilder.AddOtlpExporter` extension) will now be part of the
public API and supported in stable builds.
([#5648](https://github.com/open-telemetry/opentelemetry-dotnet/pull/5648))
## 1.9.0-alpha.1
Released 2024-May-20

90
src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpLogExporterHelperExtensions.cs
View File

@ -4,9 +4,6 @@
#nullable enable
using System.Diagnostics;
#if EXPOSE_EXPERIMENTAL_FEATURES && NET8_0_OR_GREATER
using System.Diagnostics.CodeAnalysis;
#endif
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
@ -28,6 +25,7 @@ public static class OtlpLogExporterHelperExtensions
/// <remarks><inheritdoc cref="AddOtlpExporter(OpenTelemetryLoggerOptions, Action{OtlpExporterOptions})" path="/remarks"/></remarks>
/// <param name="loggerOptions"><see cref="OpenTelemetryLoggerOptions"/> options to use.</param>
/// <returns>The instance of <see cref="OpenTelemetryLoggerOptions"/> to chain the calls.</returns>
// TODO: [Obsolete("Call LoggerProviderBuilder.AddOtlpExporter instead this method will be removed in a future version.")]
public static OpenTelemetryLoggerOptions AddOtlpExporter(this OpenTelemetryLoggerOptions loggerOptions)
=> AddOtlpExporter(loggerOptions, name: null, configure: null);
@ -37,6 +35,7 @@ public static class OtlpLogExporterHelperExtensions
/// <param name="loggerOptions"><see cref="OpenTelemetryLoggerOptions"/> options to use.</param>
/// <param name="configure">Callback action for configuring <see cref="OtlpExporterOptions"/>.</param>
/// <returns>The instance of <see cref="OpenTelemetryLoggerOptions"/> to chain the calls.</returns>
// TODO: [Obsolete("Call LoggerProviderBuilder.AddOtlpExporter instead this method will be removed in a future version.")]
public static OpenTelemetryLoggerOptions AddOtlpExporter(
this OpenTelemetryLoggerOptions loggerOptions,
Action<OtlpExporterOptions> configure)
@ -49,6 +48,7 @@ public static class OtlpLogExporterHelperExtensions
/// <param name="name">Optional name which is used when retrieving options.</param>
/// <param name="configure">Optional callback action for configuring <see cref="OtlpExporterOptions"/>.</param>
/// <returns>The instance of <see cref="OpenTelemetryLoggerOptions"/> to chain the calls.</returns>
// TODO: [Obsolete("Call LoggerProviderBuilder.AddOtlpExporter instead this method will be removed in a future version.")]
public static OpenTelemetryLoggerOptions AddOtlpExporter(
this OpenTelemetryLoggerOptions loggerOptions,
string? name,
@ -81,6 +81,7 @@ public static class OtlpLogExporterHelperExtensions
/// <param name="loggerOptions"><see cref="OpenTelemetryLoggerOptions"/> options to use.</param>
/// <param name="configureExporterAndProcessor">Callback action for configuring <see cref="OtlpExporterOptions"/> and <see cref="LogRecordExportProcessorOptions"/>.</param>
/// <returns>The instance of <see cref="OpenTelemetryLoggerOptions"/> to chain the calls.</returns>
// TODO: [Obsolete("Call LoggerProviderBuilder.AddOtlpExporter instead this method will be removed in a future version.")]
public static OpenTelemetryLoggerOptions AddOtlpExporter(
this OpenTelemetryLoggerOptions loggerOptions,
Action<OtlpExporterOptions, LogRecordExportProcessorOptions> configureExporterAndProcessor)
@ -93,6 +94,7 @@ public static class OtlpLogExporterHelperExtensions
/// <param name="name">Optional name which is used when retrieving options.</param>
/// <param name="configureExporterAndProcessor">Optional callback action for configuring <see cref="OtlpExporterOptions"/> and <see cref="LogRecordExportProcessorOptions"/>.</param>
/// <returns>The instance of <see cref="OpenTelemetryLoggerOptions"/> to chain the calls.</returns>
// TODO: [Obsolete("Call LoggerProviderBuilder.AddOtlpExporter instead this method will be removed in a future version.")]
public static OpenTelemetryLoggerOptions AddOtlpExporter(
this OpenTelemetryLoggerOptions loggerOptions,
string? name,
@ -119,86 +121,34 @@ public static class OtlpLogExporterHelperExtensions
});
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds an OTLP exporter to the LoggerProvider.
/// </summary>
/// <remarks><b>WARNING</b>: This is an experimental API which might change or be removed in the future. Use at your own risk.</remarks>
/// <param name="builder"><see cref="LoggerProviderBuilder"/> builder to use.</param>
/// <returns>The instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// Adds an OTLP exporter to the LoggerProvider.
/// </summary>
/// <param name="builder"><see cref="LoggerProviderBuilder"/> builder to use.</param>
/// <returns>The instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
internal
#endif
static LoggerProviderBuilder AddOtlpExporter(this LoggerProviderBuilder builder)
public static LoggerProviderBuilder AddOtlpExporter(this LoggerProviderBuilder builder)
=> AddOtlpExporter(builder, name: null, configureExporter: null);
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds an OTLP exporter to the LoggerProvider.
/// </summary>
/// <remarks><b>WARNING</b>: This is an experimental API which might change or be removed in the future. Use at your own risk.</remarks>
/// <param name="builder"><see cref="LoggerProviderBuilder"/> builder to use.</param>
/// <param name="configureExporter">Callback action for configuring <see cref="OtlpExporterOptions"/>.</param>
/// <returns>The instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// Adds an OTLP exporter to the LoggerProvider.
/// </summary>
/// <param name="builder"><see cref="LoggerProviderBuilder"/> builder to use.</param>
/// <param name="configureExporter">Callback action for configuring <see cref="OtlpExporterOptions"/>.</param>
/// <returns>The instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
internal
#endif
static LoggerProviderBuilder AddOtlpExporter(this LoggerProviderBuilder builder, Action<OtlpExporterOptions> configureExporter)
public static LoggerProviderBuilder AddOtlpExporter(this LoggerProviderBuilder builder, Action<OtlpExporterOptions> configureExporter)
=> AddOtlpExporter(builder, name: null, configureExporter);
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds an OTLP exporter to the LoggerProvider.
/// </summary>
/// <remarks><b>WARNING</b>: This is an experimental API which might change or be removed in the future. Use at your own risk.</remarks>
/// <param name="builder"><see cref="LoggerProviderBuilder"/> builder to use.</param>
/// <param name="configureExporterAndProcessor">Callback action for
/// configuring <see cref="OtlpExporterOptions"/> and <see
/// cref="LogRecordExportProcessorOptions"/>.</param>
/// <returns>The instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
internal
#endif
static LoggerProviderBuilder AddOtlpExporter(this LoggerProviderBuilder builder, Action<OtlpExporterOptions, LogRecordExportProcessorOptions> configureExporterAndProcessor)
public static LoggerProviderBuilder AddOtlpExporter(this LoggerProviderBuilder builder, Action<OtlpExporterOptions, LogRecordExportProcessorOptions> configureExporterAndProcessor)
=> AddOtlpExporter(builder, name: null, configureExporterAndProcessor);
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds OpenTelemetry Protocol (OTLP) exporter to the LoggerProvider.
/// </summary>
/// <remarks><b>WARNING</b>: This is an experimental API which might change or be removed in the future. Use at your own risk.</remarks>
/// <param name="builder"><see cref="LoggerProviderBuilder"/> builder to use.</param>
/// <param name="name">Optional name which is used when retrieving options.</param>
/// <param name="configureExporter">Optional callback action for configuring <see cref="OtlpExporterOptions"/>.</param>
/// <returns>The instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// Adds OpenTelemetry Protocol (OTLP) exporter to the LoggerProvider.
/// </summary>
@ -206,9 +156,7 @@ public static class OtlpLogExporterHelperExtensions
/// <param name="name">Optional name which is used when retrieving options.</param>
/// <param name="configureExporter">Optional callback action for configuring <see cref="OtlpExporterOptions"/>.</param>
/// <returns>The instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
internal
#endif
static LoggerProviderBuilder AddOtlpExporter(
public static LoggerProviderBuilder AddOtlpExporter(
this LoggerProviderBuilder builder,
string? name,
Action<OtlpExporterOptions>? configureExporter)
@ -265,22 +213,6 @@ public static class OtlpLogExporterHelperExtensions
});
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds an OTLP exporter to the LoggerProvider.
/// </summary>
/// <remarks><b>WARNING</b>: This is an experimental API which might change or be removed in the future. Use at your own risk.</remarks>
/// <param name="builder"><see cref="LoggerProviderBuilder"/> builder to use.</param>
/// <param name="name">Optional name which is used when retrieving options.</param>
/// <param name="configureExporterAndProcessor">Optional callback action for
/// configuring <see cref="OtlpExporterOptions"/> and <see
/// cref="LogRecordExportProcessorOptions"/>.</param>
/// <returns>The instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// Adds an OTLP exporter to the LoggerProvider.
/// </summary>
@ -290,9 +222,7 @@ public static class OtlpLogExporterHelperExtensions
/// configuring <see cref="OtlpExporterOptions"/> and <see
/// cref="LogRecordExportProcessorOptions"/>.</param>
/// <returns>The instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
internal
#endif
static LoggerProviderBuilder AddOtlpExporter(
public static LoggerProviderBuilder AddOtlpExporter(
this LoggerProviderBuilder builder,
string? name,
Action<OtlpExporterOptions, LogRecordExportProcessorOptions>? configureExporterAndProcessor)

3
src/OpenTelemetry.Extensions.Hosting/.publicApi/Experimental/PublicAPI.Unshipped.txt
View File

@ -1,3 +0,0 @@
OpenTelemetry.OpenTelemetryBuilder.WithLogging() -> OpenTelemetry.OpenTelemetryBuilder!
OpenTelemetry.OpenTelemetryBuilder.WithLogging(System.Action<OpenTelemetry.Logs.LoggerProviderBuilder!>! configure) -> OpenTelemetry.OpenTelemetryBuilder!
OpenTelemetry.OpenTelemetryBuilder.WithLogging(System.Action<OpenTelemetry.Logs.LoggerProviderBuilder!>? configureBuilder, System.Action<OpenTelemetry.Logs.OpenTelemetryLoggerOptions!>? configureOptions) -> OpenTelemetry.OpenTelemetryBuilder!

3
src/OpenTelemetry.Extensions.Hosting/.publicApi/Stable/PublicAPI.Unshipped.txt
View File

@ -0,0 +1,3 @@
OpenTelemetry.OpenTelemetryBuilder.WithLogging() -> OpenTelemetry.OpenTelemetryBuilder!
OpenTelemetry.OpenTelemetryBuilder.WithLogging(System.Action<OpenTelemetry.Logs.LoggerProviderBuilder!>! configure) -> OpenTelemetry.OpenTelemetryBuilder!
OpenTelemetry.OpenTelemetryBuilder.WithLogging(System.Action<OpenTelemetry.Logs.LoggerProviderBuilder!>? configureBuilder, System.Action<OpenTelemetry.Logs.OpenTelemetryLoggerOptions!>? configureOptions) -> OpenTelemetry.OpenTelemetryBuilder!

5
src/OpenTelemetry.Extensions.Hosting/CHANGELOG.md
View File

@ -2,6 +2,11 @@
## Unreleased
* The experimental APIs previously covered by `OTEL1000`
(`OpenTelemetryBuilder.WithLogging` method) will now be part of the public API
and supported in stable builds.
([#5648](https://github.com/open-telemetry/opentelemetry-dotnet/pull/5648))
## 1.9.0-alpha.1
Released 2024-May-20

78
src/OpenTelemetry.Extensions.Hosting/OpenTelemetryBuilder.cs
View File

@ -1,9 +1,6 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
#if EXPOSE_EXPERIMENTAL_FEATURES && NET8_0_OR_GREATER
using System.Diagnostics.CodeAnalysis;
#endif
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Diagnostics.Metrics;
using Microsoft.Extensions.Logging;
@ -112,30 +109,6 @@ public sealed class OpenTelemetryBuilder : IOpenTelemetryBuilder
return this;
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds logging services into the builder.
/// </summary>
/// <remarks>
/// <para><b>WARNING</b>: This is an experimental API which might change or
/// be removed in the future. Use at your own risk.</para>
/// Notes:
/// <list type="bullet">
/// <item>This is safe to be called multiple times and by library authors.
/// Only a single <see cref="LoggerProvider"/> will be created for a given
/// <see cref="IServiceCollection"/>.</item>
/// <item>This method automatically registers an <see
/// cref="ILoggerProvider"/> named 'OpenTelemetry' into the <see
/// cref="IServiceCollection"/>.</item>
/// </list>
/// </remarks>
/// <returns>The supplied <see cref="OpenTelemetryBuilder"/> for chaining
/// calls.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// Adds logging services into the builder.
/// </summary>
@ -152,12 +125,9 @@ public sealed class OpenTelemetryBuilder : IOpenTelemetryBuilder
/// </remarks>
/// <returns>The supplied <see cref="OpenTelemetryBuilder"/> for chaining
/// calls.</returns>
internal
#endif
OpenTelemetryBuilder WithLogging()
public OpenTelemetryBuilder WithLogging()
=> this.WithLogging(configureBuilder: null, configureOptions: null);
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds logging services into the builder.
/// </summary>
@ -166,29 +136,13 @@ public sealed class OpenTelemetryBuilder : IOpenTelemetryBuilder
/// configuration callback.</param>
/// <returns>The supplied <see cref="OpenTelemetryBuilder"/> for chaining
/// calls.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// Adds logging services into the builder.
/// </summary>
/// <remarks><inheritdoc cref="WithLogging()" path="/remarks"/></remarks>
/// <param name="configure"><see cref="LoggerProviderBuilder"/>
/// configuration callback.</param>
/// <returns>The supplied <see cref="OpenTelemetryBuilder"/> for chaining
/// calls.</returns>
internal
#endif
OpenTelemetryBuilder WithLogging(Action<LoggerProviderBuilder> configure)
public OpenTelemetryBuilder WithLogging(Action<LoggerProviderBuilder> configure)
{
Guard.ThrowIfNull(configure);
return this.WithLogging(configureBuilder: configure, configureOptions: null);
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds logging services into the builder.
/// </summary>
@ -196,29 +150,15 @@ public sealed class OpenTelemetryBuilder : IOpenTelemetryBuilder
/// <param name="configureBuilder">Optional <see
/// cref="LoggerProviderBuilder"/> configuration callback.</param>
/// <param name="configureOptions">Optional <see
/// cref="OpenTelemetryLoggerOptions"/> configuration callback.</param>
/// cref="OpenTelemetryLoggerOptions"/> configuration callback. <see
/// cref="OpenTelemetryLoggerOptions"/> are used by the <see
/// cref="ILoggerProvider"/> named 'OpenTelemetry' automatically registered
/// by this method.</param>
/// <returns>The supplied <see cref="OpenTelemetryBuilder"/> for chaining
/// calls.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// Adds logging services into the builder.
/// </summary>
/// <remarks><inheritdoc cref="WithLogging()" path="/remarks"/></remarks>
/// <param name="configureBuilder">Optional <see
/// cref="LoggerProviderBuilder"/> configuration callback.</param>
/// <param name="configureOptions">Optional <see
/// cref="OpenTelemetryLoggerOptions"/> configuration callback.</param>
/// <returns>The supplied <see cref="OpenTelemetryBuilder"/> for chaining
/// calls.</returns>
internal
#endif
OpenTelemetryBuilder WithLogging(
Action<LoggerProviderBuilder>? configureBuilder,
Action<OpenTelemetryLoggerOptions>? configureOptions)
public OpenTelemetryBuilder WithLogging(
Action<LoggerProviderBuilder>? configureBuilder,
Action<OpenTelemetryLoggerOptions>? configureOptions)
{
OpenTelemetryBuilderSdkExtensions.WithLogging(this, configureBuilder, configureOptions);

16
src/OpenTelemetry/.publicApi/Experimental/PublicAPI.Unshipped.txt
View File

@ -1,8 +1,6 @@
abstract OpenTelemetry.Metrics.ExemplarReservoir.Collect() -> OpenTelemetry.Metrics.ReadOnlyExemplarCollection
abstract OpenTelemetry.Metrics.ExemplarReservoir.Offer(in OpenTelemetry.Metrics.ExemplarMeasurement<double> measurement) -> void
abstract OpenTelemetry.Metrics.ExemplarReservoir.Offer(in OpenTelemetry.Metrics.ExemplarMeasurement<long> measurement) -> void
OpenTelemetry.Logs.LoggerProviderBuilderExtensions
OpenTelemetry.Logs.LoggerProviderExtensions
OpenTelemetry.Logs.LogRecord.Logger.get -> OpenTelemetry.Logs.Logger!
OpenTelemetry.Logs.LogRecord.Severity.get -> OpenTelemetry.Logs.LogRecordSeverity?
OpenTelemetry.Logs.LogRecord.Severity.set -> void
@ -24,20 +22,8 @@ OpenTelemetry.Metrics.MetricStreamConfiguration.CardinalityLimit.set -> void
OpenTelemetry.Metrics.MetricStreamConfiguration.ExemplarReservoirFactory.get -> System.Func<OpenTelemetry.Metrics.ExemplarReservoir?>?
OpenTelemetry.Metrics.MetricStreamConfiguration.ExemplarReservoirFactory.set -> void
override sealed OpenTelemetry.Metrics.FixedSizeExemplarReservoir.Collect() -> OpenTelemetry.Metrics.ReadOnlyExemplarCollection
static OpenTelemetry.Logs.LoggerProviderBuilderExtensions.AddProcessor(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder, OpenTelemetry.BaseProcessor<OpenTelemetry.Logs.LogRecord!>! processor) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.LoggerProviderBuilderExtensions.AddProcessor(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder, System.Func<System.IServiceProvider!, OpenTelemetry.BaseProcessor<OpenTelemetry.Logs.LogRecord!>!>! implementationFactory) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.LoggerProviderBuilderExtensions.AddProcessor<T>(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.LoggerProviderBuilderExtensions.Build(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder) -> OpenTelemetry.Logs.LoggerProvider!
static OpenTelemetry.Logs.LoggerProviderBuilderExtensions.ConfigureResource(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder, System.Action<OpenTelemetry.Resources.ResourceBuilder!>! configure) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.LoggerProviderBuilderExtensions.SetResourceBuilder(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder, OpenTelemetry.Resources.ResourceBuilder! resourceBuilder) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.LoggerProviderExtensions.AddProcessor(this OpenTelemetry.Logs.LoggerProvider! provider, OpenTelemetry.BaseProcessor<OpenTelemetry.Logs.LogRecord!>! processor) -> OpenTelemetry.Logs.LoggerProvider!
static OpenTelemetry.Logs.LoggerProviderExtensions.ForceFlush(this OpenTelemetry.Logs.LoggerProvider! provider, int timeoutMilliseconds = -1) -> bool
static OpenTelemetry.Logs.LoggerProviderExtensions.Shutdown(this OpenTelemetry.Logs.LoggerProvider! provider, int timeoutMilliseconds = -1) -> bool
static OpenTelemetry.OpenTelemetryBuilderSdkExtensions.WithLogging(this OpenTelemetry.IOpenTelemetryBuilder! builder) -> OpenTelemetry.IOpenTelemetryBuilder!
static OpenTelemetry.OpenTelemetryBuilderSdkExtensions.WithLogging(this OpenTelemetry.IOpenTelemetryBuilder! builder, System.Action<OpenTelemetry.Logs.LoggerProviderBuilder!>! configure) -> OpenTelemetry.IOpenTelemetryBuilder!
static OpenTelemetry.OpenTelemetryBuilderSdkExtensions.WithLogging(this OpenTelemetry.IOpenTelemetryBuilder! builder, System.Action<OpenTelemetry.Logs.LoggerProviderBuilder!>? configureBuilder, System.Action<OpenTelemetry.Logs.OpenTelemetryLoggerOptions!>? configureOptions) -> OpenTelemetry.IOpenTelemetryBuilder!
static OpenTelemetry.Sdk.CreateLoggerProviderBuilder() -> OpenTelemetry.Logs.LoggerProviderBuilder!
static Microsoft.Extensions.Logging.OpenTelemetryLoggingExtensions.UseOpenTelemetry(this Microsoft.Extensions.Logging.ILoggingBuilder! builder) -> Microsoft.Extensions.Logging.ILoggingBuilder!
static Microsoft.Extensions.Logging.OpenTelemetryLoggingExtensions.UseOpenTelemetry(this Microsoft.Extensions.Logging.ILoggingBuilder! builder, System.Action<OpenTelemetry.Logs.LoggerProviderBuilder!>! configure) -> Microsoft.Extensions.Logging.ILoggingBuilder!
static Microsoft.Extensions.Logging.OpenTelemetryLoggingExtensions.UseOpenTelemetry(this Microsoft.Extensions.Logging.ILoggingBuilder! builder, System.Action<OpenTelemetry.Logs.LoggerProviderBuilder!>? configureBuilder, System.Action<OpenTelemetry.Logs.OpenTelemetryLoggerOptions!>? configureOptions) -> Microsoft.Extensions.Logging.ILoggingBuilder!
static OpenTelemetry.Sdk.CreateLoggerProviderBuilder() -> OpenTelemetry.Logs.LoggerProviderBuilder!
virtual OpenTelemetry.Metrics.FixedSizeExemplarReservoir.OnCollected() -> void

14
src/OpenTelemetry/.publicApi/Stable/PublicAPI.Unshipped.txt
View File

@ -1,3 +1,5 @@
OpenTelemetry.Logs.LoggerProviderBuilderExtensions
OpenTelemetry.Logs.LoggerProviderExtensions
OpenTelemetry.Metrics.Exemplar
OpenTelemetry.Metrics.Exemplar.DoubleValue.get -> double
OpenTelemetry.Metrics.Exemplar.Exemplar() -> void
@ -25,4 +27,16 @@ OpenTelemetry.ReadOnlyFilteredTagCollection.Enumerator.Enumerator() -> void
OpenTelemetry.ReadOnlyFilteredTagCollection.Enumerator.MoveNext() -> bool
OpenTelemetry.ReadOnlyFilteredTagCollection.GetEnumerator() -> OpenTelemetry.ReadOnlyFilteredTagCollection.Enumerator
OpenTelemetry.ReadOnlyFilteredTagCollection.ReadOnlyFilteredTagCollection() -> void
static OpenTelemetry.OpenTelemetryBuilderSdkExtensions.WithLogging(this OpenTelemetry.IOpenTelemetryBuilder! builder) -> OpenTelemetry.IOpenTelemetryBuilder!
static OpenTelemetry.OpenTelemetryBuilderSdkExtensions.WithLogging(this OpenTelemetry.IOpenTelemetryBuilder! builder, System.Action<OpenTelemetry.Logs.LoggerProviderBuilder!>! configure) -> OpenTelemetry.IOpenTelemetryBuilder!
static OpenTelemetry.OpenTelemetryBuilderSdkExtensions.WithLogging(this OpenTelemetry.IOpenTelemetryBuilder! builder, System.Action<OpenTelemetry.Logs.LoggerProviderBuilder!>? configureBuilder, System.Action<OpenTelemetry.Logs.OpenTelemetryLoggerOptions!>? configureOptions) -> OpenTelemetry.IOpenTelemetryBuilder!
static OpenTelemetry.Logs.LoggerProviderBuilderExtensions.AddProcessor(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder, OpenTelemetry.BaseProcessor<OpenTelemetry.Logs.LogRecord!>! processor) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.LoggerProviderBuilderExtensions.AddProcessor(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder, System.Func<System.IServiceProvider!, OpenTelemetry.BaseProcessor<OpenTelemetry.Logs.LogRecord!>!>! implementationFactory) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.LoggerProviderBuilderExtensions.AddProcessor<T>(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.LoggerProviderBuilderExtensions.Build(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder) -> OpenTelemetry.Logs.LoggerProvider!
static OpenTelemetry.Logs.LoggerProviderBuilderExtensions.ConfigureResource(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder, System.Action<OpenTelemetry.Resources.ResourceBuilder!>! configure) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.LoggerProviderBuilderExtensions.SetResourceBuilder(this OpenTelemetry.Logs.LoggerProviderBuilder! loggerProviderBuilder, OpenTelemetry.Resources.ResourceBuilder! resourceBuilder) -> OpenTelemetry.Logs.LoggerProviderBuilder!
static OpenTelemetry.Logs.LoggerProviderExtensions.AddProcessor(this OpenTelemetry.Logs.LoggerProvider! provider, OpenTelemetry.BaseProcessor<OpenTelemetry.Logs.LogRecord!>! processor) -> OpenTelemetry.Logs.LoggerProvider!
static OpenTelemetry.Logs.LoggerProviderExtensions.ForceFlush(this OpenTelemetry.Logs.LoggerProvider! provider, int timeoutMilliseconds = -1) -> bool
static OpenTelemetry.Logs.LoggerProviderExtensions.Shutdown(this OpenTelemetry.Logs.LoggerProvider! provider, int timeoutMilliseconds = -1) -> bool
static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.SetExemplarFilter(this OpenTelemetry.Metrics.MeterProviderBuilder! meterProviderBuilder, OpenTelemetry.Metrics.ExemplarFilterType exemplarFilter) -> OpenTelemetry.Metrics.MeterProviderBuilder!

10
src/OpenTelemetry/BatchExportProcessor.cs
View File

@ -20,10 +20,10 @@ public abstract class BatchExportProcessor<T> : BaseExportProcessor<T>
internal const int DefaultMaxExportBatchSize = 512;
internal readonly int MaxExportBatchSize;
internal readonly int ScheduledDelayMilliseconds;
internal readonly int ExporterTimeoutMilliseconds;
private readonly CircularBuffer<T> circularBuffer;
private readonly int scheduledDelayMilliseconds;
private readonly int exporterTimeoutMilliseconds;
private readonly Thread exporterThread;
private readonly AutoResetEvent exportTrigger = new(false);
private readonly ManualResetEvent dataExportedNotification = new(false);
@ -54,8 +54,8 @@ public abstract class BatchExportProcessor<T> : BaseExportProcessor<T>
Guard.ThrowIfOutOfRange(exporterTimeoutMilliseconds, min: 0);
this.circularBuffer = new CircularBuffer<T>(maxQueueSize);
this.scheduledDelayMilliseconds = scheduledDelayMilliseconds;
this.exporterTimeoutMilliseconds = exporterTimeoutMilliseconds;
this.ScheduledDelayMilliseconds = scheduledDelayMilliseconds;
this.ExporterTimeoutMilliseconds = exporterTimeoutMilliseconds;
this.MaxExportBatchSize = maxExportBatchSize;
this.exporterThread = new Thread(this.ExporterProc)
{
@ -252,7 +252,7 @@ public abstract class BatchExportProcessor<T> : BaseExportProcessor<T>
{
try
{
WaitHandle.WaitAny(triggers, this.scheduledDelayMilliseconds);
WaitHandle.WaitAny(triggers, this.ScheduledDelayMilliseconds);
}
catch (ObjectDisposedException)
{

6
src/OpenTelemetry/CHANGELOG.md
View File

@ -2,6 +2,12 @@
## Unreleased
* The experimental APIs previously covered by `OTEL1000`
(`LoggerProviderBuilder` `AddProcessor` & `ConfigureResource` extensions, and
`LoggerProvider` `ForceFlush` & `Shutdown` extensions) will now be part of the
public API and supported in stable builds.
([#5648](https://github.com/open-telemetry/opentelemetry-dotnet/pull/5648))
## 1.9.0-alpha.1
Released 2024-May-20

79
src/OpenTelemetry/Logs/Builder/LoggerProviderBuilderExtensions.cs
View File

@ -14,30 +14,8 @@ namespace OpenTelemetry.Logs;
/// <summary>
/// Contains extension methods for the <see cref="LoggerProviderBuilder"/> class.
/// </summary>
#if EXPOSE_EXPERIMENTAL_FEATURES
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
internal
#endif
static class LoggerProviderBuilderExtensions
public static class LoggerProviderBuilderExtensions
{
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Sets the <see cref="ResourceBuilder"/> from which the <see cref="Resource"/> associated with
/// this provider is built from.
/// </summary>
/// <remarks>
/// <para><inheritdoc cref="Sdk.CreateLoggerProviderBuilder" path="/remarks"/></para>
/// Note: Calling <see cref="SetResourceBuilder(LoggerProviderBuilder, ResourceBuilder)"/> will override the currently set <see cref="ResourceBuilder"/>.
/// To modify the current <see cref="ResourceBuilder"/> call <see cref="ConfigureResource(LoggerProviderBuilder, Action{ResourceBuilder})"/> instead.
/// </remarks>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="resourceBuilder"><see cref="ResourceBuilder"/> from which Resource will be built.</param>
/// <returns>Returns <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#else
/// <summary>
/// Sets the <see cref="ResourceBuilder"/> from which the <see cref="Resource"/> associated with
/// this provider is built from.
@ -49,7 +27,6 @@ internal
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="resourceBuilder"><see cref="ResourceBuilder"/> from which Resource will be built.</param>
/// <returns>Returns <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#endif
public static LoggerProviderBuilder SetResourceBuilder(this LoggerProviderBuilder loggerProviderBuilder, ResourceBuilder resourceBuilder)
{
Guard.ThrowIfNull(resourceBuilder);
@ -65,16 +42,6 @@ internal
return loggerProviderBuilder;
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Modify in-place the <see cref="ResourceBuilder"/> from which the <see cref="Resource"/> associated with
/// this provider is built from.
/// </summary>
/// <remarks><inheritdoc cref="Sdk.CreateLoggerProviderBuilder" path="/remarks"/></remarks>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="configure">An action which modifies the provided <see cref="ResourceBuilder"/> in-place.</param>
/// <returns>Returns <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#else
/// <summary>
/// Modify in-place the <see cref="ResourceBuilder"/> from which the <see cref="Resource"/> associated with
/// this provider is built from.
@ -82,7 +49,6 @@ internal
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="configure">An action which modifies the provided <see cref="ResourceBuilder"/> in-place.</param>
/// <returns>Returns <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#endif
public static LoggerProviderBuilder ConfigureResource(this LoggerProviderBuilder loggerProviderBuilder, Action<ResourceBuilder> configure)
{
Guard.ThrowIfNull(configure);
@ -98,22 +64,12 @@ internal
return loggerProviderBuilder;
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds a processor to the provider.
/// </summary>
/// <remarks><inheritdoc cref="Sdk.CreateLoggerProviderBuilder" path="/remarks"/></remarks>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="processor">LogRecord processor to add.</param>
/// <returns>Returns <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#else
/// <summary>
/// Adds a processor to the provider.
/// </summary>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="processor">LogRecord processor to add.</param>
/// <returns>Returns <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#endif
public static LoggerProviderBuilder AddProcessor(this LoggerProviderBuilder loggerProviderBuilder, BaseProcessor<LogRecord> processor)
{
Guard.ThrowIfNull(processor);
@ -129,19 +85,6 @@ internal
return loggerProviderBuilder;
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds a processor to the provider which will be retrieved using dependency injection.
/// </summary>
/// <remarks>
/// <para><inheritdoc cref="Sdk.CreateLoggerProviderBuilder" path="/remarks"/></para>
/// Note: The type specified by <typeparamref name="T"/> will be
/// registered as a singleton service into application services.
/// </remarks>
/// <typeparam name="T">Processor type.</typeparam>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <returns>The supplied <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#else
/// <summary>
/// Adds a processor to the provider which will be retrieved using dependency injection.
/// </summary>
@ -152,7 +95,6 @@ internal
/// <typeparam name="T">Processor type.</typeparam>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <returns>The supplied <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#endif
public static LoggerProviderBuilder AddProcessor<
#if NET6_0_OR_GREATER
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]
@ -173,22 +115,12 @@ internal
return loggerProviderBuilder;
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds a processor to the provider which will be retrieved using dependency injection.
/// </summary>
/// <remarks><inheritdoc cref="Sdk.CreateLoggerProviderBuilder" path="/remarks"/></remarks>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="implementationFactory">The factory that creates the service.</param>
/// <returns>The supplied <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#else
/// <summary>
/// Adds a processor to the provider which will be retrieved using dependency injection.
/// </summary>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <param name="implementationFactory">The factory that creates the service.</param>
/// <returns>The supplied <see cref="LoggerProviderBuilder"/> for chaining.</returns>
#endif
public static LoggerProviderBuilder AddProcessor(
this LoggerProviderBuilder loggerProviderBuilder,
Func<IServiceProvider, BaseProcessor<LogRecord>> implementationFactory)
@ -206,20 +138,11 @@ internal
return loggerProviderBuilder;
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Run the given actions to initialize the <see cref="LoggerProvider"/>.
/// </summary>
/// <remarks><inheritdoc cref="Sdk.CreateLoggerProviderBuilder" path="/remarks"/></remarks>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <returns><see cref="LoggerProvider"/>.</returns>
#else
/// <summary>
/// Run the given actions to initialize the <see cref="LoggerProvider"/>.
/// </summary>
/// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
/// <returns><see cref="LoggerProvider"/>.</returns>
#endif
public static LoggerProvider Build(this LoggerProviderBuilder loggerProviderBuilder)
{
if (loggerProviderBuilder is LoggerProviderBuilderBase loggerProviderBuilderBase)

3
src/OpenTelemetry/Logs/ILogger/OpenTelemetryLoggerOptions.cs
View File

@ -82,6 +82,7 @@ public class OpenTelemetryLoggerOptions
/// </summary>
/// <param name="processor">Log processor to add.</param>
/// <returns>Returns <see cref="OpenTelemetryLoggerOptions"/> for chaining.</returns>
// TODO: [Obsolete("Use LoggerProviderBuilder.AddProcessor instead this method will be removed in a future version.")]
public OpenTelemetryLoggerOptions AddProcessor(BaseProcessor<LogRecord> processor)
{
Guard.ThrowIfNull(processor);
@ -96,6 +97,7 @@ public class OpenTelemetryLoggerOptions
/// </summary>
/// <param name="implementationFactory">The factory that creates the service.</param>
/// <returns>Returns <see cref="OpenTelemetryLoggerOptions"/> for chaining.</returns>
// TODO: [Obsolete("Use LoggerProviderBuilder.AddProcessor instead this method will be removed in a future version.")]
public OpenTelemetryLoggerOptions AddProcessor(
Func<IServiceProvider, BaseProcessor<LogRecord>> implementationFactory)
{
@ -112,6 +114,7 @@ public class OpenTelemetryLoggerOptions
/// </summary>
/// <param name="resourceBuilder"><see cref="ResourceBuilder"/> from which Resource will be built.</param>
/// <returns>Returns <see cref="OpenTelemetryLoggerOptions"/> for chaining.</returns>
// TODO: [Obsolete("Use LoggerProviderBuilder.SetResourceBuilder instead this method will be removed in a future version.")]
public OpenTelemetryLoggerOptions SetResourceBuilder(ResourceBuilder resourceBuilder)
{
Guard.ThrowIfNull(resourceBuilder);

49
src/OpenTelemetry/Logs/ILogger/OpenTelemetryLoggingExtensions.cs
View File

@ -1,13 +1,10 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
using System.Diagnostics;
#if NET6_0_OR_GREATER
using System.Diagnostics.CodeAnalysis;
#endif
#if EXPOSE_EXPERIMENTAL_FEATURES
using System.ComponentModel;
#endif
using System.Diagnostics;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Logging;
@ -39,11 +36,10 @@ public static class OpenTelemetryLoggingExtensions
/// </remarks>
/// <param name="builder">The <see cref="ILoggingBuilder"/> to use.</param>
/// <returns>The supplied <see cref="ILoggingBuilder"/> for call chaining.</returns>
#if EXPOSE_EXPERIMENTAL_FEATURES
// todo: [Obsolete("Call UseOpenTelemetry instead this method will be removed in a future version.")]
/* TODO:
// Note: We hide AddOpenTelemetry from IDEs using EditorBrowsable when UseOpenTelemetry is present to reduce confusion.
[EditorBrowsable(EditorBrowsableState.Never)]
#endif
[Obsolete("Call UseOpenTelemetry instead this method will be removed in a future version.")] */
public static ILoggingBuilder AddOpenTelemetry(
this ILoggingBuilder builder)
=> AddOpenTelemetryInternal(builder, configureBuilder: null, configureOptions: null);
@ -55,11 +51,10 @@ public static class OpenTelemetryLoggingExtensions
/// <param name="builder">The <see cref="ILoggingBuilder"/> to use.</param>
/// <param name="configure">Optional configuration action.</param>
/// <returns>The supplied <see cref="ILoggingBuilder"/> for call chaining.</returns>
#if EXPOSE_EXPERIMENTAL_FEATURES
// todo: [Obsolete("Call UseOpenTelemetry instead this method will be removed in a future version.")]
/* TODO:
// Note: We hide AddOpenTelemetry from IDEs using EditorBrowsable when UseOpenTelemetry is present to reduce confusion.
[EditorBrowsable(EditorBrowsableState.Never)]
#endif
[Obsolete("Call UseOpenTelemetry instead this method will be removed in a future version.")]*/
public static ILoggingBuilder AddOpenTelemetry(
this ILoggingBuilder builder,
Action<OpenTelemetryLoggerOptions>? configure)
@ -70,7 +65,6 @@ public static class OpenTelemetryLoggingExtensions
/// Adds an OpenTelemetry logger named 'OpenTelemetry' to the <see cref="ILoggerFactory"/>.
/// </summary>
/// <remarks>
/// <para><b>WARNING</b>: This is an experimental API which might change or be removed in the future. Use at your own risk.</para>
/// Note: This is safe to be called multiple times and by library authors.
/// Only a single <see cref="OpenTelemetryLoggerProvider"/> will be created
/// for a given <see cref="IServiceCollection"/>.
@ -82,19 +76,9 @@ public static class OpenTelemetryLoggingExtensions
#endif
public
#else
/// <summary>
/// Adds an OpenTelemetry logger named 'OpenTelemetry' to the <see cref="ILoggerFactory"/>.
/// </summary>
/// <remarks>
/// Note: This is safe to be called multiple times and by library authors.
/// Only a single <see cref="OpenTelemetryLoggerProvider"/> will be created
/// for a given <see cref="IServiceCollection"/>.
/// </remarks>
/// <param name="builder">The <see cref="ILoggingBuilder"/> to use.</param>
/// <returns>The supplied <see cref="ILoggingBuilder"/> for call chaining.</returns>
internal
#endif
static ILoggingBuilder UseOpenTelemetry(
static ILoggingBuilder UseOpenTelemetry(
this ILoggingBuilder builder)
=> AddOpenTelemetryInternal(builder, configureBuilder: null, configureOptions: null);
@ -104,23 +88,16 @@ public static class OpenTelemetryLoggingExtensions
/// </summary>
/// <remarks><inheritdoc cref="UseOpenTelemetry(ILoggingBuilder)" path="/remarks"/></remarks>
/// <param name="builder">The <see cref="ILoggingBuilder"/> to use.</param>
/// <param name="configure">Optional <see cref="LoggerProviderBuilder"/> configuration action.</param>
/// <param name="configure"><see cref="LoggerProviderBuilder"/> configuration action.</param>
/// <returns>The supplied <see cref="ILoggingBuilder"/> for call chaining.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// Adds an OpenTelemetry logger named 'OpenTelemetry' to the <see cref="ILoggerFactory"/>.
/// </summary>
/// <remarks><inheritdoc cref="UseOpenTelemetry(ILoggingBuilder)" path="/remarks"/></remarks>
/// <param name="builder">The <see cref="ILoggingBuilder"/> to use.</param>
/// <param name="configure"><see cref="LoggerProviderBuilder"/> configuration action.</param>
/// <returns>The supplied <see cref="ILoggingBuilder"/> for call chaining.</returns>
internal
#endif
static ILoggingBuilder UseOpenTelemetry(
static ILoggingBuilder UseOpenTelemetry(
this ILoggingBuilder builder,
Action<LoggerProviderBuilder> configure)
{
@ -143,17 +120,9 @@ public static class OpenTelemetryLoggingExtensions
#endif
public
#else
/// <summary>
/// Adds an OpenTelemetry logger named 'OpenTelemetry' to the <see cref="ILoggerFactory"/>.
/// </summary>
/// <remarks><inheritdoc cref="UseOpenTelemetry(ILoggingBuilder)" path="/remarks"/></remarks>
/// <param name="builder">The <see cref="ILoggingBuilder"/> to use.</param>
/// <param name="configureBuilder">Optional <see cref="LoggerProviderBuilder"/> configuration action.</param>
/// <param name="configureOptions">Optional <see cref="OpenTelemetryLoggerOptions"/> configuration action.</param>
/// <returns>The supplied <see cref="ILoggingBuilder"/> for call chaining.</returns>
internal
#endif
static ILoggingBuilder UseOpenTelemetry(
static ILoggingBuilder UseOpenTelemetry(
this ILoggingBuilder builder,
Action<LoggerProviderBuilder>? configureBuilder,
Action<OpenTelemetryLoggerOptions>? configureOptions)

73
src/OpenTelemetry/Logs/LoggerProviderExtensions.cs
View File

@ -1,9 +1,6 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
#if EXPOSE_EXPERIMENTAL_FEATURES && NET8_0_OR_GREATER
using System.Diagnostics.CodeAnalysis;
#endif
using OpenTelemetry.Internal;
namespace OpenTelemetry.Logs;
@ -11,30 +8,8 @@ namespace OpenTelemetry.Logs;
/// <summary>
/// Contains extension methods for the <see cref="LoggerProvider"/> class.
/// </summary>
#if EXPOSE_EXPERIMENTAL_FEATURES
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
internal
#endif
static class LoggerProviderExtensions
public static class LoggerProviderExtensions
{
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Add a processor to the <see cref="LoggerProvider"/>.
/// </summary>
/// <remarks>
/// <para><inheritdoc cref="Sdk.CreateLoggerProviderBuilder" path="/remarks"/></para>
/// Note: The supplied <paramref name="processor"/> will be
/// automatically disposed when then the <see
/// cref="LoggerProvider"/> is disposed.
/// </remarks>
/// <param name="provider"><see cref="LoggerProvider"/> instance on which ForceFlush will be called.</param>
/// <param name="processor">Log processor to add.</param>
/// <returns>The supplied <see cref="OpenTelemetryLoggerOptions"/> for chaining.</returns>
#else
/// <summary>
/// Add a processor to the <see cref="LoggerProvider"/>.
/// </summary>
@ -46,7 +21,6 @@ internal
/// <param name="provider"><see cref="LoggerProvider"/> instance on which ForceFlush will be called.</param>
/// <param name="processor">Log processor to add.</param>
/// <returns>The supplied <see cref="OpenTelemetryLoggerOptions"/> for chaining.</returns>
#endif
public static LoggerProvider AddProcessor(this LoggerProvider provider, BaseProcessor<LogRecord> processor)
{
Guard.ThrowIfNull(provider);
@ -60,27 +34,6 @@ internal
return provider;
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Flushes all the processors registered under <see cref="LoggerProvider"/>, blocks the current thread
/// until flush completed, shutdown signaled or timed out.
/// </summary>
/// <param name="provider"><see cref="LoggerProvider"/> instance on which ForceFlush will be called.</param>
/// <param name="timeoutMilliseconds">
/// The number (non-negative) of milliseconds to wait, or
/// <c>Timeout.Infinite</c> to wait indefinitely.
/// </param>
/// <returns>
/// Returns <c>true</c> when force flush succeeded; otherwise, <c>false</c>.
/// </returns>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown when the <c>timeoutMilliseconds</c> is smaller than -1.
/// </exception>
/// <remarks>
/// <para><inheritdoc cref="Sdk.CreateLoggerProviderBuilder" path="/remarks"/></para>
/// This function guarantees thread-safety.
/// </remarks>
#else
/// <summary>
/// Flushes all the processors registered under <see cref="LoggerProvider"/>, blocks the current thread
/// until flush completed, shutdown signaled or timed out.
@ -99,7 +52,6 @@ internal
/// <remarks>
/// This function guarantees thread-safety.
/// </remarks>
#endif
public static bool ForceFlush(this LoggerProvider provider, int timeoutMilliseconds = Timeout.Infinite)
{
Guard.ThrowIfNull(provider);
@ -113,28 +65,6 @@ internal
return true;
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Attempts to shutdown the <see cref="LoggerProvider"/>, blocks the current thread until
/// shutdown completed or timed out.
/// </summary>
/// <param name="provider"><see cref="LoggerProvider"/> instance on which Shutdown will be called.</param>
/// <param name="timeoutMilliseconds">
/// The number (non-negative) of milliseconds to wait, or
/// <c>Timeout.Infinite</c> to wait indefinitely.
/// </param>
/// <returns>
/// Returns <c>true</c> when shutdown succeeded; otherwise, <c>false</c>.
/// </returns>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown when the <c>timeoutMilliseconds</c> is smaller than -1.
/// </exception>
/// <remarks>
/// <para><inheritdoc cref="Sdk.CreateLoggerProviderBuilder" path="/remarks"/></para>
/// This function guarantees thread-safety. Only the first call will
/// win, subsequent calls will be no-op.
/// </remarks>
#else
/// <summary>
/// Attempts to shutdown the <see cref="LoggerProvider"/>, blocks the current thread until
/// shutdown completed or timed out.
@ -154,7 +84,6 @@ internal
/// This function guarantees thread-safety. Only the first call will
/// win, subsequent calls will be no-op.
/// </remarks>
#endif
public static bool Shutdown(this LoggerProvider provider, int timeoutMilliseconds = Timeout.Infinite)
{
Guard.ThrowIfNull(provider);

7
src/OpenTelemetry/Logs/LoggerProviderSdk.cs
View File

@ -194,7 +194,12 @@ internal sealed class LoggerProviderSdk : LoggerProvider
}
/// <inheritdoc />
protected override bool TryCreateLogger(
#if EXPOSE_EXPERIMENTAL_FEATURES
protected
#else
internal
#endif
override bool TryCreateLogger(
string? name,
#if NETSTANDARD2_1_OR_GREATER || NET6_0_OR_GREATER
[NotNullWhen(true)]

87
src/OpenTelemetry/OpenTelemetryBuilderSdkExtensions.cs
View File

@ -1,9 +1,6 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
#if EXPOSE_EXPERIMENTAL_FEATURES && NET8_0_OR_GREATER
using System.Diagnostics.CodeAnalysis;
#endif
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Diagnostics.Metrics;
using Microsoft.Extensions.Logging;
@ -129,31 +126,6 @@ public static class OpenTelemetryBuilderSdkExtensions
return builder;
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds logging services into the builder.
/// </summary>
/// <param name="builder"><see cref="IOpenTelemetryBuilder"/>.</param>
/// <remarks>
/// <para><b>WARNING</b>: This is an experimental API which might change or
/// be removed in the future. Use at your own risk.</para>
/// Notes:
/// <list type="bullet">
/// <item>This is safe to be called multiple times and by library authors.
/// Only a single <see cref="LoggerProvider"/> will be created for a given
/// <see cref="IServiceCollection"/>.</item>
/// <item>This method automatically registers an <see
/// cref="ILoggerProvider"/> named 'OpenTelemetry' into the <see
/// cref="IServiceCollection"/>.</item>
/// </list>
/// </remarks>
/// <returns>The supplied <see cref="IOpenTelemetryBuilder"/> for chaining
/// calls.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// Adds logging services into the builder.
/// </summary>
@ -171,12 +143,9 @@ public static class OpenTelemetryBuilderSdkExtensions
/// </remarks>
/// <returns>The supplied <see cref="IOpenTelemetryBuilder"/> for chaining
/// calls.</returns>
internal
#endif
static IOpenTelemetryBuilder WithLogging(this IOpenTelemetryBuilder builder)
public static IOpenTelemetryBuilder WithLogging(this IOpenTelemetryBuilder builder)
=> WithLogging(builder, configureBuilder: null, configureOptions: null);
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds logging services into the builder.
/// </summary>
@ -186,32 +155,15 @@ public static class OpenTelemetryBuilderSdkExtensions
/// configuration callback.</param>
/// <returns>The supplied <see cref="IOpenTelemetryBuilder"/> for chaining
/// calls.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// Adds logging services into the builder.
/// </summary>
/// <remarks><inheritdoc cref="WithLogging(IOpenTelemetryBuilder)" path="/remarks"/></remarks>
/// <param name="builder"><see cref="IOpenTelemetryBuilder"/>.</param>
/// <param name="configure"><see cref="LoggerProviderBuilder"/>
/// configuration callback.</param>
/// <returns>The supplied <see cref="IOpenTelemetryBuilder"/> for chaining
/// calls.</returns>
internal
#endif
static IOpenTelemetryBuilder WithLogging(
this IOpenTelemetryBuilder builder,
Action<LoggerProviderBuilder> configure)
public static IOpenTelemetryBuilder WithLogging(
this IOpenTelemetryBuilder builder,
Action<LoggerProviderBuilder> configure)
{
Guard.ThrowIfNull(configure);
return WithLogging(builder, configureBuilder: configure, configureOptions: null);
}
#if EXPOSE_EXPERIMENTAL_FEATURES
/// <summary>
/// Adds logging services into the builder.
/// </summary>
@ -220,31 +172,16 @@ public static class OpenTelemetryBuilderSdkExtensions
/// <param name="configureBuilder">Optional <see
/// cref="LoggerProviderBuilder"/> configuration callback.</param>
/// <param name="configureOptions">Optional <see
/// cref="OpenTelemetryLoggerOptions"/> configuration callback.</param>
/// cref="OpenTelemetryLoggerOptions"/> configuration callback. <see
/// cref="OpenTelemetryLoggerOptions"/> are used by the <see
/// cref="ILoggerProvider"/> named 'OpenTelemetry' automatically registered
/// by this method.</param>
/// <returns>The supplied <see cref="IOpenTelemetryBuilder"/> for chaining
/// calls.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else
/// <summary>
/// Adds logging services into the builder.
/// </summary>
/// <remarks><inheritdoc cref="WithLogging(IOpenTelemetryBuilder)" path="/remarks"/></remarks>
/// <param name="builder"><see cref="IOpenTelemetryBuilder"/>.</param>
/// <param name="configureBuilder">Optional <see
/// cref="LoggerProviderBuilder"/> configuration callback.</param>
/// <param name="configureOptions">Optional <see
/// cref="OpenTelemetryLoggerOptions"/> configuration callback.</param>
/// <returns>The supplied <see cref="IOpenTelemetryBuilder"/> for chaining
/// calls.</returns>
internal
#endif
static IOpenTelemetryBuilder WithLogging(
this IOpenTelemetryBuilder builder,
Action<LoggerProviderBuilder>? configureBuilder,
Action<OpenTelemetryLoggerOptions>? configureOptions)
public static IOpenTelemetryBuilder WithLogging(
this IOpenTelemetryBuilder builder,
Action<LoggerProviderBuilder>? configureBuilder,
Action<OpenTelemetryLoggerOptions>? configureOptions)
{
builder.Services.AddLogging(
logging => logging.UseOpenTelemetry(configureBuilder, configureOptions));

2
src/OpenTelemetry/Sdk.cs
View File

@ -90,7 +90,7 @@ public static class Sdk
/// <returns><see cref="LoggerProviderBuilder"/> instance, which is used
/// to build a <see cref="LoggerProvider"/>.</returns>
#if NET8_0_OR_GREATER
[Experimental(DiagnosticDefinitions.LoggerProviderExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
[Experimental(DiagnosticDefinitions.LogsBridgeExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
#endif
public
#else

4
test/Benchmarks/Helper/LogRecordHelper.cs
View File

@ -12,9 +12,9 @@ internal class LogRecordHelper
{
var items = new List<LogRecord>(1);
using var factory = LoggerFactory.Create(builder => builder
.AddOpenTelemetry(loggerOptions =>
.UseOpenTelemetry(logging =>
{
loggerOptions.AddInMemoryExporter(items);
logging.AddInMemoryExporter(items);
}));
var logger = factory.CreateLogger("TestLogger");

6
test/Benchmarks/Logs/LogBenchmarks.cs
View File

@ -50,14 +50,14 @@ public class LogBenchmarks
this.loggerFactoryWithOneProcessor = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options => options
builder.UseOpenTelemetry(logging => logging
.AddProcessor(new DummyLogProcessor()));
});
this.loggerWithOneProcessor = this.loggerFactoryWithOneProcessor.CreateLogger<LogBenchmarks>();
this.loggerFactoryWithTwoProcessor = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options => options
builder.UseOpenTelemetry(logging => logging
.AddProcessor(new DummyLogProcessor())
.AddProcessor(new DummyLogProcessor()));
});
@ -65,7 +65,7 @@ public class LogBenchmarks
this.loggerFactoryWithThreeProcessor = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options => options
builder.UseOpenTelemetry(logging => logging
.AddProcessor(new DummyLogProcessor())
.AddProcessor(new DummyLogProcessor())
.AddProcessor(new DummyLogProcessor()));

4
test/OpenTelemetry.Api.Tests/Logs/LoggerProviderTests.cs
View File

@ -62,7 +62,11 @@ public sealed class LoggerProviderTests
private sealed class TestLoggerProvider : LoggerProvider
{
#if OPENTELEMETRY_API_EXPERIMENTAL_FEATURES_EXPOSED
protected override bool TryCreateLogger(
#else
internal override bool TryCreateLogger(
#endif
string? name,
#if NETSTANDARD2_1_OR_GREATER || NET6_0_OR_GREATER
[NotNullWhen(true)]

3
test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/IntegrationTest/IntegrationTests.cs
View File

@ -4,7 +4,6 @@
using System.Diagnostics;
using System.Diagnostics.Metrics;
using System.Diagnostics.Tracing;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation;
using OpenTelemetry.Logs;
@ -235,7 +234,7 @@ public sealed class IntegrationTests : IDisposable
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder
.AddOpenTelemetry(options => options
.UseOpenTelemetry(logging => logging
.AddProcessor(sp =>
OtlpLogExporterHelperExtensions.BuildOtlpLogExporter(
sp,

412
test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/OtlpLogExporterTests.cs
View File

@ -3,7 +3,6 @@
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Reflection;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
@ -111,46 +110,32 @@ public class OtlpLogExporterTests
[Fact]
public void AddOtlpExporterSetsDefaultBatchExportProcessor()
{
var loggerProvider = Sdk.CreateLoggerProviderBuilder()
using var loggerProvider = Sdk.CreateLoggerProviderBuilder()
.AddOtlpExporter()
.Build();
CheckProcessorDefaults();
var loggerProviderSdk = loggerProvider as LoggerProviderSdk;
Assert.NotNull(loggerProviderSdk);
loggerProvider.Dispose();
var batchProcessor = loggerProviderSdk.Processor as BatchLogRecordExportProcessor;
Assert.NotNull(batchProcessor);
void CheckProcessorDefaults()
{
var bindingFlags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic;
var processor = typeof(BaseProcessor<LogRecord>)
.Assembly
.GetType("OpenTelemetry.Logs.LoggerProviderSdk")
.GetProperty("Processor", bindingFlags)
.GetValue(loggerProvider) as BatchExportProcessor<LogRecord>;
Assert.NotNull(processor);
var scheduledDelayMilliseconds = typeof(BatchExportProcessor<LogRecord>)
.GetField("scheduledDelayMilliseconds", bindingFlags)
.GetValue(processor);
Assert.Equal(5000, scheduledDelayMilliseconds);
}
Assert.Equal(BatchLogRecordExportProcessor.DefaultScheduledDelayMilliseconds, batchProcessor.ScheduledDelayMilliseconds);
Assert.Equal(BatchLogRecordExportProcessor.DefaultExporterTimeoutMilliseconds, batchProcessor.ExporterTimeoutMilliseconds);
Assert.Equal(BatchLogRecordExportProcessor.DefaultMaxExportBatchSize, batchProcessor.MaxExportBatchSize);
}
[Fact]
public void AddOtlpLogExporterReceivesAttributesWithParseStateValueSetToFalse()
[Theory]
[InlineData(false)]
[InlineData(true)]
public void AddOtlpLogExporterReceivesAttributesWithParseStateValueSetToFalse(bool callUseOpenTelemetry)
{
bool optionsValidated = false;
var logRecords = new List<LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder
.AddOpenTelemetry(options => options
.AddInMemoryExporter(logRecords)
.AddOtlpExporter());
ConfigureOtlpExporter(builder, callUseOpenTelemetry, logRecords: logRecords);
builder.Services.Configure<OpenTelemetryLoggerOptions>(o =>
{
@ -172,21 +157,20 @@ public class OtlpLogExporterTests
}
[Theory]
[InlineData(true)]
[InlineData(false)]
public void AddOtlpLogExporterParseStateValueCanBeTurnedOff(bool parseState)
[InlineData(true, false)]
[InlineData(false, false)]
[InlineData(true, true)]
[InlineData(false, true)]
public void AddOtlpLogExporterParseStateValueCanBeTurnedOff(bool parseState, bool callUseOpenTelemetry)
{
var logRecords = new List<LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder
.AddOpenTelemetry(options =>
{
options.ParseStateValues = parseState;
options
.AddInMemoryExporter(logRecords)
.AddOtlpExporter();
});
ConfigureOtlpExporter(
builder,
callUseOpenTelemetry,
configureOptions: o => o.ParseStateValues = parseState,
logRecords: logRecords);
});
var logger = loggerFactory.CreateLogger("OtlpLogExporterTests");
@ -215,17 +199,19 @@ public class OtlpLogExporterTests
}
[Theory]
[InlineData(true)]
[InlineData(false)]
public void AddOtlpLogExporterParseStateValueCanBeTurnedOffHosting(bool parseState)
[InlineData(true, false)]
[InlineData(false, false)]
[InlineData(true, true)]
[InlineData(false, true)]
public void AddOtlpLogExporterParseStateValueCanBeTurnedOffHosting(bool parseState, bool callUseOpenTelemetry)
{
var logRecords = new List<LogRecord>();
var hostBuilder = new HostBuilder();
hostBuilder.ConfigureLogging(logging => logging
.AddOpenTelemetry(options => options
.AddInMemoryExporter(logRecords)
.AddOtlpExporter()));
hostBuilder.ConfigureLogging(logging =>
{
ConfigureOtlpExporter(logging, callUseOpenTelemetry, logRecords: logRecords);
});
hostBuilder.ConfigureServices(services =>
services.Configure<OpenTelemetryLoggerOptions>(options => options.ParseStateValues = parseState));
@ -263,12 +249,13 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.IncludeFormattedMessage = true;
options.ParseStateValues = true;
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options =>
{
options.IncludeFormattedMessage = true;
options.ParseStateValues = true;
});
});
var logger = loggerFactory.CreateLogger("OtlpLogExporterTests");
@ -308,12 +295,13 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.IncludeFormattedMessage = true;
options.ParseStateValues = true;
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options =>
{
options.IncludeFormattedMessage = true;
options.ParseStateValues = true;
});
});
var logger = loggerFactory.CreateLogger("OtlpLogExporterTests");
@ -377,10 +365,7 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(logging => logging.AddInMemoryExporter(logRecords));
});
var logger = loggerFactory.CreateLogger("OtlpLogExporterTests");
@ -400,10 +385,7 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(logging => logging.AddInMemoryExporter(logRecords));
});
var logger = loggerFactory.CreateLogger("OtlpLogExporterTests");
@ -426,10 +408,7 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(logging => logging.AddInMemoryExporter(logRecords));
});
var logger = loggerFactory.CreateLogger("OtlpLogExporterTests");
@ -466,12 +445,11 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.AddInMemoryExporter(logRecords);
options.IncludeFormattedMessage = true;
})
.AddFilter("CheckToOtlpLogRecordSeverityLevelAndText", LogLevel.Trace);
builder
.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options => options.IncludeFormattedMessage = true)
.AddFilter("CheckToOtlpLogRecordSeverityLevelAndText", LogLevel.Trace);
});
var logger = loggerFactory.CreateLogger("CheckToOtlpLogRecordSeverityLevelAndText");
@ -519,12 +497,13 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.AddInMemoryExporter(logRecords);
options.IncludeFormattedMessage = includeFormattedMessage;
options.ParseStateValues = true;
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options =>
{
options.IncludeFormattedMessage = includeFormattedMessage;
options.ParseStateValues = true;
});
});
var logger = loggerFactory.CreateLogger("OtlpLogExporterTests");
@ -642,10 +621,7 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(logging => logging.AddInMemoryExporter(logRecords));
});
var logger = loggerFactory.CreateLogger("OtlpLogExporterTests");
@ -683,11 +659,9 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.ParseStateValues = true;
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options => options.ParseStateValues = true);
});
var logger = loggerFactory.CreateLogger(string.Empty);
@ -789,11 +763,9 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>(1);
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.IncludeScopes = false;
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options => options.IncludeScopes = false);
});
var logger = loggerFactory.CreateLogger("Some category");
@ -826,11 +798,9 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>(1);
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.IncludeScopes = true;
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options => options.IncludeScopes = true);
});
var logger = loggerFactory.CreateLogger(nameof(OtlpLogExporterTests));
@ -866,11 +836,9 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>(1);
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.IncludeScopes = true;
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options => options.IncludeScopes = true);
});
var logger = loggerFactory.CreateLogger(nameof(OtlpLogExporterTests));
@ -918,11 +886,9 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>(1);
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.IncludeScopes = true;
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options => options.IncludeScopes = true);
});
var logger = loggerFactory.CreateLogger(nameof(OtlpLogExporterTests));
@ -958,11 +924,9 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>(1);
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.IncludeScopes = true;
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options => options.IncludeScopes = true);
});
var logger = loggerFactory.CreateLogger(nameof(OtlpLogExporterTests));
@ -998,11 +962,9 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>(1);
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.IncludeScopes = true;
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options => options.IncludeScopes = true);
});
var logger = loggerFactory.CreateLogger(nameof(OtlpLogExporterTests));
@ -1035,11 +997,9 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>(1);
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.IncludeScopes = true;
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options => options.IncludeScopes = true);
});
var logger = loggerFactory.CreateLogger(nameof(OtlpLogExporterTests));
@ -1071,11 +1031,9 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>(1);
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.IncludeScopes = true;
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options => options.IncludeScopes = true);
});
var logger = loggerFactory.CreateLogger(nameof(OtlpLogExporterTests));
@ -1102,11 +1060,9 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>(1);
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.IncludeScopes = true;
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options => options.IncludeScopes = true);
});
var logger = loggerFactory.CreateLogger(nameof(OtlpLogExporterTests));
@ -1141,11 +1097,9 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>(1);
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.IncludeScopes = true;
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options => options.IncludeScopes = true);
});
var logger = loggerFactory.CreateLogger(nameof(OtlpLogExporterTests));
@ -1180,11 +1134,9 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>(1);
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.IncludeScopes = true;
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options => options.IncludeScopes = true);
});
var logger = loggerFactory.CreateLogger(nameof(OtlpLogExporterTests));
@ -1223,11 +1175,9 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>(1);
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.IncludeScopes = true;
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options => options.IncludeScopes = true);
});
var logger = loggerFactory.CreateLogger(nameof(OtlpLogExporterTests));
@ -1265,11 +1215,9 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>(1);
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.IncludeScopes = true;
options.AddInMemoryExporter(logRecords);
});
builder.UseOpenTelemetry(
logging => logging.AddInMemoryExporter(logRecords),
options => options.IncludeScopes = true);
});
var logger = loggerFactory.CreateLogger(nameof(OtlpLogExporterTests));
@ -1303,56 +1251,66 @@ public class OtlpLogExporterTests
Assert.Contains(scopeValue2, allScopeValues);
}
[Fact]
public void AddOtlpLogExporterDefaultOptionsTest()
[Theory]
[InlineData(true)]
[InlineData(false)]
public void AddOtlpLogExporterDefaultOptionsTest(bool callUseOpenTelemetry)
{
var options = new OpenTelemetryLoggerOptions();
var services = new ServiceCollection();
services.AddLogging(builder =>
{
ConfigureOtlpExporter(builder, callUseOpenTelemetry);
});
options.AddOtlpExporter();
using var sp = services.BuildServiceProvider();
var provider = new OpenTelemetryLoggerProvider(new TestOptionsMonitor<OpenTelemetryLoggerOptions>(options));
sp.GetRequiredService<ILoggerFactory>();
var processor = GetProcessor(provider);
Assert.NotNull(processor);
var batchProcesor = processor as BatchLogRecordExportProcessor;
var provider = sp.GetRequiredService<LoggerProvider>() as LoggerProviderSdk;
Assert.NotNull(provider);
var batchProcesor = provider.Processor as BatchLogRecordExportProcessor;
Assert.NotNull(batchProcesor);
var batchProcessorType = typeof(BatchExportProcessor<LogRecord>);
Assert.Equal(5000, batchProcessorType.GetField("scheduledDelayMilliseconds", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(batchProcesor));
Assert.Equal(BatchLogRecordExportProcessor.DefaultScheduledDelayMilliseconds, batchProcesor.ScheduledDelayMilliseconds);
}
[Theory]
[InlineData(ExportProcessorType.Simple)]
[InlineData(ExportProcessorType.Batch)]
public void AddOtlpLogExporterLogRecordProcessorOptionsTest(ExportProcessorType processorType)
[InlineData(ExportProcessorType.Simple, false)]
[InlineData(ExportProcessorType.Batch, false)]
[InlineData(ExportProcessorType.Simple, true)]
[InlineData(ExportProcessorType.Batch, true)]
public void AddOtlpLogExporterLogRecordProcessorOptionsTest(ExportProcessorType processorType, bool callUseOpenTelemetry)
{
var options = new OpenTelemetryLoggerOptions();
options.AddOtlpExporter((o, l) =>
var services = new ServiceCollection();
services.AddLogging(builder =>
{
l.ExportProcessorType = processorType;
l.BatchExportProcessorOptions = new BatchExportLogRecordProcessorOptions() { ScheduledDelayMilliseconds = 1000 };
ConfigureOtlpExporter(
builder,
callUseOpenTelemetry,
configureExporterAndProcessor: (e, p) =>
{
p.ExportProcessorType = processorType;
p.BatchExportProcessorOptions = new BatchExportLogRecordProcessorOptions() { ScheduledDelayMilliseconds = 1000 };
});
});
var provider = new OpenTelemetryLoggerProvider(new TestOptionsMonitor<OpenTelemetryLoggerOptions>(options));
using var sp = services.BuildServiceProvider();
var processor = GetProcessor(provider);
sp.GetRequiredService<ILoggerFactory>();
var provider = sp.GetRequiredService<LoggerProvider>() as LoggerProviderSdk;
Assert.NotNull(provider);
var processor = provider.Processor;
Assert.NotNull(processor);
if (processorType == ExportProcessorType.Batch)
{
var batchProcesor = processor as BatchLogRecordExportProcessor;
Assert.NotNull(batchProcesor);
var batchProcessorType = typeof(BatchExportProcessor<LogRecord>);
Assert.Equal(1000, batchProcessorType.GetField("scheduledDelayMilliseconds", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(batchProcesor));
Assert.Equal(1000, batchProcesor.ScheduledDelayMilliseconds);
}
else
{
@ -1368,9 +1326,7 @@ public class OtlpLogExporterTests
var logRecords = new List<LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder
.AddOpenTelemetry(options => options
.AddInMemoryExporter(logRecords));
builder.UseOpenTelemetry(logging => logging.AddInMemoryExporter(logRecords));
});
var logger1 = loggerFactory.CreateLogger("OtlpLogExporterTests-A");
@ -1421,9 +1377,11 @@ public class OtlpLogExporterTests
}
[Theory]
[InlineData(null)]
[InlineData("logging")]
public void VerifyEnvironmentVariablesTakenFromIConfigurationWhenUsingLoggerFactoryCreate(string optionsName)
[InlineData(null, false)]
[InlineData("logging", false)]
[InlineData(null, true)]
[InlineData("logging", true)]
public void VerifyEnvironmentVariablesTakenFromIConfigurationWhenUsingLoggerFactoryCreate(string optionsName, bool callUseOpenTelemetry)
{
RunVerifyEnvironmentVariablesTakenFromIConfigurationTest(
optionsName,
@ -1433,7 +1391,10 @@ public class OtlpLogExporterTests
{
configure(logging.Services);
logging.AddOpenTelemetry(o => o.AddOtlpExporter(optionsName, configure: null));
ConfigureOtlpExporter(
logging,
callUseOpenTelemetry,
name: optionsName);
});
return (factory, factory);
@ -1441,9 +1402,11 @@ public class OtlpLogExporterTests
}
[Theory]
[InlineData(null)]
[InlineData("logging")]
public void VerifyEnvironmentVariablesTakenFromIConfigurationWhenUsingLoggingBuilder(string optionsName)
[InlineData(null, false)]
[InlineData("logging", false)]
[InlineData(null, true)]
[InlineData("logging", true)]
public void VerifyEnvironmentVariablesTakenFromIConfigurationWhenUsingLoggingBuilder(string optionsName, bool callUseOpenTelemetry)
{
RunVerifyEnvironmentVariablesTakenFromIConfigurationTest(
optionsName,
@ -1454,8 +1417,10 @@ public class OtlpLogExporterTests
configure(services);
services.AddLogging(
logging => logging.AddOpenTelemetry(o =>
o.AddOtlpExporter(optionsName, configure: null)));
logging => ConfigureOtlpExporter(
logging,
callUseOpenTelemetry,
name: optionsName));
var sp = services.BuildServiceProvider();
@ -1582,11 +1547,62 @@ public class OtlpLogExporterTests
return record.Attributes.FirstOrDefault(att => att.Key == key);
}
private static BaseProcessor<LogRecord> GetProcessor(OpenTelemetryLoggerProvider provider)
private static void ConfigureOtlpExporter(
ILoggingBuilder builder,
bool callUseOpenTelemetry,
string name = null,
Action<OtlpExporterOptions> configureExporter = null,
Action<OtlpExporterOptions, LogRecordExportProcessorOptions> configureExporterAndProcessor = null,
Action<OpenTelemetryLoggerOptions> configureOptions = null,
List<LogRecord> logRecords = null)
{
var sdkProvider = typeof(OpenTelemetryLoggerProvider).GetField("Provider", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(provider);
if (callUseOpenTelemetry)
{
builder.UseOpenTelemetry(
logging =>
{
if (configureExporterAndProcessor != null)
{
logging.AddOtlpExporter(name, configureExporterAndProcessor);
}
else
{
logging.AddOtlpExporter(name, configureExporter);
}
return (BaseProcessor<LogRecord>)sdkProvider.GetType().GetProperty("Processor", BindingFlags.Instance | BindingFlags.Public).GetMethod.Invoke(sdkProvider, null);
if (logRecords != null)
{
logging.AddInMemoryExporter(logRecords);
}
},
options =>
{
configureOptions?.Invoke(options);
});
}
else
{
#pragma warning disable CS0618 // Type or member is obsolete
builder.AddOpenTelemetry(options =>
{
configureOptions?.Invoke(options);
if (configureExporterAndProcessor != null)
{
options.AddOtlpExporter(name, configureExporterAndProcessor);
}
else
{
options.AddOtlpExporter(name, configureExporter);
}
if (logRecords != null)
{
options.AddInMemoryExporter(logRecords);
}
});
#pragma warning restore CS0618 // Type or member is obsolete
}
}
private sealed class TestOptionsMonitor<T> : IOptionsMonitor<T>

4
test/OpenTelemetry.Tests.Stress.Logs/Program.cs
View File

@ -23,9 +23,9 @@ public static class Program
{
this.loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
builder.AddOpenTelemetry(logging =>
{
options.AddProcessor(new DummyProcessor());
logging.AddProcessor(new DummyProcessor());
});
});