diff --git a/README.md b/README.md index fb59e95..c985e8b 100644 --- a/README.md +++ b/README.md @@ -1,84 +1,97 @@ [![Pull Request Validation](https://github.com/elastic/elastic-otel-dotnet/actions/workflows/ci.yml/badge.svg)](https://github.com/elastic/elastic-otel-dotnet/actions/workflows/ci.yml) -# Elastic Distribution for OpenTelemetry .NET +# Elastic Distribution of OpenTelemetry .NET -The Elastic Distribution for OpenTelemetry .NET provides a zero code change extension -to [OpenTelemetry SDK for .NET](https://opentelemetry.io/docs/languages/net). These extensions ensure -a smooth and rich out of the box experience with [Elastic Observability](https://www.elastic.co/observability) -through strictly OpenTelemetry native means. +> [!WARNING] +> The Elastic Distribution of OpenTelemetry .NET is not yet recommended for production use. Functionality may be changed or removed in future releases. Alpha releases are not subject to the support SLA of official GA features. +> +> We welcome your feedback! You can reach us by [opening a GitHub issue](https://github.com/elastic/elastic-otel-dotnet/issues) or starting a discussion thread on the [Elastic Discuss forum](https://discuss.elastic.co/tags/c/observability/apm/58/dotnet). -This ensures there are no new concepts to learn with the full OpenTelemetry ecosystem remains at ones -fingertips. Read more about the concept of [OpenTelemetry Distributions](https://opentelemetry.io/docs/concepts/distributions). +The Elastic Distribution of OpenTelemetry .NET (EDOT .NET) provides a zero code change extension of the [OpenTelemetry SDK for .NET](https://opentelemetry.io/docs/languages/net). EDOT .NET makes it easier to get started using OpenTelemetry in your .NET applications through strictly OpenTelemetry native means, while also providing a smooth and rich out of the box experience with [Elastic Observability](https://www.elastic.co/observability). It's an explicit goal of this distribution to introduce **no new concepts** in addition to those defined by the wider OpenTelemetry community. -The Elastic Distribution for OpenTelemetry .NET includes some Elastic-specific processors to ensure the best -compatibility when exporting OpenTelemetry signal data [Elastic Observability](https://www.elastic.co/observability). -The distribution also preconfigures the collection of tracing, metrics and logs signals, applying -some opinionated defaults, such as which sources are collected by default. The distribution also -ensures that the OTLP exporter is enabled by default. +> [!NOTE] +> For more details about OpenTelemetry distributions in general, visit the [OpenTelemetry documentation](https://opentelemetry.io/docs/concepts/distributions). -> **_IMPORTANT:_** The Elastic Distribution for OpenTelemetry .NET is currently in early alpha release status. -> It is not yet feature complete and may contain bugs. We are actively working on improving the distribution and -adding new features. -> -> If you would like to experience the alpha and help us improve the distribution by providing -early feedback, you can follow the steps below to get started. +With EDOT .NET you have access to all the features of the OpenTelemetry SDK for .NET plus: + +* Access to SDK improvements and bug fixes contributed by the Elastic team _before_ the changes are available upstream in OpenTelemetry repositories. +* Elastic-specific processors that ensure optimal compatibility when exporting OpenTelemetry signal data to an Elastic backend like an Elastic Observability deployment. +* Preconfigured collection of tracing and metrics signals, applying some opinionated defaults, such as which sources are collected by default. +* Ensuring that the OpenTelemetry protocol (OTLP) exporter is enabled by default. + +**Ready to try out the distro?** Follow the step-by-step instructions in [Get started](./docs/get-started.md). + +## Install -## Getting started +To get started with the Elastic Distribution of OpenTelemetry .NET, you must add the +[`Elastic.OpenTelemetry`](https://www.nuget.org/packages/Elastic.OpenTelemetry) +NuGet package to your project. This can be achieved by adding the package reference to your project file. -As the distribution is a lightweight extension of the OpenTelemetry SDK, you should be broadly +```xml + +``` + +> [!NOTE] +> Replace the `` placeholder with the latest available package from [NuGet.org](https://www.nuget.org/packages/Elastic.OpenTelemetry). + +## Read the docs + +* [Get started](./get-started.md) +* [Configuration](./configure.md) + + diff --git a/docs/configure.md b/docs/configure.md new file mode 100644 index 0000000..054e8a7 --- /dev/null +++ b/docs/configure.md @@ -0,0 +1,262 @@ + + +# Configure + +Configure the Elastic Distribution of OpenTelemetry .NET (EDOT .NET) to send data to Elastic. + + +## Configuration methods + +Configure the OpenTelemetry SDK using the mechanisms listed in the [OpenTelemetry documentation](https://opentelemetry.io/docs/languages/net/automatic/configuration/), +including: + +* Setting [environment variables](#environment-variables) +* Using the [`IConfiguration` integration](#iconfiguration-integration) +* [Manually configuring](#manual-configuration) EDOT .NET + + +Configuration options set manually in the code take precedence over environment variables, and +environment variables take precedence over configuration options set using the `IConfiguration` system. + +### Environment variables + + +EDOT .NET can be configured using environment variables. +This is a cross-platform way to configure EDOT .NET and is especially useful in containerized environments. + + +Environment variables are read at startup and can be used to configure EDOT .NET. +For details of the various options available and their corresponding environment variable names, +see [Configuration options](#configuration-options) + +### `IConfiguration` integration + + +In applications that use the "host" pattern, such as ASP.NET Core and worker service, EDOT .NET +can be configured using the `IConfiguration` integration. + + +This is done by passing an `IConfiguration` instance to the `AddElasticOpenTelemetry` extension +method on the `IServiceCollection`. + +When using an `IHostApplicationBuilder` such as modern ASP.NET Core applications, the current `IConfiguration` +can be accessed via the `Configuration` property on the builder: + +```csharp +var builder = WebApplication.CreateBuilder(args); +// Access the current `IConfiguration` instance from the builder. +var currentConfig = builder.Configuration; +``` + +By default, at this stage, the configuration will be populated from the default configuration sources, +including the `appsettings.json` file(s) and command-line arguments. You may use these sources to define +the configuration for the Elastic Distribution of OpenTelemetry .NET. + + +For example, you can define the configuration for the Elastic Distribution of OpenTelemetry .NET in the `appsettings.json` file: + +```json +{ + "Elastic": { + "OpenTelemetry": { + "FileLogDirectory": "C:\\Logs" + } + } +} +``` + +> [!NOTE] +> This example sets the file log directory to `C:\Logs` which enables diagnostic file logging. + +Configuration from the "Elastic:OpenTelemetry" section of the `IConfiguration` instance will be +bound to the `ElasticOpenTelemetryOptions` instance used to configure EDOT .NET. + +To learn more about the Microsoft configuration system, see +[Configuration in ASP.NET Core](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/configuration). + +### Manual configuration + + +In all other scenarios, you can configure EDOT .NET manually in code. + + +Create an instance of `ElasticOpenTelemetryBuilderOptions` and pass it to the `ElasticOpenTelemetryBuilder` +constructor or an overload of the `AddElasticOpenTelemetry` extension method on the `IServiceCollection`. + + +For example, in traditional console applications, you can configure the +Elastic Distribution of OpenTelemetry .NET like this: + +```csharp +using Elastic.OpenTelemetry; +using Elastic.OpenTelemetry.Configuration; +using Elastic.OpenTelemetry.Extensions; +using Microsoft.Extensions.DependencyInjection; +using OpenTelemetry; + +var services = new ServiceCollection(); + +// Create an instance of `ElasticOpenTelemetryBuilderOptions`. +var builderOptions = new ElasticOpenTelemetryBuilderOptions +{ + // Create an instance of `ElasticOpenTelemetryOptions` and configure + // the file log directory by setting the corresponding property. + DistroOptions = new ElasticOpenTelemetryOptions + { + // This example sets the file log directory to `C:\Logs` + // which enables diagnostic file logging. + FileLogDirectory = "C:\\Logs", + } +}; + +// Pass the `ElasticOpenTelemetryBuilderOptions` instance to the +// `ElasticOpenTelemetryBuilder` constructor to configure EDOT .NET. +await using var session = new ElasticOpenTelemetryBuilder(builderOptions) + .WithTracing(b => b.AddSource("MySource")) + .Build(); +``` + + +## Configuration options + +Because the Elastic Distribution of OpenTelemetry .NET (EDOT .NET) is an extension of the [OpenTelemetry .NET agent](https://github.com/open-telemetry/opentelemetry-dotnet-instrumentation), it supports both: + +* General OpenTelemetry SDK configuration options +* Elastic-specific configuration options that are only available when using EDOT .NET + +### OpenTelemetry SDK configuration options + +EDOT .NET supports all configuration options listed in the [OpenTelemetry General SDK Configuration documentation](https://opentelemetry.io/docs/languages/sdk-configuration/general/). + +### Elastic-specific configuration options + +EDOT .NET supports the following Elastic-specific options. + +#### `FileLogDirectory` + +* _Type_: String +* _Default_: `string.Empty` + +A string specifying the directory where the Elastic Distribution of OpenTelemetry .NET will write diagnostic log files. +When not provided, no file logging will occur. Each new .NET process will create a new log file in the +specified directory. + +| Configuration method | Key | +|---|---| +| Environment variable | `ELASTIC_OTEL_FILE_LOG_DIRECTORY` | +| `IConfiguration` integration | `Elastic:OpenTelemetry:FileLogDirectory` | + +#### `FileLogLevel` + +* _Type_: String +* _Default_: `Information` + +Sets the logging level for EDOT .NET. + +Valid options: `Critical`, `Error`, `Warning`, `Information`, `Debug`, `Trace` and `None` (`None` disables the logging). + +| Configuration method | Key | +|---|---| +| Environment variable | `ELASTIC_OTEL_FILE_LOG_LEVEL` | +| `IConfiguration` integration | `Elastic:OpenTelemetry:FileLogLevel` | + +#### `SkipOtlpExporter` + +* _Type_: Bool +* _Default_: `false` + +Allows EDOT .NET to used with its defaults, but without enabling the export of telemetry data to +an OTLP endpoint. This can be useful when you want to test applications without sending telemetry data. + +| Configuration method | Key | +|---|---| +| Environment variable | `ELASTIC_OTEL_SKIP_OTLP_EXPORTER` | +| `IConfiguration` integration | `Elastic:OpenTelemetry:SkipOtlpExporter` | + +#### `ElasticDefaults` + +* _Type_: String +* _Default_: `string.Empty` + +A comma-separated list of Elastic defaults to enable. This can be useful when you want to enable +only some of the Elastic Distribution of OpenTelemetry .NET opinionated defaults. + +Valid options: `None`, `Traces`, `Metrics`, `Logs`, `All`. + +Except for the `None` option, all other options can be combined. + +When this setting is not configured or the value is `string.Empty`, all Elastic Distribution of OpenTelemetry .NET defaults will be enabled. + +When `None` is specified, no Elastic Distribution of OpenTelemetry .NET defaults will be enabled, and you will need to manually +configure the OpenTelemetry SDK to enable collection of telemetry signals. In this mode, EDOT .NET +does not provide any opinionated defaults, nor register any processors, allowing you to start with the "vanilla" +OpenTelemetry SDK configuration. You may then choose to configure the various providers and register processors +as required. + +In all other cases, the Elastic Distribution of OpenTelemetry .NET will enable the specified defaults. For example, to enable only +Elastic defaults only for tracing and metrics, set this value to `Traces,Metrics`. + +| Configuration method | Key | +|---|---| +| Environment variable | `ELASTIC_OTEL_DEFAULTS_ENABLED` | +| `IConfiguration` integration | `Elastic:OpenTelemetry:ElasticDefaults` | + + +## Authentication methods + +When sending data to Elastic, there are two ways you can authenticate: using an APM agent key or using a secret token. + +### Use an APM agent key (API key) + + +[APM agent keys](https://www.elastic.co/guide/en/observability/current/apm-api-key.html) are +used to authorize requests to an Elastic Observability endpoint. +APM agent keys are revocable, you can have more than one of them, and +you can add or remove them without restarting APM Server. + + +To create and manage APM agent keys in Kibana: + +1. Go to **APM Settings**. +1. Select the **Agent Keys** tab. + +When using an APM agent key, the `OTEL_EXPORTER_OTLP_HEADERS` is set using a +different auth schema (`ApiKey` rather than `Bearer`). For example: + + +```sh +export OTEL_EXPORTER_OTLP_ENDPOINT=https://my-deployment.apm.us-west1.gcp.cloud.es.io +export OTEL_EXPORTER_OTLP_HEADERS="Authorization=ApiKey TkpXUkx...dVZGQQ==" +``` + +### Use a secret token + + + +[Secret tokens](https://www.elastic.co/guide/en/observability/current/apm-secret-token.html) are used to authorize requests to the APM Server. Both EDOT .NET and APM Server must be configured with the same secret token for the request to be accepted. + + +You can find the values of these variables in Kibana's APM tutorial. +In Kibana: + +1. Go to **Setup guides**. +1. Select **Observability**. +1. Select **Monitor my application performance**. +1. Scroll down and select the **OpenTelemetry** option. +1. The appropriate values for `OTEL_EXPORTER_OTLP_ENDPOINT` and `OTEL_EXPORTER_OTLP_HEADERS` are shown there. + + ![Elastic Cloud OpenTelemetry configuration](images/elastic-cloud-opentelemetry-configuration.png) + + For example: + + ```sh + export OTEL_EXPORTER_OTLP_ENDPOINT=https://my-deployment.apm.us-west1.gcp.cloud.es.io + export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer P....l" + ``` \ No newline at end of file diff --git a/docs/configure.mdx b/docs/configure.mdx deleted file mode 100644 index ab6befe..0000000 --- a/docs/configure.mdx +++ /dev/null @@ -1,170 +0,0 @@ ---- -slug: /otel-dotnet/configure -title: Configure ---- - -Configuration of the OpenTelemetry SDK should be performed through the -mechanisms [documented on the OpenTelemetry website](https://opentelemetry.io/docs/languages/net/automatic/configuration/). - -The Elastic Distribution for OpenTelemetry .NET can be further configured using advanced settings when -you need complete control of its behaviour. Configuration can be achieved by setting environment variables, -using the `IConfiguration` integration, or manually configuring the Elastic distribution. - -## Environment variables - -The Elastic Distribution for OpenTelemetry .NET can be configured using environment variables. This is a cross-platform -way to configure the Elastic Distribution for OpenTelemetry .NET and is especially useful in containerized environments. - -Environment variables are read at startup and can be used to configure the Elastic distribution. -For details of the various options available and their corresponding environment variable names, -see [configuration otpions](#configuration_options). - -Environment variables always take precedence over configuration provided by the `IConfiguration` -system. - -## IConfiguration integration - -In applications that use the "host" pattern, such as ASP.NET Core and worker service, the Elastic -distribution can be configured using the `IConfiguration` integration. This is done by passing an -`IConfiguration` instance to the `AddElasticOpenTelemetry` extension method on the `IServiceCollection`. - -When using an `IHostApplicationBuilder` such as modern ASP.NET Core applications, the current `IConfiguration` -can be accessed via the `Configuration` property on the builder. - -```csharp -var builder = WebApplication.CreateBuilder(args); -var currentConfig = builder.Configuration; [^1] -``` -[^1]: Access the current `IConfiguration` instance from the builder. - -By default, at this stage, the configuration will be populated from the default configuration sources, -including the `appsettings.json` file(s) and command-line arguments. You may use these sources to define -the configuration for the Elastic Distribution for OpenTelemetry .NET. - -For example, you can define the configuration for the Elastic Distribution for OpenTelemetry .NET in the `appsettings.json` file: - -```json -{ - "Elastic": { - "OpenTelemetry": { - "FileLogDirectory": "C:\\Logs" [^1] - } - } -} -``` -[^1]: This example sets the file log directory to `C:\Logs` which enables diagnostic file logging. - -Configuration from the "Elastic:OpenTelemetry" section of the `IConfiguration` instance will be -bound to the `ElasticOpenTelemetryOptions` instance used to configure the Elastic distribution. - -To learn more about the Microsoft configuration system, see -[Configuration in ASP.NET Core](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/configuration). - -## Manual configuration - -In all other scenarios, configuration can be achieved manually in code. This is done by creating -an instance of `ElasticOpenTelemetryBuilderOptions` and passing it to the `ElasticOpenTelemetryBuilder` constructor -or an overload of the `AddElasticOpenTelemetry` extension method on the `IServiceCollection`. - -For example, in traditional console applications, you can configure the Elastic Distribution for OpenTelemetry .NET like this: - -```csharp -using Elastic.OpenTelemetry; -using Elastic.OpenTelemetry.Configuration; -using Elastic.OpenTelemetry.Extensions; -using Microsoft.Extensions.DependencyInjection; -using OpenTelemetry; - -var services = new ServiceCollection(); - -var builderOptions = new ElasticOpenTelemetryBuilderOptions [^1] -{ - DistroOptions = new ElasticOpenTelemetryOptions [^2] - { - FileLogDirectory = "C:\\Logs", [^3] - } -}; - -await using var session = new ElasticOpenTelemetryBuilder(builderOptions) [^4] - .WithTracing(b => b.AddSource("MySource")) - .Build(); -``` -[^1]: Create an instance of `ElasticOpenTelemetryBuilderOptions` -[^2]: Create an instance of `ElasticOpenTelemetryOptions` and configure the file log directory by -setting the corresponding property. -[^3]: This example sets the file log directory to `C:\Logs` which enables diagnostic file logging. -[^4]: Pass the `ElasticOpenTelemetryBuilderOptions` instance to the `ElasticOpenTelemetryBuilder` constructor -to configure the Elastic Distribution for OpenTelemetry .NET. - -## Configuration options - -### `FileLogDirectory` - -A string specifying the directory where the Elastic Distribution for OpenTelemetry .NET will write diagnostic log files. -When not provided, no file logging will occur. Each new .NET process will create a new log file in the -specified directory. - -| Environment variable name | IConfiguration key | -| ------------- |-------------| -| `ELASTIC_OTEL_FILE_LOG_DIRECTORY` | `Elastic:OpenTelemetry:FileLogDirectory` | - -| Default | Type | -| ------------- |-------------| -| `string.Empty` | String | - -### `FileLogLevel` - -Sets the logging level for the distribtuion. - -Valid options: `Critical`, `Error`, `Warning`, `Information`, `Debug`, `Trace` and `None` (`None` disables the logging). - -| Environment variable name | IConfiguration key | -| ------------- |-------------| -| `ELASTIC_OTEL_FILE_LOG_LEVEL` | `Elastic:OpenTelemetry:FileLogLevel` | - -| Default | Type | -| ------------- |-------------| -| `Information` | String | - -### `SkipOtlpExporter` - -Allows the distribution to used with its defaults, but without enabling the export of telemetry data to -an OTLP endpoint. This can be useful when you want to test applications without sending telemetry data. - -| Environment variable name | IConfiguration key | -| ------------- |-------------| -| `ELASTIC_OTEL_SKIP_OTLP_EXPORTER` | `Elastic:OpenTelemetry:SkipOtlpExporter` | - -| Default | Type | -| ------------- |-------------| -| `false` | Bool | - -[float] -[[config-enabledelasticdefaults]] -### `ElasticDefaults` - -A comma-separated list of Elastic defaults to enable. This can be useful when you want to enable -only some of the Elastic Distribution for OpenTelemetry .NET opinionated defaults. - -Valid options: `None`, `Traces`, `Metrics`, `Logs`, `All`. - -Except for the `None` option, all other options can be combined. - -When this setting is not configured or the value is `string.Empty`, all Elastic Distribution for OpenTelemetry .NET defaults will be enabled. - -When `None` is specified, no Elastic Distribution for OpenTelemetry .NET defaults will be enabled, and you will need to manually -configure the OpenTelemetry SDK to enable collection of telemetry signals. In this mode, the Elastic distribution -does not provide any opinionated defaults, nor register any processors, allowing you to start with the "vanilla" -OpenTelemetry SDK configuration. You may then choose to configure the various providers and register processors -as required. - -In all other cases, the Elastic Distribution for OpenTelemetry .NET will enable the specified defaults. For example, to enable only -Elastic defaults only for tracing and metrics, set this value to `Traces,Metrics`. - -| Environment variable name | IConfiguration key | -| ------------- |-------------| -| `ELASTIC_OTEL_DEFAULTS_ENABLED` | `Elastic:OpenTelemetry:ElasticDefaults` | - -| Default | Type | -| ------------- |-------------| -| `string.Empty` | String | \ No newline at end of file diff --git a/docs/elastic-otel-dotnet.docnav.json b/docs/elastic-otel-dotnet.docnav.json deleted file mode 100644 index d6740bf..0000000 --- a/docs/elastic-otel-dotnet.docnav.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "mission": ".NET", - "id": "elastic-otel-dotnet", - "landingPageSlug": "/otel-dotnet/intro", - "icon": "logoObservability", - "description": "Elastic Distribution for OpenTelemetry .NET", - "items": [ - { - "label": "Get started", - "slug": "/otel-dotnet/get-started" - }, - { - "label": "Configure", - "slug": "/otel-dotnet/configure" - } - ] -} \ No newline at end of file diff --git a/docs/get-started.md b/docs/get-started.md new file mode 100644 index 0000000..3007f25 --- /dev/null +++ b/docs/get-started.md @@ -0,0 +1,237 @@ + + +# Get started + +> [!WARNING] +> The Elastic Distribution of OpenTelemetry .NET is not yet recommended for production use. Functionality may be changed or removed in future releases. Alpha releases are not subject to the support SLA of official GA features. +> +> We welcome your feedback! You can reach us by [opening a GitHub issue](https://github.com/elastic/elastic-otel-dotnet/issues) or starting a discussion thread on the [Elastic Discuss forum](https://discuss.elastic.co/tags/c/observability/apm/58/dotnet). + +This guide shows you how to use the Elastic Distribution of OpenTelemetry .NET (EDOT .NET) to instrument your .NET application and send OpenTelemetry data to an Elastic Observability deployment. + +**Already familiar with OpenTelemetry?** It's an explicit goal of this distribution to introduce _no new concepts_ outside those defined by the wider OpenTelemetry community. + +**New to OpenTelemetry?** This section will guide you through the _minimal_ configuration options to get EDOT Java set up in your application. You do _not_ need any existing experience with OpenTelemetry to set up EDOT Java initially. If you need more control over your configuration after getting set up, you can learn more in the [OpenTelemetry documentation](https://opentelemetry.io/docs/languages/net). + +> [!NOTE] +> As an OpenTelemetry SDK, EDOT .NET supports sending data to any OpenTelemetry protocol (OTLP) endpoint ([OpenTelemetry Collector](https://opentelemetry.io/docs/collector/)), but this guide assumes you are sending data to Elastic. + + +## Prerequisites + +Before getting started: + +* **Check your .NET SDK version**. The current documentation and examples are written with .NET 6 and newer applications in mind. Before continuing, ensure that you have a supported [.NET SDK version](https://dotnet.microsoft.com/en-us/download/dotnet) installed locally. +* **Set up Elastic Observability**. You'll need somewhere to send the gathered OpenTelemetry data, so it can be viewed and analyzed. This doc assumes you're using an [Elastic Observability](https://www.elastic.co/observability) cloud deployment. You can use an existing one or set up a new one. +
+ Expand for setup instructions + To create your first Elastic Observability deployment: + + 1. Sign up for a [free Elastic Cloud trial](https://cloud.elastic.co/registration) or sign into an existing account. + 1. Go to . + 1. Click **Create deployment**. + 1. When the deployment is ready, click *Open* to visit your Kibana home page (for example, `https://{DEPLOYMENT_NAME}.kb.{REGION}.cloud.es.io/app/home#/getting_started`). +
+ + +## Install + + +To get started with the Elastic OpenTelemetry Distribution for .NET, add the `Elastic.OpenTelemetry` NuGet package reference to your project file: + +```xml + +``` + +> [!NOTE] +> Replace the `` placeholder with the latest available package from [NuGet.org](https://www.nuget.org/packages/Elastic.OpenTelemetry). + +After adding the package reference, you can start using EDOT .NET in your application. + + +> [!NOTE] +> EDOT .NET includes a transitive dependency on the OpenTelemetry SDK, so you do not _need_ to add the OpenTelemetry SDK package to your project directly. However, you _can_ explicitly add the OpenTelemetry SDK as a dependency if you want to opt into newer SDK versions. If you do this, the OpenTelemetry SDK dependency must be defined _before_ the Elastic OpenTelemetry Distribution for .NET is defined. + +> [!NOTE] +> EDOT .NET is designed to be easy to use and integrate into your applications. This includes applications that have previously used the OpenTelemetry SDK directly. In situations where the OpenTelemetry SDK is already used, the only required change is to add the `Elastic.OpenTelemetry` NuGet package to the project. Doing so will automatically switch to the opinionated configuration provided by EDOT .NET. + + +## Instrument your application + +The OpenTelemetry SDK and EDOT .NET provide extension methods to enable observability features in your application with a few lines of code. Choose from: + +* [**ASP.NET Core application**](#aspnet-core-application) for ASP.NET Core minimal API applications, other ASP.NET Core workloads and other host-based applications like [worker services](https://learn.microsoft.com/en-us/dotnet/core/extensions/workers). +* [**`Microsoft.Extensions.Hosting`**](#microsoftextensionshosting) for console applications and services that are written against a builder that exposes an `IServiceCollection`. +* [**Manual instrumentation**](#manual-instrumentation) for environments where an `IServiceCollection` is unavailable. + +### ASP.NET Core application + +If you want to instrument an ASP.NET Core minimal API application using EDOT .NET, follow the +steps below. Similar steps can also be used to instrument other ASP.NET Core workloads and other +host-based applications like [worker services](https://learn.microsoft.com/en-us/dotnet/core/extensions/workers). + +> [!NOTE] +> The examples below assume your code uses the top-level statements feature introduced in C# 9.0 and the default choice for applications created using the latest templates. + + +1. To take advantage of the OpenTelemetry SDK instrumentation for ASP.NET Core, add the following NuGet package to your project: + ```xml + + ``` + + This package includes instrumentation to collect traces for requests handled by ASP.NET Core endpoints. + + > [!NOTE] + > The ASP.NET Core instrumentation is not included by default in EDOT .NET. As with all optional instrumentation libraries, you can choose to include them in your application by adding a suitable package reference. + +1. Inside the `Program.cs` file of the ASP.NET Core application, add the following two `using` directives: + + ```csharp +using OpenTelemetry; +using OpenTelemetry.Trace; + ``` + + The OpenTelemetry SDK provides extension methods on the `IServiceCollection` to enable the providers and configure the SDK. EDOT .NET overrides the default OpenTelemetry SDK registration, adding several opinionated defaults. + +1. In the minimal API template, the `WebApplicationBuilder` exposes a `Services` property that can be used to register services with the dependency injection container. To enable tracing and metrics collection, ensure that the OpenTelemetry SDK is registered: + + ```csharp +var builder = WebApplication.CreateBuilder(args); + +builder.Services + // The `AddHttpClient` method registers the `IHttpClientFactory` service with + // the dependency injection container. This is NOT required to enable OpenTelemetry, + // but the example endpoint will use it to send an HTTP request. + .AddHttpClient() + // The `AddOpenTelemetry` method registers the OpenTelemetry SDK with the + // dependency injection container. When available, EDOT .NET will override + // this to add opinionated defaults. + .AddOpenTelemetry() + // Configure tracing to instrument requests handled by ASP.NET Core. + .WithTracing(t => t.AddAspNetCoreInstrumentation()); + ``` + +With these limited changes to the `Program.cs` file, the application is now configured to use the +OpenTelemetry SDK and EDOT .NET to collect traces and metrics, which are exported via the +OpenTelemetry protocol (OTLP). + +To demonstrate the tracing capabilities, add a simple endpoint to the application: + +```csharp +app.MapGet("/", async (IHttpClientFactory httpClientFactory) => +{ + using var client = httpClientFactory.CreateClient(); + + await Task.Delay(100); + // Using this URL will require two redirects, allowing us to + // see multiple spans in the trace. + var response = await client.GetAsync("http://elastic.co"); <1> + await Task.Delay(50); + + return response.StatusCode == System.Net.HttpStatusCode.OK ? Results.Ok() : Results.StatusCode(500); +}); +``` + +EDOT .NET will automatically enable the exporting of signals via the OTLP exporter. This +exporter requires that endpoint(s) are configured. A common mechanism for configuring +endpoints is via environment variables. + +### `Microsoft.Extensions.Hosting` + + +For console applications, services, etc that are written against a builder that exposes an `IServiceCollection` you can install this package: + +```xml + +``` + +> [!NOTE] +> Replace the `` placeholder with the latest available package from [NuGet.org](https://www.nuget.org/packages/Elastic.OpenTelemetry). + +Ensure you call `AddOpenTelemetry` to enable OpenTelemetry just as you would when using OpenTelemetry directly. Our package intercepts this call to set up our defaults, but can be further build upon as per usual: + +```csharp +var builder = Host.CreateApplicationBuilder(args); + +builder.Services.AddOpenTelemetry() + .ConfigureResource(r => r.AddService(serviceName: "MyService")) + .WithTracing(t => t.AddSource(Worker.ActivitySourceName).AddConsoleExporter()) + .WithMetrics(m => m.AddMeter(Worker.MeterName).AddConsoleExporter()); +``` + +### Manual instrumentation + +In environments where an `IServiceCollection` is unavailable you may manually start instrumenting by creating an instance of `ElasticOpenTelemetryBuilder`. + +```csharp +await using var session = new ElasticOpenTelemetryBuilder() + .WithTracing(b => b.AddSource(ActivitySourceName)) + .Build(); +``` + +This will setup instrumentation for as long as `session` is not disposed. We would generally expect the `session` +to live for the life of the application. + +`ElasticOpenTelemetryBuilder` is an implementation of [`IOpenTelemetryBuilder`](https://github.com/open-telemetry/opentelemetry-dotnet/blob/70657395b82ba00b8a1e848e8832b77dff94b6d2/src/OpenTelemetry.Api.ProviderBuilderExtensions/IOpenTelemetryBuilder.cs#L12). + +This is important to know because any instrumentation configuration is automatically exposed by the base +OpenTelemetry package as extension methods on `IOpenTelemetryBuilder`. You will not lose functionality by +using our builder. + + +## Configure EDOT .NET + +To configure EDOT .NET, at a minimum you'll need the deployment's OTLP endpoint and +authorization data to set the appropriate `OTLP_*` environment variables: + +* `OTEL_EXPORTER_OTLP_ENDPOINT`: The full URL of the endpoint where data will be sent. +* `OTEL_EXPORTER_OTLP_HEADERS`: A comma-separated list of `key=value` pairs that will +be added to the headers of every request. This is typically this is used for +authentication information. + +You can find the values of these variables in Kibana's APM tutorial. In Kibana: + + +1. Go to **Setup guides**. +1. Select **Observability**. +1. Select **Monitor my application performance**. +1. Scroll down and select the **OpenTelemetry** option. +1. The appropriate values for `OTEL_EXPORTER_OTLP_ENDPOINT` and `OTEL_EXPORTER_OTLP_HEADERS` are shown there. + + ![Elastic Cloud OpenTelemetry configuration](images/elastic-cloud-opentelemetry-configuration.png) + + For example: + + ```sh +export OTEL_EXPORTER_OTLP_ENDPOINT=https://my-deployment.apm.us-west1.gcp.cloud.es.io +export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer P....l" + ``` +1. Configure environment variables for the application either in `launchSettings.json` or in the environment where the application is running. +1. Once configured, run the application and make a request to the root endpoint. A trace will be generated and exported to the OTLP endpoint. + +For more information on all the available configuration options, refer to [Configuration](./configure.md). + + +## Confirm that EDOT .NET is working + +To confirm that EDOT .NET has successfully connected to Elastic: + +1. In Kibana, go to **Observability** → **Applications** → **Traces**. +1. You should see the name of the service to which you just added EDOT .NET. It can take several minutes after setting up EDOT .NET for the service to show up in this list. +1. Click on the name of the service in the list to see traces. + + ![Minimal API request trace sample in the Elastic APM UI](images/trace-sample-minimal-api.png) + + +## Next steps + +* Browse all [available configuration options](./configure.md). +* Learn more about viewing and interpreting data in the [Observability guide](https://www.elastic.co/guide/en/observability/current/apm.html). diff --git a/docs/get-started.mdx b/docs/get-started.mdx deleted file mode 100644 index a5da728..0000000 --- a/docs/get-started.mdx +++ /dev/null @@ -1,149 +0,0 @@ ---- -slug: /otel-dotnet/get-started -title: Get started ---- - -This page will show you how to get started with Elastic OpenTelemetry distribution for .NET. - -As the distribution is a lightweight wrapper around the OpenTelemetry SDK, you should be broadly -familiar with the OpenTelemetry SDK concepts and instrumenting applications using the Microsoft -diagnostic APIs. If you are not, we recommend you read the -[OpenTelemetry SDK documentation](https://opentelemetry.io/docs/languages/net) first. - - - This project is not yet recommended for production use. - Functionality may be changed or removed in future releases. - Alpha releases are not subject to the support SLA of official GA features. - - If you would like to experience the alpha and help us improve the distribution by providing - early feedback, follow the steps below to get started. - - -## Prerequisites - -The current documentation and examples are written with .NET 6 and newer applications in mind. -Before continuing, ensure that you have a supported -https://dotnet.microsoft.com/en-us/download/dotnet[.NET SDK version] installed locally. - -## Installation - -To get started with the Elastic OpenTelemetry Distribution for .NET, you must add the `Elastic.OpenTelemetry` -NuGet package to your project. This can be achieved by adding the package reference to your project file. - -```xml - -``` - -After adding the package reference, you can start using the Elastic OpenTelemetry Distribution for .NET -in your application. The distribution includes a transitive dependency on the OpenTelemetry SDK, -so you do not need to add the OpenTelemetry SDK package to your project, although doing so will -cause no harm and may be used to opt into newer SDK versions before the Elastic OpenTelemetry Distribution for .NET -references them. - -The Elastic OpenTelemetry distribution is designed to be easy to use and integrate into your -applications. This includes applications which have previously used the OpenTelemetry SDK directly. -In situations where the OpenTelemetry SDK is already used, the only required change is -to add the `Elastic.OpenTelemetry` NuGet package to the project. Doing so will automatically -switch to the opinionated configuration provided by the Elastic distribution. - -## ASP.NET Core usage - -A common requirement is to instrument ASP.NET Core applications based on the `Microsoft.Extensions.Hosting` -libraries which provide dependency injection via an `IServiceProvider`. - -The OpenTelemetry SDK and the Elastic Distribution for OpenTelemetry .NET provide extension methods to enable observability -features in your application by adding a few lines of code. - -In this section, we'll focus on instrumenting an ASP.NET Core minimal API application using the Elastic -OpenTelemetry distribution. Similar steps can also be used to instrument other ASP.NET Core workloads -and other host-based applications such as https://learn.microsoft.com/en-us/dotnet/core/extensions/workers[worker services]. - - - These examples assume the use of the top-level statements feature introduced in C# 9.0 and the - default choice for applications created using the latest templates. - - -To take advantage of the OpenTelemetry SDK instrumentation for ASP.NET Core, add the following -NuGet package to your project: - -```xml - -``` - -This package includes instrumentation to collect traces for requests handled by ASP.NET Core endpoints. - - - The ASP.NET Core instrumentation is not included by default in the Elastic Distribution for OpenTelemetry .NET. - As with all optional instrumentation libraries, you can choose to include them in your application by - adding a suitable package reference. - - -Inside the `Program.cs` file of the ASP.NET Core application, add the following two using directives: - -```csharp -using OpenTelemetry; -using OpenTelemetry.Trace; -``` - -The OpenTelemetry SDK provides extension methods on the `IServiceCollection` to support enabling the -providers and configuring the SDK. The Elastic Distribution for OpenTelemetry .NET overrides the default SDK registration, -adding several opinionated defaults. - -In the minimal API template, the `WebApplicationBuilder` exposes a `Services` property that can be used -to register services with the dependency injection container. To enable tracing and metrics collection, -ensure that the OpenTelemetry SDK is registered. - -```csharp -var builder = WebApplication.CreateBuilder(args); - -builder.Services - .AddHttpClient() [^1] - .AddOpenTelemetry() [^2] - .WithTracing(t => t.AddAspNetCoreInstrumentation()); [^3] -``` -[^1]: The `AddHttpClient` method registers the `IHttpClientFactory` service with the dependency -injection container. This is NOT required to enable OpenTelemetry, but the example endpoint will use it to -send an HTTP request. -[^2]: The `AddOpenTelemetry` method registers the OpenTelemetry SDK with the dependency injection -container. When available, the Elastic Distribution for OpenTelemetry .NET will override this to add opinionated defaults. -[^3]: Configure tracing to instrument requests handled by ASP.NET Core. - -With these limited changes to the `Program.cs` file, the application is now configured to use the -OpenTelemetry SDK and the Elastic Distribution for OpenTelemetry .NET to collect traces and metrics, which are exported via -OTLP. - -To demonstrate the tracing capabilities, add a simple endpoint to the application: - -```csharp -app.MapGet("/", async (IHttpClientFactory httpClientFactory) => -{ - using var client = httpClientFactory.CreateClient(); - - await Task.Delay(100); - var response = await client.GetAsync("http://elastic.co"); [^1] - await Task.Delay(50); - - return response.StatusCode == System.Net.HttpStatusCode.OK ? Results.Ok() : Results.StatusCode(500); -}); -``` -[^1]: Using this URL will require two redirects, allowing us to see multiple spans in the trace. - -The Elastic Distribution for OpenTelemetry .NET will automatically enable the exporting of signals via the OTLP exporter. This -exporter requires that endpoint(s) are configured. A common mechanism for configuring endpoints is -via environment variables. - -This demo uses an Elastic Cloud deployment as the destination for our observability data. From Kibana -running in Elastic Cloud, navigate to the observability set up guides. Select the OpenTelemetry option -to view the configuration details that should be supplied to the application. - -![Elastic Cloud OpenTelemetry configuration](./images/elastic-cloud-opentelemetry-configuration.png) - -Configure environment variables for the application either in `launchSettings.json` or in the environment -where the application is running. - -Once configured, run the application and make a request to the root endpoint. A trace will be generated -and exported to the OTLP endpoint. - -To view the traces, you can use the Elastic APM UI. - -![Minimal API request trace sample in the Elastic APM UI](./images/trace-sample-minimal-api.png) \ No newline at end of file diff --git a/docs/intro.mdx b/docs/intro.mdx deleted file mode 100644 index 2610dc4..0000000 --- a/docs/intro.mdx +++ /dev/null @@ -1,31 +0,0 @@ ---- -slug: /otel-dotnet/intro -title: Elastic OpenTelemetry Distribution for .NET ---- - - - This project is not yet recommended for production use. - Functionality may be changed or removed in future releases. - Alpha releases are not subject to the support SLA of official GA features. - - If you would like to experience the alpha and help us improve the distribution by providing - early feedback, see [get started](get-started). - - -The `Elastic.OpenTelemetry` package contains an Elastic Distribution for OpenTelemetry .NET of the -[OpenTelemetry SDK for .NET](https://opentelemetry.io/docs/languages/net). A distribution -is a wrapper around an upstream OpenTelemetry repository with some customizations. For -more details about distributions in general, visit the -[OpenTelemetry documentation](https://opentelemetry.io/docs/concepts/distributions). - -The Elastic Distribution for OpenTelemtry .NET includes some Elastic-specific processors to ensure the best -compatibility when exporting OpenTelemetry signal data to an Elastic backend such -as Elastic APM server. The distribution also preconfigures the collection of tracing -and metrics signals, applying some opinionated defaults, such as which sources are -collected by default. The distribution also ensures that the OTLP exporter is enabled -by default. - -The distribution includes extension methods to fully control the creation of the -underlying tracer and metric providers, providing a helpful set of defaults -to get developers up and running quickly with collecting and exporting OpenTelemetry -signals. \ No newline at end of file diff --git a/src/Elastic.OpenTelemetry/AutoInstrumentationPlugin.cs b/src/Elastic.OpenTelemetry/AutoInstrumentationPlugin.cs index 9343d7c..266b31c 100644 --- a/src/Elastic.OpenTelemetry/AutoInstrumentationPlugin.cs +++ b/src/Elastic.OpenTelemetry/AutoInstrumentationPlugin.cs @@ -14,7 +14,7 @@ namespace Elastic.OpenTelemetry; /// -/// Elastic Distribution for OpenTelemetry .NET plugin for Auto Instrumentation. +/// Elastic Distribution of OpenTelemetry .NET plugin for Auto Instrumentation. /// Ensures all signals are rich enough to report to Elastic /// // ReSharper disable once UnusedType.Global diff --git a/src/Elastic.OpenTelemetry/Configuration/ElasticDefaults.cs b/src/Elastic.OpenTelemetry/Configuration/ElasticDefaults.cs index 38f0ed7..3bc90f9 100644 --- a/src/Elastic.OpenTelemetry/Configuration/ElasticDefaults.cs +++ b/src/Elastic.OpenTelemetry/Configuration/ElasticDefaults.cs @@ -15,15 +15,15 @@ public enum ElasticDefaults /// No Elastic defaults will be included, acting effectively as a vanilla OpenTelemetry None, - /// Include Elastic Distribution for OpenTelemetry .NET tracing defaults + /// Include Elastic Distribution of OpenTelemetry .NET tracing defaults Traces = 1 << 0, //1 - /// Include Elastic Distribution for OpenTelemetry .NET metrics defaults + /// Include Elastic Distribution of OpenTelemetry .NET metrics defaults Metrics = 1 << 1, //2 - /// Include Elastic Distribution for OpenTelemetry .NET logging defaults + /// Include Elastic Distribution of OpenTelemetry .NET logging defaults Logs = 1 << 2, //4 - /// (default) Include all Elastic Distribution for OpenTelemetry .NET logging defaults + /// (default) Include all Elastic Distribution of OpenTelemetry .NET logging defaults All = ~0 } diff --git a/src/Elastic.OpenTelemetry/Configuration/ElasticOpenTelemetryOptions.cs b/src/Elastic.OpenTelemetry/Configuration/ElasticOpenTelemetryOptions.cs index 3d47cc1..57ec5a4 100644 --- a/src/Elastic.OpenTelemetry/Configuration/ElasticOpenTelemetryOptions.cs +++ b/src/Elastic.OpenTelemetry/Configuration/ElasticOpenTelemetryOptions.cs @@ -134,7 +134,7 @@ private static string GetDefaultLogDirectory() public string LogDirectoryDefault { get; } /// - /// The output directory where the Elastic Distribution for OpenTelemetry .NET will write log files. + /// The output directory where the Elastic Distribution of OpenTelemetry .NET will write log files. /// /// /// When configured, a file log will be created in this directory with the name @@ -192,7 +192,7 @@ public bool SkipOtlpExporter } /// - /// Allows flags to be set based of to selectively opt in to Elastic Distribution for OpenTelemetry .NET features. + /// Allows flags to be set based of to selectively opt in to Elastic Distribution of OpenTelemetry .NET features. /// Defaults to /// /// @@ -212,7 +212,7 @@ public ElasticDefaults ElasticDefaults } /// - /// Control which signals will be automatically enabled by the Elastic Distribution for OpenTelemetry .NET. + /// Control which signals will be automatically enabled by the Elastic Distribution of OpenTelemetry .NET. /// /// This configuration respects the open telemetry environment configuration out of the box: /// diff --git a/src/Elastic.OpenTelemetry/Configuration/Signals.cs b/src/Elastic.OpenTelemetry/Configuration/Signals.cs index 3e78e16..a0c9840 100644 --- a/src/Elastic.OpenTelemetry/Configuration/Signals.cs +++ b/src/Elastic.OpenTelemetry/Configuration/Signals.cs @@ -14,15 +14,15 @@ public enum Signals /// No Elastic defaults will be included, acting effectively as a vanilla OpenTelemetry None, - /// Include Elastic Distribution for OpenTelemetry .NET tracing defaults + /// Include Elastic Distribution of OpenTelemetry .NET tracing defaults Traces = 1 << 0, //1 - /// Include Elastic Distribution for OpenTelemetry .NET metrics defaults + /// Include Elastic Distribution of OpenTelemetry .NET metrics defaults Metrics = 1 << 1, //2 - /// Include Elastic Distribution for OpenTelemetry .NET logging defaults + /// Include Elastic Distribution of OpenTelemetry .NET logging defaults Logs = 1 << 2, //4 - /// (default) Include all Elastic Distribution for OpenTelemetry .NET logging defaults + /// (default) Include all Elastic Distribution of OpenTelemetry .NET logging defaults All = ~0 } diff --git a/src/Elastic.OpenTelemetry/Diagnostics/LoggerMessages.cs b/src/Elastic.OpenTelemetry/Diagnostics/LoggerMessages.cs index 79f8751..26686f1 100644 --- a/src/Elastic.OpenTelemetry/Diagnostics/LoggerMessages.cs +++ b/src/Elastic.OpenTelemetry/Diagnostics/LoggerMessages.cs @@ -36,13 +36,13 @@ internal static partial class LoggerMessages public static void LogAgentPreamble(this ILogger logger) { var process = Process.GetCurrentProcess(); - logger.LogInformation("Elastic Distribution for OpenTelemetry .NET: {AgentInformationalVersion}", VersionHelper.InformationalVersion); + logger.LogInformation("Elastic Distribution of OpenTelemetry .NET: {AgentInformationalVersion}", VersionHelper.InformationalVersion); if (logger is CompositeLogger distributionLogger) { if (distributionLogger.LogFileEnabled) - logger.LogInformation("Elastic Distribution for OpenTelemetry .NET, log file: {LogFilePath}", distributionLogger.LogFilePath); + logger.LogInformation("Elastic Distribution of OpenTelemetry .NET, log file: {LogFilePath}", distributionLogger.LogFilePath); else - logger.LogInformation("Elastic Distribution for OpenTelemetry .NET, log file: "); + logger.LogInformation("Elastic Distribution of OpenTelemetry .NET, log file: "); } logger.LogInformation("Process ID: {ProcessId}", process.Id); diff --git a/src/Elastic.OpenTelemetry/Elastic.OpenTelemetry.csproj b/src/Elastic.OpenTelemetry/Elastic.OpenTelemetry.csproj index d16d0e7..69f6374 100644 --- a/src/Elastic.OpenTelemetry/Elastic.OpenTelemetry.csproj +++ b/src/Elastic.OpenTelemetry/Elastic.OpenTelemetry.csproj @@ -3,7 +3,7 @@ Library netstandard2.0;netstandard2.1;net462;net6.0;net8.0 - Elastic Distribution for OpenTelemetry .NET + Elastic Distribution of OpenTelemetry .NET OpenTelemetry extensions for Elastic Observability, fully native with zero code changes. elastic;opentelemetry;observabillity;apm;logs;metrics;traces;monitoring enable diff --git a/src/Elastic.OpenTelemetry/ElasticOpenTelemetryBuilder.cs b/src/Elastic.OpenTelemetry/ElasticOpenTelemetryBuilder.cs index 217f973..6b44c98 100644 --- a/src/Elastic.OpenTelemetry/ElasticOpenTelemetryBuilder.cs +++ b/src/Elastic.OpenTelemetry/ElasticOpenTelemetryBuilder.cs @@ -52,7 +52,7 @@ public class ElasticOpenTelemetryBuilder : IOpenTelemetryBuilder public IServiceCollection Services { get; } /// - /// Shared bootstrap routine for the Elastic Distribution for OpenTelemetry .NET. + /// Shared bootstrap routine for the Elastic Distribution of OpenTelemetry .NET. /// Used to ensure auto instrumentation and manual instrumentation bootstrap the same way. /// public static (EventListener, ILogger) Bootstrap(ElasticOpenTelemetryBuilderOptions options) diff --git a/src/Elastic.OpenTelemetry/Extensions/MeterProviderBuilderExtensions.cs b/src/Elastic.OpenTelemetry/Extensions/MeterProviderBuilderExtensions.cs index 88d9282..092c847 100644 --- a/src/Elastic.OpenTelemetry/Extensions/MeterProviderBuilderExtensions.cs +++ b/src/Elastic.OpenTelemetry/Extensions/MeterProviderBuilderExtensions.cs @@ -14,7 +14,7 @@ namespace Elastic.OpenTelemetry.Extensions; /// public static class MeterProviderBuilderExtensions { - /// Use Elastic Distribution for OpenTelemetry .NET defaults for + /// Use Elastic Distribution of OpenTelemetry .NET defaults for public static MeterProviderBuilder UseElasticDefaults(this MeterProviderBuilder builder, ILogger? logger = null) { logger ??= NullLogger.Instance; diff --git a/src/Elastic.OpenTelemetry/Extensions/TracerProviderBuilderExtensions.cs b/src/Elastic.OpenTelemetry/Extensions/TracerProviderBuilderExtensions.cs index 8446490..6807d57 100644 --- a/src/Elastic.OpenTelemetry/Extensions/TracerProviderBuilderExtensions.cs +++ b/src/Elastic.OpenTelemetry/Extensions/TracerProviderBuilderExtensions.cs @@ -34,7 +34,7 @@ private static TracerProviderBuilder LogAndAddProcessor(this TracerProviderBuild return builder.AddProcessor(processor); } - /// Use Elastic Distribution for OpenTelemetry .NET defaults for + /// Use Elastic Distribution of OpenTelemetry .NET defaults for public static TracerProviderBuilder UseElasticDefaults(this TracerProviderBuilder builder, ILogger? logger = null) { logger ??= NullLogger.Instance; diff --git a/src/Elastic.OpenTelemetry/IInstrumentationLifetime.cs b/src/Elastic.OpenTelemetry/IInstrumentationLifetime.cs index 31f667b..29d41dd 100644 --- a/src/Elastic.OpenTelemetry/IInstrumentationLifetime.cs +++ b/src/Elastic.OpenTelemetry/IInstrumentationLifetime.cs @@ -4,6 +4,6 @@ namespace Elastic.OpenTelemetry; /// -/// A logical Elastic Distribution for OpenTelemetry .NET instance. +/// A logical Elastic Distribution of OpenTelemetry .NET instance. /// public interface IInstrumentationLifetime : IDisposable, IAsyncDisposable; diff --git a/tests/AutoInstrumentation.IntegrationTests/PluginLoaderTests.cs b/tests/AutoInstrumentation.IntegrationTests/PluginLoaderTests.cs index 4a91c95..20fc496 100644 --- a/tests/AutoInstrumentation.IntegrationTests/PluginLoaderTests.cs +++ b/tests/AutoInstrumentation.IntegrationTests/PluginLoaderTests.cs @@ -19,7 +19,7 @@ public async Task ObserveDistributionPluginLoad() var output = exampleApplicationContainer.FailureTestOutput(); output.Should() .NotBeNullOrWhiteSpace() - .And.Contain("Elastic Distribution for OpenTelemetry .NET:") + .And.Contain("Elastic Distribution of OpenTelemetry .NET:") .And.Contain("ElasticOpenTelemetryBuilder initialized") .And.Contain("Added 'Elastic.OpenTelemetry.Processors.ElasticCompatibilityProcessor'"); diff --git a/tests/Elastic.OpenTelemetry.Tests/LoggingTests.cs b/tests/Elastic.OpenTelemetry.Tests/LoggingTests.cs index 7d1a363..43ded66 100644 --- a/tests/Elastic.OpenTelemetry.Tests/LoggingTests.cs +++ b/tests/Elastic.OpenTelemetry.Tests/LoggingTests.cs @@ -33,9 +33,9 @@ public async Task ObserveLogging() } //assert preamble information gets logged - logger.Messages.Should().ContainMatch("*Elastic Distribution for OpenTelemetry .NET:*"); + logger.Messages.Should().ContainMatch("*Elastic Distribution of OpenTelemetry .NET:*"); - var preambles = logger.Messages.Where(l => l.Contains("[Information] Elastic Distribution for OpenTelemetry .NET:")).ToList(); + var preambles = logger.Messages.Where(l => l.Contains("[Information] Elastic Distribution of OpenTelemetry .NET:")).ToList(); preambles.Should().NotBeNull().And.HaveCount(1); // assert instrumentation session logs initialized and stack trace gets dumped.