AgentFrameworkSpanProcessor make public

[MCKRUZ]

Good afternoon, I wanted to add some Agent Telemetry to my existing project but saw that the AgentFrameworkSpanProcessor is actually an internal class, the only way I see to currently utilize it is with WithAgentFramework which I don't need to use since I have a highly customized Telemetry pipeline that I already configure. All I really want to do is add the right sources and processors to my existing pipeline.

Any chance of a change?

[rahuldevikar761]

Hi @juliomenendez, can you take a look?

[threddy]

@MCKRUZ Are you looking to
Subscribe to OTel spans emitted by AgentsFramework + export them to your existing setup? OR
Subscribe to OTel spans emitted by AgentsFramework + use the exporter the Agent 365 Observability SDK provides (which will export spans to MAC/Defender/Purview) OR
Manually instrument your code with other spans provided by the Agent 365 Observability SDK + use the exporter the Agent 365 Observability SDK provides (which will export spans to MAC/Defender/Purview)

[MCKRUZ]

I have a rather complex telemetry setup. (see below). I mainly want to be in control of the way things are configured.

`public static class IServiceCollectionExtensions
{
#region Public Methods

/// <summary>
/// Configures OpenTelemetry observability services with automatic environment detection.
/// This method sets up comprehensive telemetry collection including traces, metrics, and logs,
/// automatically selecting the appropriate configuration based on the application type.
/// </summary>
/// <param name="services">The service collection to add OpenTelemetry services to.</param>
/// <param name="appConfig">Application configuration containing OpenTelemetry settings.</param>
/// <returns>The service collection for chaining configuration calls.</returns>
/// <remarks>
/// <para>
/// This method implements intelligent environment detection to determine whether the application
/// should use web-specific or desktop-specific OpenTelemetry configuration. The detection is based
/// on whether the current assembly name is listed in the <c>Logger.WebTelemetryProjects</c> configuration.
/// </para>
///
/// <para>
/// <strong>Environment Detection Logic:</strong>
/// <list type="bullet">
/// <item><description><strong>Web Applications:</strong> Use <see cref="AddWebTelemetry"/> for full ASP.NET Core integration</description></item>
/// <item><description><strong>Desktop Applications:</strong> Use <see cref="AddDesktopTelemetry"/> for standalone service configuration</description></item>
/// <item><description><strong>Fallback:</strong> Desktop configuration is used when web detection fails</description></item>
/// </list>
/// </para>
///
/// <para>
/// <strong>Configured Services:</strong>
/// <list type="bullet">
/// <item><description>ResourceBuilder singleton for consistent resource attribution</description></item>
/// <item><description>Web telemetry: TracerProvider and MeterProvider via ASP.NET Core integration</description></item>
/// <item><description>Desktop telemetry: Standalone TracerProvider and MeterProvider services</description></item>
/// <item><description>Automatic resource builder creation with application metadata</description></item>
/// </list>
/// </para>
///
/// <para>
/// <strong>Prerequisites:</strong>
/// <list type="bullet">
/// <item><description>AppConfig must be registered in the service collection</description></item>
/// <item><description>Logger configuration section should contain WebTelemetryProjects list</description></item>
/// <item><description>Required OpenTelemetry packages must be referenced</description></item>
/// </list>
/// </para>
/// </remarks>
/// <example>
/// <code>
/// // In Program.cs
/// var builder = WebApplication.CreateBuilder(args);
///
/// // Register configuration
/// builder.Services.Configure&lt;AppConfig&gt;(builder.Configuration);
/// var appConfig = builder.Configuration.Get&lt;AppConfig&gt;();
///
/// // Add OpenTelemetry with automatic environment detection
/// builder.Services.AddOpenTelemetry(appConfig);
///
/// // The method will automatically detect if this is a web application
/// // and configure telemetry appropriately
/// </code>
/// </example>
/// <example>
/// <code>
/// // Manual environment specification
/// var services = new ServiceCollection();
/// services.Configure&lt;AppConfig&gt;(config);
/// var appConfig = config.Get&lt;AppConfig&gt;();
///
/// // This will automatically detect the application type
/// services.AddOpenTelemetry(appConfig);
///
/// // For web apps (assembly name in WebTelemetryProjects):
/// // - Configures ASP.NET Core instrumentation
/// // - Sets up HTTP client and server tracing
/// // - Enables Prometheus metrics endpoint
///
/// // For desktop apps:
/// // - Configures standalone providers
/// // - Enables manual instrumentation
/// // - Sets up application-specific metrics
/// </code>
/// </example>
public static IServiceCollection AddOpenTelemetry(this IServiceCollection services, AppConfig appConfig)
{
	var currentAssemblyName = Assembly.GetEntryAssembly()?.GetName().Name;

	// Register ResourceBuilder as a singleton
	services.AddSingleton<ResourceBuilder>(sp =>
	{
		var config = sp.GetRequiredService<IOptionsMonitor<AppConfig>>();
		return CreateResourceBuilder(config);
	});

	if (currentAssemblyName != null && appConfig.Logger.WebTelemetryProjects.Contains(currentAssemblyName))
		return services.AddWebTelemetry();
	else
		return services.AddDesktopTelemetry();
}

/// <summary>
/// Configures comprehensive logging services with multiple providers and OpenTelemetry integration.
/// This method sets up structured logging with console output, debug logging, and telemetry export
/// capabilities for comprehensive application monitoring and debugging.
/// </summary>
/// <param name="services">The service collection to add logging services to.</param>
/// <returns>The service collection for chaining configuration calls.</returns>
/// <remarks>
/// <para>
/// This method configures a multi-provider logging system that combines traditional logging
/// with modern observability features. It clears any existing providers to ensure a clean
/// configuration and then adds providers for different scenarios and environments.
/// </para>
///
/// <para>
/// <strong>Configured Logging Providers:</strong>
/// <list type="bullet">
/// <item><description><strong>Console Logger:</strong> Simple console output for basic logging scenarios</description></item>
/// <item><description><strong>Debug Logger:</strong> Visual Studio debug output for development debugging</description></item>
/// <item><description><strong>Simple Console Logger:</strong> Enhanced console output with colors, timestamps, and scopes</description></item>
/// <item><description><strong>OpenTelemetry Logger:</strong> Telemetry integration for observability platforms</description></item>
/// </list>
/// </para>
///
/// <para>
/// <strong>Console Formatting Features:</strong>
/// <list type="bullet">
/// <item><description>Colored output based on log level (Error=Red, Warning=Yellow, etc.)</description></item>
/// <item><description>Timestamps in "yyyy-MM-dd HH:mm:ss" format for precise timing</description></item>
/// <item><description>Single-line output for compact console display</description></item>
/// <item><description>Scope inclusion for contextual logging information</description></item>
/// </list>
/// </para>
///
/// <para>
/// <strong>OpenTelemetry Integration:</strong>
/// <list type="bullet">
/// <item><description>Structured log data export to observability platforms</description></item>
/// <item><description>OTLP exporter for OpenTelemetry Protocol compatible backends</description></item>
/// <item><description>Azure Monitor integration for Application Insights</description></item>
/// <item><description>Resource builder integration for consistent service attribution</description></item>
/// <item><description>Enhanced options: scope inclusion, formatted messages, and state parsing</description></item>
/// </list>
/// </para>
///
/// <para>
/// <strong>Configuration Dependencies:</strong>
/// <list type="bullet">
/// <item><description>Requires AppConfig to be registered in the service collection</description></item>
/// <item><description>Needs ResourceBuilder singleton for OpenTelemetry configuration</description></item>
/// <item><description>Logger configuration section should contain exporter endpoints</description></item>
/// </list>
/// </para>
/// </remarks>
/// <example>
/// <code>
/// // In Program.cs
/// var builder = WebApplication.CreateBuilder(args);
///
/// // Configure application settings first
/// builder.Services.Configure&lt;AppConfig&gt;(builder.Configuration);
///
/// // Add comprehensive logging
/// builder.Services.AddLogging();
///
/// // Use logger in services
/// public class MyService
/// {
///     private readonly ILogger&lt;MyService&gt; _logger;
///
///     public MyService(ILogger&lt;MyService&gt; logger)
///     {
///         _logger = logger;
///     }
///
///     public void DoWork()
///     {
///         _logger.LogInformation("Starting work at {Time}", DateTime.UtcNow);
///         _logger.LogWarning("This is a warning message");
///         _logger.LogError("An error occurred: {Error}", "Something went wrong");
///     }
/// }
/// </code>
/// </example>
/// <example>
/// <code>
/// // Configuration for different environments
/// // appsettings.Development.json
/// {
///   "Logger": {
///     "OtelExporterEndpoint": "http://localhost:4317"
///   }
/// }
///
/// // appsettings.Production.json
/// {
///   "Logger": {
///     "ApplicationInsights": {
///       "ConnectionString": "InstrumentationKey=xxx;IngestionEndpoint=https://xxx.in.ai.azure.com/"
///     },
///     "OtelExporterEndpoint": "https://otelcollector.example.com:4317"
///   }
/// }
///
/// // The logging configuration automatically adapts based on the environment
/// </code>
/// </example>
public static IServiceCollection AddLogging(this IServiceCollection services)
{
	services.AddLogging(loggingBuilder =>
	{
		loggingBuilder.ClearProviders();

		loggingBuilder.AddConsole(options =>
		{
			options.FormatterName = ConsoleFormatterNames.Simple;
		});

		loggingBuilder.AddDebug();

		loggingBuilder.AddSimpleConsole(options =>
		{
			options.IncludeScopes = true;
			options.SingleLine = true;
			options.ColorBehavior = LoggerColorBehavior.Enabled;
			options.TimestampFormat = "yyyy-MM-dd HH:mm:ss ";
		});

		loggingBuilder.AddOpenTelemetry();
	});

	// Use OptionsBuilder to configure with DI
	services.AddOptions<OpenTelemetryLoggerOptions>()
		.Configure<IOptionsMonitor<AppConfig>, ResourceBuilder>((options, appConfig, resourceBuilder) =>
		{
			var config = appConfig.CurrentValue;

			options.IncludeScopes = true;
			options.ParseStateValues = true;
			options.IncludeFormattedMessage = true;
			options.SetResourceBuilder(resourceBuilder);
			if (!string.IsNullOrEmpty(config.Logger.OtelExporterEndpoint))
				options.AddOtlpExporter(otlpOptions => otlpOptions.Endpoint = new Uri(config.Logger.OtelExporterEndpoint));
			if (!string.IsNullOrEmpty(config.Logger.ApplicationInsights.ConnectionString))
				options.AddAzureMonitorLogExporter(azureOptions => azureOptions.ConnectionString = config.Logger.ApplicationInsights.ConnectionString);
		});

	return services;
}

/// <summary>
/// Configures Microsoft Graph API client with Azure AD authentication using client credentials flow.
/// This method registers a singleton <see cref="GraphServiceClient"/> that can be used throughout
/// the application to interact with Microsoft Graph API endpoints.
/// </summary>
/// <param name="services">The service collection to add Graph API services to.</param>
/// <returns>The service collection for chaining configuration calls.</returns>
/// <remarks>
/// <para>
/// This method sets up the Microsoft Graph API client with proper authentication using the
/// Azure AD client credentials flow. The client is registered as a singleton to optimize
/// performance and resource usage, making it suitable for applications that make frequent
/// Graph API calls.
/// </para>
///
/// <para>
/// <strong>Authentication Configuration:</strong>
/// <list type="bullet">
/// <item><description>Uses Azure AD client credentials flow for service-to-service authentication</description></item>
/// <item><description>Registers as singleton for optimal performance and resource management</description></item>
/// <item><description>Uses <see cref="IOptionsMonitor{AppConfig}"/> for configuration change tracking</description></item>
/// <item><description>Automatic credential refresh and token management handled by Azure SDK</description></item>
/// </list>
/// </para>
///
/// <para>
/// <strong>Required Configuration:</strong>
/// The following configuration settings must be provided in AppConfig:
/// <list type="bullet">
/// <item><description><strong>Azure.GraphApi.Entra.TenantId:</strong> Azure AD tenant identifier</description></item>
/// <item><description><strong>Azure.GraphApi.Entra.ClientId:</strong> Application (client) ID from Azure AD registration</description></item>
/// <item><description><strong>Azure.GraphApi.Entra.ClientSecret:</strong> Client secret for the application</description></item>
/// <item><description><strong>Azure.GraphApi.Scope:</strong> Default scope for Graph API access (typically "https://graph.microsoft.com/.default")</description></item>
/// </list>
/// </para>
///
/// <para>
/// <strong>Security Considerations:</strong>
/// <list type="bullet">
/// <item><description>Store client secrets securely (Azure Key Vault, environment variables, etc.)</description></item>
/// <item><description>Ensure the Azure AD app has proper Graph API permissions</description></item>
/// <item><description>Use least privilege principle for Graph API access</description></item>
/// <item><description>Consider using managed identities when hosting in Azure</description></item>
/// </list>
/// </para>
///
/// <para>
/// <strong>Common Use Cases:</strong>
/// <list type="bullet">
/// <item><description>Reading user profiles and directory information</description></item>
/// <item><description>Sending emails through Microsoft Graph</description></item>
/// <item><description>Managing Azure AD users and groups</description></item>
/// <item><description>Accessing SharePoint files and OneDrive content</description></item>
/// <item><description>Handling calendar events and Teams meetings</description></item>
/// </list>
/// </para>
/// </remarks>
/// <example>
/// <code>
/// // In Program.cs
/// var builder = WebApplication.CreateBuilder(args);
///
/// // Configure application settings
/// builder.Services.Configure&lt;AppConfig&gt;(builder.Configuration);
///
/// // Add Graph API support
/// builder.Services.ConfigureGraphApi();
///
/// // Use Graph API in services
/// public class UserService
/// {
///     private readonly GraphServiceClient _graphClient;
///
///     public UserService(GraphServiceClient graphClient)
///     {
///         _graphClient = graphClient;
///     }
///
///     public async Task&lt;User&gt; GetUserAsync(string userId)
///     {
///         return await _graphClient.Users[userId].GetAsync();
///     }
///
///     public async Task SendEmailAsync(string toEmail, string subject, string body)
///     {
///         var message = new Message
///         {
///             Subject = subject,
///             Body = new ItemBody { Content = body, ContentType = BodyType.Text },
///             ToRecipients = new[] { new Recipient { EmailAddress = new EmailAddress { Address = toEmail } } }
///         };
///
///         await _graphClient.Me.SendMail(message, false).PostAsync();
///     }
/// }
/// </code>
/// </example>
/// <example>
/// <code>
/// // Configuration in appsettings.json
/// {
///   "Azure": {
///     "GraphApi": {
///       "Entra": {
///         "TenantId": "your-tenant-id-here",
///         "ClientId": "your-client-id-here",
///         "ClientSecret": "your-client-secret-here"
///       },
///       "Scope": "https://graph.microsoft.com/.default"
///     }
///   }
/// }
///
/// // Azure AD App Registration Requirements:
/// // 1. Register a new application in Azure AD
/// // 2. Add a client secret
/// // 3. Grant appropriate Graph API permissions (e.g., User.Read.All, Mail.Send)
/// // 4. Grant admin consent for the permissions
/// // 5. Copy the Tenant ID, Client ID, and Client Secret to your configuration
/// </code>
/// </example>
/// <example>
/// <code>
/// // Error handling and usage patterns
/// public class GraphService
/// {
///     private readonly GraphServiceClient _graphClient;
///     private readonly ILogger&lt;GraphService&gt; _logger;
///
///     public GraphService(GraphServiceClient graphClient, ILogger&lt;GraphService&gt; logger)
///     {
///         _graphClient = graphClient;
///         _logger = logger;
///     }
///
///     public async Task&lt;IEnumerable&lt;User&gt;&gt; GetUsersAsync()
///     {
///         try
///         {
///             var users = await _graphClient.Users
///                 .GetAsync(requestConfiguration =>
///                 {
///                     requestConfiguration.QueryParameters.Top = 25;
///                     requestConfiguration.QueryParameters.Select = "id,displayName,mail,userPrincipalName";
///                 });
///
///             return users?.Value ?? Enumerable.Empty&lt;User&gt;();
///         }
///         catch (ServiceException ex)
///         {
///             _logger.LogError(ex, "Failed to retrieve users from Graph API");
///             throw;
///         }
///     }
/// }
/// </code>
/// </example>
public static IServiceCollection ConfigureGraphApi(this IServiceCollection services)
{
	// Register the GraphServiceClient as a singleton using IOptionsMonitor<AppConfig> for change tracking
	services.AddSingleton<GraphServiceClient>(sp =>
	{
		var appConfig = sp.GetRequiredService<IOptionsMonitor<AppConfig>>().CurrentValue;

		var clientSecretCredential = new Azure.Identity.ClientSecretCredential(
			appConfig.Azure.GraphApi.Entra.TenantId,
			appConfig.Azure.GraphApi.Entra.ClientId,
			appConfig.Azure.GraphApi.Entra.ClientSecret);

		return new GraphServiceClient(clientSecretCredential, appConfig.Azure.GraphApi.Scope);
	});

	return services;
}
#endregion

#region Private Methods
private static IServiceCollection AddWebTelemetry(this IServiceCollection services)
{
	// Enable Semantic Kernel OTel Diagnostics
	AppContext.SetSwitch("Microsoft.SemanticKernel.Experimental.GenAI.EnableOTelDiagnosticsSensitive", true);

	// Enable Experimental Azure SDK Observability
	AppContext.SetSwitch("Azure.Experimental.EnableActivitySource", true);

	// By default instrumentation captures chat messages without content
	// since content can be very verbose and have sensitive information.
	// The following AppContext switch enables content recording.
	AppContext.SetSwitch("Microsoft.Experimental.TraceGenAIMessageContent", true);

	// Customize instrumentation options
	CustomizeAspNetCoreTraceInstrumentationOptions(services);
	CustomizeHttpClientTraceInstrumentationOptions(services);

	services.AddOpenTelemetry()
		.WithTracing(builder =>
		{
			var sp = services.BuildServiceProvider();
			var appConfig = sp.GetRequiredService<IOptionsMonitor<AppConfig>>();
			var resourceBuilder = sp.GetRequiredService<ResourceBuilder>();
			builder.ConfigureTracerProviderBuilder(appConfig, resourceBuilder);
		})
		.WithMetrics(builder =>
		{
			var sp = services.BuildServiceProvider();
			var appConfig = sp.GetRequiredService<IOptionsMonitor<AppConfig>>();
			var resourceBuilder = sp.GetRequiredService<ResourceBuilder>();
			builder.ConfigureMeterProviderBuilder(appConfig, resourceBuilder);
		});

	return services;
}

private static IServiceCollection AddDesktopTelemetry(this IServiceCollection services)
{
	// Allows for Semantic Kernel to be used with Open Telemetry
	AppContext.SetSwitch("Microsoft.SemanticKernel.Experimental.GenAI.EnableOTelDiagnosticsSensitive", true);

	// Customize instrumentation options
	CustomizeAspNetCoreTraceInstrumentationOptions(services);
	CustomizeHttpClientTraceInstrumentationOptions(services);

	services.AddSingleton<TracerProvider>(sp =>
	{
		var config = sp.GetRequiredService<IOptionsMonitor<AppConfig>>();
		var resourceBuilder = sp.GetRequiredService<ResourceBuilder>();
		return BuildTracerProvider(config, resourceBuilder);
	});

	services.AddSingleton<MeterProvider>(sp =>
	{
		var config = sp.GetRequiredService<IOptionsMonitor<AppConfig>>();
		var resourceBuilder = sp.GetRequiredService<ResourceBuilder>();
		return BuildMeterProvider(config, resourceBuilder);
	});

	return services;
}

private static MeterProvider BuildMeterProvider(IOptionsMonitor<AppConfig> config, ResourceBuilder resourceBuilder)
{
	// Build the meter provider builder
	var meterProviderBuilder = Sdk.CreateMeterProviderBuilder()
												   .ConfigureMeterProviderBuilder(config, resourceBuilder);

	// Build the meter provider
	var meterProvider = meterProviderBuilder.Build();

	return meterProvider; 
}

private static TracerProvider BuildTracerProvider(IOptionsMonitor<AppConfig> config, ResourceBuilder resourceBuilder)
{
	// Build the tracer provider builder
	var tracerProviderBuilder = Sdk.CreateTracerProviderBuilder()
												     .ConfigureTracerProviderBuilder(config, resourceBuilder);

	// Build the meter provider
	var tracerProvider = tracerProviderBuilder.Build();

	return tracerProvider;
}

private static void CustomizeAspNetCoreTraceInstrumentationOptions(IServiceCollection services)
{
	services.Configure<AspNetCoreTraceInstrumentationOptions>(options =>
	{
		options.RecordException = true;
		options.EnrichWithException = (activity, exception) =>
		{
			activity.SetTag("exception.type", exception.GetType().FullName);
			activity.SetTag("exception.message", exception.Message);
			activity.SetTag("exception.stacktrace", exception.StackTrace);
		};
	});
}

private static void CustomizeHttpClientTraceInstrumentationOptions(IServiceCollection services)
{
	services.Configure<HttpClientTraceInstrumentationOptions>(options =>
	{
		options.RecordException = true;
		options.EnrichWithException = (activity, exception) =>
		{
			activity.SetTag("exception.type", exception.GetType().FullName);
			activity.SetTag("exception.message", exception.Message);
			activity.SetTag("exception.stacktrace", exception.StackTrace);
		};
	});
}

private static MeterProviderBuilder ConfigureMeterProviderBuilder(this MeterProviderBuilder builder, IOptionsMonitor<AppConfig> appConfig, ResourceBuilder resourceBuilder)
{
	builder
		.SetResourceBuilder(resourceBuilder)
		.AddMeter(SKOpenTelemetryInstrument.SourceName)
		.AddMeter(AgentsAIOpenTelemetryInstrument.SourceName)
		.AddMeter(ExtensionsAITelemetryInstrument.SourceName)
		.AddMeter("Microsoft.AspNetCore.Hosting")
		.AddMeter("Microsoft.AspNetCore.Server.Kestrel")
		.SetExemplarFilter(ExemplarFilterType.TraceBased)
		.AddAspNetCoreInstrumentation()
		.AddHttpClientInstrumentation()
		.AddRuntimeInstrumentation()
		.AddView(instrument =>
		{
			return instrument.GetType().GetGenericTypeDefinition() == typeof(Histogram<>)
				? new Base2ExponentialBucketHistogramConfiguration()
				: null;
		});


	if (!string.IsNullOrEmpty(appConfig.CurrentValue.Logger.OtelExporterEndpoint))
		builder.AddOtlpExporter(options => options.Endpoint = new Uri(appConfig.CurrentValue.Logger.OtelExporterEndpoint));

	if (!string.IsNullOrEmpty(appConfig.CurrentValue.Logger.ApplicationInsights.ConnectionString))
		builder.AddAzureMonitorMetricExporter(options => options.ConnectionString = appConfig.CurrentValue.Logger.ApplicationInsights.ConnectionString);

	builder.AddPrometheusExporter();

	return builder;
}

private static TracerProviderBuilder ConfigureTracerProviderBuilder(this TracerProviderBuilder builder, IOptionsMonitor<AppConfig> appConfig, ResourceBuilder resourceBuilder)
{
	builder
		.SetResourceBuilder(resourceBuilder)
		.AddSource(SKOpenTelemetryInstrument.SourceName)
		.AddSource(AgentsAIOpenTelemetryInstrument.SourceName)
		.AddSource(ExtensionsAITelemetryInstrument.SourceName)
		.AddProcessor(new AgentFrameworkSpanProcessor())
		.SetSampler(new AlwaysOnSampler())
		.AddAspNetCoreInstrumentation()
		.AddHttpClientInstrumentation()
		.AddEntityFrameworkCoreInstrumentation()
		.AddSqlClientInstrumentation();
		
	if (!string.IsNullOrEmpty(appConfig.CurrentValue.Logger.OtelExporterEndpoint))
		builder.AddOtlpExporter(options => options.Endpoint = new Uri(appConfig.CurrentValue.Logger.OtelExporterEndpoint));

	if (!string.IsNullOrEmpty(appConfig.CurrentValue.Logger.ApplicationInsights.ConnectionString))
		builder.AddAzureMonitorTraceExporter(options => options.ConnectionString = appConfig.CurrentValue.Logger.ApplicationInsights.ConnectionString);

	return builder;
}

private static ResourceBuilder CreateResourceBuilder(IOptionsMonitor<AppConfig> appConfig)
{
	var callingAssembly = Assembly.GetEntryAssembly();
	var serviceName = callingAssembly?.GetName().Name ?? "UnknownService";
	var serviceNamespace = callingAssembly?.EntryPoint?.DeclaringType?.Namespace
						   ?? callingAssembly?.GetName().Name
						   ?? "UnknownNamespace";

	return ResourceBuilder
		.CreateDefault()
		.AddService(
			serviceName: serviceName,
			serviceNamespace: serviceNamespace,
			serviceVersion: appConfig.CurrentValue.Common.ApplicationVersion)
		.AddAttributes(new List<KeyValuePair<string, object>>
		{
			new("app", serviceName),
			new("app.version", appConfig.CurrentValue.Common.ApplicationVersion),
			new("app.namespace", serviceNamespace),
			new("service.instance.id", Environment.MachineName)
		})
		.AddTelemetrySdk();
}
#endregion

}
`

[threddy]

Thank you for the details. Can you also help me understand which of these scenarios you are aiming to use (i.e. manual or auto-instrumentation using the A365 Observability SDK)? This will determine the set of sources and processors we need to expose.

[MCKRUZ]

Subscribe to OTel spans emitted by AgentsFramework + export them to your existing setup

[MCKRUZ]

The specific one I'm looking for right now is "AgentFrameworkSpanProcessor" which I have currently just replicated in my code. I don't want you to automatically set up telemetry for me, I want access to do it myself custom.