diff --git a/sdk/@launchdarkly/observability-dotnet/.gitignore b/sdk/@launchdarkly/observability-dotnet/.gitignore
index 858f059cc..69b1c92ce 100644
--- a/sdk/@launchdarkly/observability-dotnet/.gitignore
+++ b/sdk/@launchdarkly/observability-dotnet/.gitignore
@@ -2,6 +2,8 @@
 **/obj
 LaunchDarkly.Observability.sln.DotSettings.user
 **/launchSettings.json
+**/.vs/**
+packages/
 docs/
 api/
 nupkgs/
diff --git a/sdk/@launchdarkly/observability-dotnet/README.md b/sdk/@launchdarkly/observability-dotnet/README.md
index 25b0fe63e..3e723e9e2 100644
--- a/sdk/@launchdarkly/observability-dotnet/README.md
+++ b/sdk/@launchdarkly/observability-dotnet/README.md
@@ -9,7 +9,7 @@ LaunchDarkly Observability Plugin for .Net
 
 **NB: APIs are subject to change until a 1.x version is released.**
 
-## Install
+## Install for ASP.Net Core
 
 ```shell
 dotnet add package LaunchDarkly.Observability
@@ -18,7 +18,54 @@ dotnet add package LaunchDarkly.Observability
 Install the plugin when configuring your LaunchDarkly SDK.
 
 ```csharp
- // TODO: Add example.
+var builder = WebApplication.CreateBuilder(args);
+
+
+var config = Configuration.Builder("your-sdk-key")
+    .Plugins(new PluginConfigurationBuilder()
+        .Add(ObservabilityPlugin.Builder(builder.Services)
+            .WithServiceName("your-service-name")
+            .WithServiceVersion("example-sha")
+            .Build()
+        )
+    ).Build();
+
+// Building the LdClient with the Observability plugin. This line will add services to the web application.
+var client = new LdClient(config);
+
+// Client must be built before this line.
+var app = builder.Build();
+```
+
+## Install for an ASP.Net application with .Net Framework 
+
+```csharp
+// In Global.asax.cs
+protected void Application_Start()
+ {
+     // Other application specific code.
+     var client = new LdClient(Configuration.Builder("your-sdk-key")
+         .Plugins(new PluginConfigurationBuilder().Add(ObservabilityPlugin.Builder()
+             .WithServiceName("your-service-name")
+             .WithServiceVersion("example-sha")
+             .Build()))
+         .Build());
+ }
+ 
+ protected void Application_End() {
+     Observe.Shutdown();
+ }
+```
+
+```xml
+<!-- In Web.config -->
+<system.webServer>
+  // Any existing content should remain and the following should be added.
+  <modules>
+  <add name="TelemetryHttpModule" type="OpenTelemetry.Instrumentation.AspNet.TelemetryHttpModule,
+    OpenTelemetry.Instrumentation.AspNet.TelemetryHttpModule" preCondition="integratedMode,managedHandler" />
+  </modules>
+</system.webServer>
 ```
 
 LaunchDarkly overview
@@ -49,4 +96,4 @@ We encourage pull requests and other contributions from the community. Check out
 [dotnetplugin-sdk-ci]: https://github.com/launchdarkly/observability-sdk/actions/workflows/dotnet-plugin.yml
 [o11y-docs-link]: https://launchdarkly.github.io/observability-sdk/sdk/@launchdarkly/observability-dotnet/
 [dotnetplugin-nuget-badge]: https://img.shields.io/nuget/v/LaunchDarkly.Observability.svg?style=flat-square
-[dotnetplugin-nuget-link]: https://www.nuget.org/packages/LaunchDarkly.Observability/
\ No newline at end of file
+[dotnetplugin-nuget-link]: https://www.nuget.org/packages/LaunchDarkly.Observability/
diff --git a/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Asp/Core/ObservabilityExtensions.cs b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Asp/Core/ObservabilityExtensions.cs
new file mode 100644
index 000000000..87e89eded
--- /dev/null
+++ b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Asp/Core/ObservabilityExtensions.cs
@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using LaunchDarkly.Observability.Otel;
+using LaunchDarkly.Logging;
+using LaunchDarkly.Observability.Logging;
+using LaunchDarkly.Observability.Sampling;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using OpenTelemetry;
+using OpenTelemetry.Resources;
+using OpenTelemetry.Trace;
+using OpenTelemetry.Exporter;
+using OpenTelemetry.Logs;
+using OpenTelemetry.Metrics;
+
+// ReSharper disable once CheckNamespace
+namespace LaunchDarkly.Observability
+{
+    /// <summary>
+    /// Static class containing extension methods for configuring observability
+    /// </summary>
+    public static class ObservabilityExtensions
+    {
+        private class LdObservabilityHostedService : IHostedService
+        {
+            private readonly ObservabilityConfig _config;
+            private readonly ILoggerProvider _loggerProvider;
+
+            public LdObservabilityHostedService(ObservabilityConfig config, IServiceProvider provider)
+            {
+                _loggerProvider = provider.GetService<ILoggerProvider>();
+                _config = config;
+            }
+
+            public Task StartAsync(CancellationToken cancellationToken)
+            {
+                Observe.Initialize(_config, _loggerProvider);
+                return Task.CompletedTask;
+            }
+
+            public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+        }
+
+        internal static void AddLaunchDarklyObservabilityWithConfig(this IServiceCollection services,
+            ObservabilityConfig config, Logger logger = null)
+        {
+            DebugLogger.SetLogger(logger);
+
+            var sampler = CommonOtelOptions.GetSampler(config);
+
+            var resourceBuilder = CommonOtelOptions.GetResourceBuilder(config);
+
+            services.AddOpenTelemetry().WithTracing(tracing =>
+            {
+                tracing
+                    .WithCommonLaunchDarklyConfig(config, resourceBuilder, sampler)
+                    .AddAspNetCoreInstrumentation(options => { options.RecordException = true; });
+            }).WithLogging(logging =>
+            {
+                logging.SetResourceBuilder(resourceBuilder)
+                    .AddProcessor(new SamplingLogProcessor(sampler))
+                    .AddOtlpExporter(options =>
+                    {
+                        options.WithCommonLaunchDarklyLoggingExport(config);
+                    });
+                config.ExtendedLoggerConfiguration?.Invoke(logging);
+            }).WithMetrics(metrics =>
+            {
+                metrics
+                    .WithCommonLaunchDarklyConfig(config, resourceBuilder)
+                    .AddAspNetCoreInstrumentation();
+            });
+
+            // Attach a hosted service which will allow us to get a logger provider instance from the built
+            // service collection.
+            services.AddHostedService((serviceProvider) =>
+                new LdObservabilityHostedService(config, serviceProvider));
+        }
+
+        /// <summary>
+        /// Add the LaunchDarkly Observability services. This function would typically be called by the LaunchDarkly
+        /// Observability plugin. This should only be called by the end user if the Observability plugin needs to be
+        /// initialized earlier than the LaunchDarkly client.
+        /// </summary>
+        /// <param name="services">The service collection</param>
+        /// <param name="sdkKey">The LaunchDarkly SDK</param>
+        /// <param name="configure">A method to configure the services</param>
+        /// <returns>The service collection</returns>
+        public static IServiceCollection AddLaunchDarklyObservability(
+            this IServiceCollection services,
+            string sdkKey,
+            Action<ObservabilityConfig.ObservabilityConfigBuilder> configure)
+        {
+            var builder = ObservabilityConfig.Builder();
+            configure(builder);
+
+            var config = builder.Build(sdkKey);
+            AddLaunchDarklyObservabilityWithConfig(services, config);
+            return services;
+        }
+    }
+}
diff --git a/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/ObservabilityPlugin.cs b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Asp/Core/ObservabilityPlugin.cs
similarity index 94%
rename from sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/ObservabilityPlugin.cs
rename to sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Asp/Core/ObservabilityPlugin.cs
index 0859fe116..9bead039e 100644
--- a/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/ObservabilityPlugin.cs
+++ b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Asp/Core/ObservabilityPlugin.cs
@@ -6,7 +6,9 @@
 using LaunchDarkly.Sdk.Server.Plugins;
 using LaunchDarkly.Sdk.Server.Telemetry;
 using Microsoft.Extensions.DependencyInjection;
+using OpenTelemetry.Logs;
 
+// ReSharper disable once CheckNamespace
 namespace LaunchDarkly.Observability
 {
     public class ObservabilityPlugin : Plugin
@@ -20,7 +22,7 @@ public class ObservabilityPlugin : Plugin
         /// In a typical configuration, this method will not need to be used.
         /// </para>
         /// <para>
-        /// This method only needs to be used when observability related functionality must be intialized before it
+        /// This method only needs to be used when observability related functionality must be initialized before it
         /// is possible to initialize the LaunchDarkly SDK.
         /// </para>
         /// </summary>
@@ -32,15 +34,16 @@ public class ObservabilityPlugin : Plugin
         /// <para>
         /// When using this builder, LaunchDarkly client must be constructed before your application is built.
         /// For example:
+        ///
         /// <code>
         /// var builder = WebApplication.CreateBuilder(args);
         ///
         ///
-        /// var config = Configuration.Builder(Environment.GetEnvironmentVariable("your-sdk-key")
+        /// var config = Configuration.Builder("your-sdk-key")
         ///     .Plugins(new PluginConfigurationBuilder()
         ///         .Add(ObservabilityPlugin.Builder(builder.Services)
         ///             .WithServiceName("ryan-test-service")
-        ///             .WithServiceVersion("0.0.0")
+        ///             .WithServiceVersion("example-sha")
         ///             .Build())).Build();
         /// // Building the LdClient with the Observability plugin. This line will add services to the web application.
         /// var client = new LdClient(config);
diff --git a/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Asp/Legacy/ObservabilityPlugin.cs b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Asp/Legacy/ObservabilityPlugin.cs
new file mode 100644
index 000000000..3eb157449
--- /dev/null
+++ b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Asp/Legacy/ObservabilityPlugin.cs
@@ -0,0 +1,113 @@
+using System.Collections.Generic;
+using LaunchDarkly.Sdk.Integrations.Plugins;
+using LaunchDarkly.Sdk.Server.Hooks;
+using LaunchDarkly.Sdk.Server.Interfaces;
+using LaunchDarkly.Sdk.Server.Plugins;
+using LaunchDarkly.Sdk.Server.Telemetry;
+
+// ReSharper disable once CheckNamespace
+namespace LaunchDarkly.Observability
+{
+    public class ObservabilityPlugin : Plugin
+    {
+        private readonly ObservabilityPluginBuilder _config;
+
+        /// <summary>
+        /// Create a new builder for <see cref="ObservabilityPlugin"/>.
+        /// <para>
+        /// When using this builder, LaunchDarkly client must be constructed during Application_Start of your
+        /// web application in Global.asax.cs.
+        /// For example:
+        ///
+        /// <code>
+        ///   protected void Application_Start()
+        ///  {
+        ///      // Other application specific code.
+        ///      var client = new LdClient(Configuration.Builder("your-sdk-key")
+        ///          .Plugins(new PluginConfigurationBuilder().Add(ObservabilityPlugin.Builder()
+        ///              .WithServiceName("classic-asp-application")
+        ///              .WithServiceVersion("example-sha")
+        ///              .Build()))
+        ///          .Build());
+        ///  }
+        ///
+        ///  protected void Application_End() {
+        ///      Observe.Shutdown();
+        ///  }
+        /// </code>
+        ///
+        /// Additionally the Web.config must include the following.
+        ///
+        /// <code>
+        ///  <system.webServer>
+        ///    // Any existing content should remain and the following should be added.
+        ///    <modules>
+        ///    <add name="TelemetryHttpModule" type="OpenTelemetry.Instrumentation.AspNet.TelemetryHttpModule,
+        ///      OpenTelemetry.Instrumentation.AspNet.TelemetryHttpModule" preCondition="integratedMode,managedHandler" />
+        ///    </modules>
+        ///  </system.webServer>
+        /// </code>
+        /// 
+        /// </para>
+        /// </summary>
+        /// <returns>A new <see cref="ObservabilityPluginBuilder"/> instance for configuring the observability plugin.</returns>
+        public static ObservabilityPluginBuilder Builder() =>
+            new ObservabilityPluginBuilder();
+
+        /// <summary>
+        /// Construct a plugin which is intended to be used with already configured observability services.
+        /// <para>
+        /// In a typical configuration, this method will not need to be used.
+        /// </para>
+        /// <para>
+        /// This method only needs to be used when observability related functionality must be initialized before it
+        /// is possible to initialize the LaunchDarkly SDK.
+        /// </para>
+        /// </summary>
+        /// <returns>an observability plugin instance</returns>
+        public static ObservabilityPlugin ForExistingServices() => new ObservabilityPlugin();
+
+        internal ObservabilityPlugin(ObservabilityPluginBuilder config) : base(
+            "LaunchDarkly.Observability")
+        {
+            _config = config;
+        }
+
+        internal ObservabilityPlugin() : base("LaunchDarkly.Observability")
+        {
+            _config = null;
+        }
+
+        /// <inheritdoc />
+        public override void Register(ILdClient client, EnvironmentMetadata metadata)
+        {
+            if (_config == null) return;
+            var config = _config.BuildConfig(metadata.Credential);
+            OpenTelemetry.Register(config);
+        }
+
+        /// <inheritdoc />
+        public override IList<Hook> GetHooks(EnvironmentMetadata metadata)
+        {
+            return new List<Hook>
+            {
+                TracingHook.Builder().IncludeValue().Build()
+            };
+        }
+
+        /// <summary>
+        /// Used to build an instance of the Observability Plugin.
+        /// </summary>
+        public sealed class ObservabilityPluginBuilder : BaseBuilder<ObservabilityPluginBuilder>
+        {
+            /// <summary>
+            /// Build an <see cref="ObservabilityPlugin"/> instance with the configured settings.
+            /// </summary>
+            /// <returns>The constructed <see cref="ObservabilityPlugin"/>.</returns>
+            public ObservabilityPlugin Build()
+            {
+                return new ObservabilityPlugin(this);
+            }
+        }
+    }
+}
diff --git a/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Asp/Legacy/OpenTelemetryConfig.cs b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Asp/Legacy/OpenTelemetryConfig.cs
new file mode 100644
index 000000000..c98b3cef4
--- /dev/null
+++ b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Asp/Legacy/OpenTelemetryConfig.cs
@@ -0,0 +1,100 @@
+using LaunchDarkly.Logging;
+using LaunchDarkly.Observability.Otel;
+using Microsoft.Extensions.Logging;
+using OpenTelemetry;
+using OpenTelemetry.Logs;
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Trace;
+
+// ReSharper disable once CheckNamespace
+namespace LaunchDarkly.Observability
+{
+    public static class OpenTelemetry
+    {
+        private static TracerProvider _tracerProvider;
+        private static MeterProvider _meterProvider;
+        private static readonly object ProviderLock = new object();
+        private static ILoggerFactory _loggerFactory;
+
+        /// <summary>
+        /// Extension method which adds LaunchDarkly logging to a logging factory.
+        ///
+        /// <code>
+        /// using (var factory = LoggerFactory.Create(builder => { builder.AddLaunchDarklyLogging(config); })) {
+        ///   // Use factory to get logger which uses LaunchDarkly loging.
+        /// }
+        /// </code>
+        /// </summary>
+        /// <param name="loggingBuilder">the logging builder for the factory</param>
+        /// <param name="config">the LaunchDarkly observability configuration</param>
+        public static void AddLaunchDarklyLogging(this ILoggingBuilder loggingBuilder, ObservabilityConfig config)
+        {
+            loggingBuilder.AddOpenTelemetry(options =>
+            {
+                options.SetResourceBuilder(CommonOtelOptions.GetResourceBuilder(config))
+                    .AddProcessor(new SamplingLogProcessor(CommonOtelOptions.GetSampler(config)))
+                    .AddOtlpExporter(exportOptions => { exportOptions.WithCommonLaunchDarklyLoggingExport(config); });
+
+                config.ExtendedLoggerConfiguration?.Invoke(options);
+            });
+        }
+
+        /// <summary>
+        /// Configure LaunchDarkly observability. In typical usage, the ObservabilityPlugin should be used instead.
+        /// <para>
+        /// This method is for advanced use-cases where the LaunchDarkly client needs to be initialized later than the
+        /// telemetry implementation.
+        /// </para>
+        /// <para>
+        /// If this method is used, then the <see cref="ObservabilityPlugin"/> should be instantiated using
+        /// <see cref="ObservabilityPlugin.ForExistingServices"/> method.
+        /// </para>
+        /// </summary>
+        /// <param name="config">configuration for LaunchDarkly Observability</param>
+        /// <param name="debugLogger">an optional debug logger</param>
+        public static void Register(ObservabilityConfig config, Logger debugLogger = null)
+        {
+            lock (ProviderLock)
+            {
+                // If the providers are set, then the implementation has already been configured.
+                if (_tracerProvider != null)
+                {
+                    return;
+                }
+
+                var resourceBuilder = CommonOtelOptions.GetResourceBuilder(config);
+                var sampler = CommonOtelOptions.GetSampler(config);
+
+                _tracerProvider = global::OpenTelemetry.Sdk.CreateTracerProviderBuilder()
+                    .WithCommonLaunchDarklyConfig(config, resourceBuilder, sampler)
+                    .AddAspNetInstrumentation()
+                    .Build();
+
+                _meterProvider = global::OpenTelemetry.Sdk.CreateMeterProviderBuilder()
+                    .WithCommonLaunchDarklyConfig(config, resourceBuilder)
+                    .AddAspNetInstrumentation()
+                    .Build();
+
+                _loggerFactory = LoggerFactory.Create(builder => { builder.AddLaunchDarklyLogging(config); });
+                var logger = _loggerFactory.CreateLogger<ObservabilityPlugin>();
+                Observe.Initialize(config, logger);
+            }
+        }
+
+        /// <summary>
+        /// Shutdown the underlying telemetry.
+        /// </summary>
+        public static void Shutdown()
+        {
+            lock (ProviderLock)
+            {
+                _tracerProvider?.Dispose();
+                _meterProvider?.Dispose();
+                _loggerFactory?.Dispose();
+                _tracerProvider = null;
+                _meterProvider = null;
+                _loggerFactory = null;
+            }
+        }
+    }
+}
diff --git a/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/BaseBuilder.cs b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/BaseBuilder.cs
index d24b3fd19..e7f9a283e 100644
--- a/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/BaseBuilder.cs
+++ b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/BaseBuilder.cs
@@ -6,6 +6,12 @@
 
 namespace LaunchDarkly.Observability
 {
+#if NETFRAMEWORK
+    using LoggerBuilderType = OpenTelemetryLoggerOptions;
+#else
+    using LoggerBuilderType = LoggerProviderBuilder;
+#endif
+
     /// <summary>
     /// Base builder which allows for methods to be shared between building a config directly and building a plugin.
     /// <remarks>
@@ -23,7 +29,7 @@ public class BaseBuilder<TBuilder> where TBuilder : BaseBuilder<TBuilder>
         private string _environment = string.Empty;
         private string _serviceVersion = string.Empty;
         private Action<TracerProviderBuilder> _extendedTracerConfiguration;
-        private Action<LoggerProviderBuilder> _extendedLoggerConfiguration;
+        private Action<LoggerBuilderType> _extendedLoggerConfiguration;
         private Action<MeterProviderBuilder> _extendedMeterConfiguration;
 
         protected BaseBuilder()
@@ -171,7 +177,7 @@ public TBuilder WithExtendedTracingConfig(Action<TracerProviderBuilder> extended
         /// </example>
         /// <param name="extendedLoggerConfiguration">A function used to extend the logging configuration.</param>
         /// <returns>A reference to this builder.</returns>
-        public TBuilder WithExtendedLoggerConfiguration(Action<LoggerProviderBuilder> extendedLoggerConfiguration)
+        public TBuilder WithExtendedLoggerConfiguration(Action<LoggerBuilderType> extendedLoggerConfiguration)
         {
             _extendedLoggerConfiguration = extendedLoggerConfiguration;
             return (TBuilder)this;
diff --git a/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/LaunchDarkly.Observability.csproj b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/LaunchDarkly.Observability.csproj
index 9b0e9e7bd..9156aa90e 100644
--- a/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/LaunchDarkly.Observability.csproj
+++ b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/LaunchDarkly.Observability.csproj
@@ -1,71 +1,97 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <!--x-release-please-start-version-->
-    <Version>0.1.0</Version>
-    <!--x-release-please-end-->
-    <Nullable>disable</Nullable>
-    <!-- The BUILDFRAMEWORKS variable allows us to override the target frameworks with a
-         single framework that we are testing; this allows us to test with older SDK
-         versions that would error out if they saw any newer target frameworks listed
-         here, even if we weren't running those. -->
-    <BuildFrameworks Condition="'$(BUILDFRAMEWORKS)' == ''">netstandard2.0;net471;net8.0</BuildFrameworks>
-    <TargetFrameworks>$(BUILDFRAMEWORKS)</TargetFrameworks>
-    <LangVersion>7.3</LangVersion>
-    
-    <Description>LaunchDarkly Observability for Server-Side .NET SDK</Description>
-    <Authors>LaunchDarkly</Authors>
-    <Owners>LaunchDarkly</Owners>
-    <Company>LaunchDarkly</Company>
-    <Copyright>Copyright 2025 Catamorphic, Co</Copyright>
-    <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
-    <PackageProjectUrl>https://github.com/launchdarkly/observability-sdk</PackageProjectUrl>
-    <RepositoryUrl>https://github.com/launchdarkly/observability-sdk</RepositoryUrl>
-
-    <!-- fail if XML comments are missing or invalid -->
-    <WarningsAsErrors>1570,1571,1572,1573,1574,1580,1581,1584,1591,1710,1711,1712</WarningsAsErrors>
-  </PropertyGroup>
-
-  <!-- Allow the testing project to access internals. -->
-  <ItemGroup Condition="'$(Configuration)'!='Release'">
-    <InternalsVisibleTo Include="LaunchDarkly.Observability.Tests" />
-    <!-- Dynamically generated assembly used by Moq. Required for mocking in unit tests. -->
-    <InternalsVisibleTo Include="DynamicProxyGenAssembly2"/>
-  </ItemGroup>
-
-  <PropertyGroup Condition="'$(Configuration)'=='Release' And '$(SKIP_SIGNING)'!='true'">
-    <AssemblyOriginatorKeyFile>../../../../../LaunchDarkly.snk</AssemblyOriginatorKeyFile>
-    <SignAssembly>true</SignAssembly>
-  </PropertyGroup>
-
-  <PropertyGroup>
-    <IncludeSymbols>true</IncludeSymbols>
-    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
-  </PropertyGroup> 
-
-  <ItemGroup>
-    <!-- Open Telemetry Dependencies -->
-    <PackageReference Include="OpenTelemetry" Version="1.12.0" />
-    <PackageReference Include="OpenTelemetry.Exporter.Console" Version="1.12.0" />
-    <PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.12.0" />
-    <PackageReference Include="OpenTelemetry.Extensions.Hosting" Version="1.12.0" />
-    <PackageReference Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.12.0" />
-    <PackageReference Include="OpenTelemetry.Instrumentation.GrpcNetClient" Version="1.12.0-beta.1" />
-    <PackageReference Include="OpenTelemetry.Instrumentation.Http" Version="1.12.0" />
-    <PackageReference Include="OpenTelemetry.Instrumentation.Process" Version="1.12.0-beta.1" />
-    <PackageReference Include="OpenTelemetry.Instrumentation.Quartz" Version="1.12.0-beta.1" />
-    <PackageReference Include="OpenTelemetry.Instrumentation.Runtime" Version="1.12.0" />
-    <PackageReference Include="OpenTelemetry.Instrumentation.SqlClient" Version="1.12.0-beta.2" />
-    <PackageReference Include="OpenTelemetry.Instrumentation.Wcf" Version="1.12.0-beta.1" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <!-- LaunchDarkly Dependencies -->
-    <PackageReference Include="LaunchDarkly.ServerSdk" Version="[8.10.0,9.0.0)" />
-    <PackageReference Include="LaunchDarkly.ServerSdk.Telemetry" Version="[1.3.0,2.0.0)" />
-  </ItemGroup>
-  
-  <ItemGroup>
-    <!-- Temporary dependency until: https://github.com/open-telemetry/opentelemetry-dotnet/issues/5973 is resolved. -->
-    <PackageReference Include="System.Diagnostics.DiagnosticSource" Version="9.0.0" />
-  </ItemGroup>
-</Project>
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <!--x-release-please-start-version-->
+        <Version>0.1.0</Version>
+        <!--x-release-please-end-->
+        <Nullable>disable</Nullable>
+        <!-- The BUILDFRAMEWORKS variable allows us to override the target frameworks with a
+             single framework that we are testing; this allows us to test with older SDK
+             versions that would error out if they saw any newer target frameworks listed
+             here, even if we weren't running those. -->
+        <BuildFrameworks Condition="'$(BUILDFRAMEWORKS)' == ''">netstandard2.0;net471;net8.0</BuildFrameworks>
+        <TargetFrameworks>$(BUILDFRAMEWORKS)</TargetFrameworks>
+        <LangVersion>7.3</LangVersion>
+
+        <Description>LaunchDarkly Observability for Server-Side .NET SDK</Description>
+        <Authors>LaunchDarkly</Authors>
+        <Owners>LaunchDarkly</Owners>
+        <Company>LaunchDarkly</Company>
+        <Copyright>Copyright 2025 Catamorphic, Co</Copyright>
+        <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
+        <PackageProjectUrl>https://github.com/launchdarkly/observability-sdk</PackageProjectUrl>
+        <RepositoryUrl>https://github.com/launchdarkly/observability-sdk</RepositoryUrl>
+        <!-- To enable only specific source files. -->
+        <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+
+        <!-- fail if XML comments are missing or invalid -->
+        <WarningsAsErrors>1570,1571,1572,1573,1574,1580,1581,1584,1591,1710,1711,1712</WarningsAsErrors>
+    </PropertyGroup>
+
+    <!-- Allow the testing project to access internals. -->
+    <ItemGroup Condition="'$(Configuration)'!='Release'">
+        <InternalsVisibleTo Include="LaunchDarkly.Observability.Tests"/>
+        <!-- Dynamically generated assembly used by Moq. Required for mocking in unit tests. -->
+        <InternalsVisibleTo Include="DynamicProxyGenAssembly2"/>
+    </ItemGroup>
+
+    <PropertyGroup Condition="'$(Configuration)'=='Release' And '$(SKIP_SIGNING)'!='true'">
+        <AssemblyOriginatorKeyFile>../../../../../LaunchDarkly.snk</AssemblyOriginatorKeyFile>
+        <SignAssembly>true</SignAssembly>
+    </PropertyGroup>
+    
+    <!-- Common -->
+    <ItemGroup>
+        <Compile Include="**\*.cs" Exclude="Asp\**\*.cs;bin\**\*.cs;obj\**\*.cs"/>
+    </ItemGroup>
+    
+    <!-- Asp.Net non-core -->
+    <ItemGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'">
+        <Compile Include="Asp\Legacy\*.cs" />
+    </ItemGroup>
+    
+    <!-- Asp.Net Core -->
+    <ItemGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' != 'net'">
+        <Compile Include="Asp\Core\*.cs" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <!-- Common Open Telemetry Dependencies -->
+        <PackageReference Include="OpenTelemetry" Version="1.12.0"/>
+        <PackageReference Include="OpenTelemetry.Exporter.Console" Version="1.12.0"/>
+        <PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.12.0"/>
+        <PackageReference Include="OpenTelemetry.Extensions.Hosting" Version="1.12.0"/>
+        <PackageReference Include="OpenTelemetry.Instrumentation.GrpcNetClient" Version="1.12.0-beta.1"/>
+        <PackageReference Include="OpenTelemetry.Instrumentation.Http" Version="1.12.0"/>
+        <PackageReference Include="OpenTelemetry.Instrumentation.Process" Version="1.12.0-beta.1"/>
+        <PackageReference Include="OpenTelemetry.Instrumentation.Quartz" Version="1.12.0-beta.1"/>
+        <PackageReference Include="OpenTelemetry.Instrumentation.Runtime" Version="1.12.0"/>
+        <PackageReference Include="OpenTelemetry.Instrumentation.SqlClient" Version="1.12.0-beta.2"/>
+        <PackageReference Include="OpenTelemetry.Instrumentation.Wcf" Version="1.12.0-beta.1"/>
+    </ItemGroup>
+
+    <ItemGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'">
+        <!-- Open Telemetry Dependencies for .NET Framework, non-core ASP -->
+        <PackageReference Include="OpenTelemetry.Instrumentation.AspNet" Version="1.12.0-beta.1"/>
+    </ItemGroup>
+
+    <ItemGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' != 'net'">
+        <!-- Open Telemetry Dependencies - ASP.Net Core -->
+        <PackageReference Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.12.0"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <!-- LaunchDarkly Dependencies -->
+        <PackageReference Include="LaunchDarkly.ServerSdk" Version="[8.10.0,9.0.0)"/>
+        <PackageReference Include="LaunchDarkly.ServerSdk.Telemetry" Version="[1.3.0,2.0.0)"/>
+    </ItemGroup>
+  
+    <PropertyGroup>
+      <IncludeSymbols>true</IncludeSymbols>
+      <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+    </PropertyGroup> 
+
+    <ItemGroup>
+        <!-- Temporary dependency until: https://github.com/open-telemetry/opentelemetry-dotnet/issues/5973 is resolved. -->
+        <PackageReference Include="System.Diagnostics.DiagnosticSource" Version="9.0.0"/>
+    </ItemGroup>
+</Project>
diff --git a/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/ObservabilityConfig.cs b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/ObservabilityConfig.cs
index 3da379deb..16faee42a 100644
--- a/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/ObservabilityConfig.cs
+++ b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/ObservabilityConfig.cs
@@ -5,7 +5,13 @@
 
 namespace LaunchDarkly.Observability
 {
-    public struct ObservabilityConfig
+#if NETFRAMEWORK
+    using LoggerBuilderType = OpenTelemetryLoggerOptions;
+#else
+    using LoggerBuilderType = LoggerProviderBuilder;
+#endif
+
+    public class ObservabilityConfig
     {
         /// <summary>
         /// The configured OTLP endpoint.
@@ -52,7 +58,7 @@ public struct ObservabilityConfig
         /// <summary>
         /// Function which extends the configuration of the logger provider.
         /// </summary>
-        public Action<LoggerProviderBuilder> ExtendedLoggerConfiguration { get; }
+        public Action<LoggerBuilderType> ExtendedLoggerConfiguration { get; }
 
         /// <summary>
         /// Function which extends the configuration of the meter provider.
@@ -67,9 +73,9 @@ internal ObservabilityConfig(
             string serviceVersion,
             string sdkKey,
             Action<TracerProviderBuilder> extendedTracerConfiguration,
-            Action<LoggerProviderBuilder> extendedLoggerConfiguration,
+            Action<LoggerBuilderType> extendedLoggerConfiguration,
             Action<MeterProviderBuilder> extendedMeterConfiguration
-            )
+        )
         {
             OtlpEndpoint = otlpEndpoint;
             BackendUrl = backendUrl;
diff --git a/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/ObservabilityExtensions.cs b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/ObservabilityExtensions.cs
deleted file mode 100644
index a97b7dfd1..000000000
--- a/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/ObservabilityExtensions.cs
+++ /dev/null
@@ -1,186 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using LaunchDarkly.Observability.Otel;
-using LaunchDarkly.Logging;
-using LaunchDarkly.Observability.Logging;
-using LaunchDarkly.Observability.Sampling;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using OpenTelemetry;
-using OpenTelemetry.Resources;
-using OpenTelemetry.Trace;
-using OpenTelemetry.Exporter;
-using OpenTelemetry.Logs;
-using OpenTelemetry.Metrics;
-
-namespace LaunchDarkly.Observability
-{
-    /// <summary>
-    /// Static class containing extension methods for configuring observability
-    /// </summary>
-    public static class ObservabilityExtensions
-    {
-        private const OtlpExportProtocol ExportProtocol = OtlpExportProtocol.HttpProtobuf;
-        private const int FlushIntervalMs = 5 * 1000;
-        private const int MaxExportBatchSize = 10000;
-        private const int MaxQueueSize = 10000;
-        private const int ExportTimeoutMs = 30000;
-
-        private const string TracesPath = "/v1/traces";
-        private const string LogsPath = "/v1/logs";
-        private const string MetricsPath = "/v1/metrics";
-
-
-        private class LdObservabilityHostedService : IHostedService
-        {
-            private readonly ObservabilityConfig _config;
-            private readonly ILoggerProvider _loggerProvider;
-
-            public LdObservabilityHostedService(ObservabilityConfig config, IServiceProvider provider)
-            {
-                _loggerProvider = provider.GetService<ILoggerProvider>();
-                _config = config;
-            }
-
-            public Task StartAsync(CancellationToken cancellationToken)
-            {
-                Observe.Initialize(_config, _loggerProvider);
-                return Task.CompletedTask;
-            }
-
-            public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
-        }
-
-        private static async Task GetSamplingConfigAsync(CustomSampler sampler, ObservabilityConfig config)
-        {
-            using (var samplingClient = new SamplingConfigClient(config.BackendUrl))
-            {
-                try
-                {
-                    var res = await samplingClient.GetSamplingConfigAsync(config.SdkKey).ConfigureAwait(false);
-                    if (res == null) return;
-                    sampler.SetConfig(res);
-                }
-                catch (Exception ex)
-                {
-                    DebugLogger.DebugLog($"Exception while getting sampling config: {ex}");
-                }
-            }
-        }
-
-        private static IEnumerable<KeyValuePair<string, object>> GetResourceAttributes(ObservabilityConfig config)
-        {
-            var attrs = new List<KeyValuePair<string, object>>();
-
-            if (!string.IsNullOrWhiteSpace(config.Environment))
-            {
-                attrs.Add(
-                    new KeyValuePair<string, object>(AttributeNames.DeploymentEnvironment, config.Environment));
-            }
-
-            attrs.Add(new KeyValuePair<string, object>(AttributeNames.ProjectId, config.SdkKey));
-
-            return attrs;
-        }
-
-        internal static void AddLaunchDarklyObservabilityWithConfig(this IServiceCollection services,
-            ObservabilityConfig config, Logger logger = null)
-        {
-            DebugLogger.SetLogger(logger);
-            var resourceAttributes = GetResourceAttributes(config);
-
-            var sampler = new CustomSampler();
-
-            // Asynchronously get sampling config.
-            _ = Task.Run(() => GetSamplingConfigAsync(sampler, config));
-
-            var resourceBuilder = ResourceBuilder.CreateDefault();
-            if (!string.IsNullOrWhiteSpace(config.ServiceName))
-            {
-                resourceBuilder.AddService(config.ServiceName, serviceVersion: config.ServiceVersion);
-                resourceBuilder.AddAttributes(resourceAttributes);
-            }
-
-            services.AddOpenTelemetry().WithTracing(tracing =>
-            {
-                tracing.SetResourceBuilder(resourceBuilder)
-                    .AddHttpClientInstrumentation()
-                    .AddGrpcClientInstrumentation()
-                    .AddWcfInstrumentation()
-                    .AddQuartzInstrumentation()
-                    .AddAspNetCoreInstrumentation(options => { options.RecordException = true; })
-                    .AddSqlClientInstrumentation(options => { options.SetDbStatementForText = true; })
-                    .AddSource(DefaultNames.ActivitySourceNameOrDefault(config.ServiceName));
-
-                // Always use sampling exporter for traces
-                var samplingTraceExporter = new SamplingTraceExporter(sampler, new OtlpExporterOptions
-                {
-                    Endpoint = new Uri(config.OtlpEndpoint + TracesPath),
-                    Protocol = OtlpExportProtocol.HttpProtobuf,
-                });
-
-                tracing.AddProcessor(new BatchActivityExportProcessor(samplingTraceExporter, MaxQueueSize,
-                    FlushIntervalMs, ExportTimeoutMs, MaxExportBatchSize));
-                config.ExtendedTracerConfiguration?.Invoke(tracing);
-            }).WithLogging(logging =>
-            {
-                logging.SetResourceBuilder(resourceBuilder)
-                    .AddProcessor(new SamplingLogProcessor(sampler))
-                    .AddOtlpExporter(options =>
-                    {
-                        options.Endpoint = new Uri(config.OtlpEndpoint + LogsPath);
-                        options.Protocol = ExportProtocol;
-                        options.BatchExportProcessorOptions.MaxExportBatchSize = MaxExportBatchSize;
-                        options.BatchExportProcessorOptions.MaxQueueSize = MaxQueueSize;
-                        options.BatchExportProcessorOptions.ScheduledDelayMilliseconds = FlushIntervalMs;
-                    });
-                config.ExtendedLoggerConfiguration?.Invoke(logging);
-            }).WithMetrics(metrics =>
-            {
-                metrics.SetResourceBuilder(resourceBuilder)
-                    .AddMeter(DefaultNames.MeterNameOrDefault(config.ServiceName))
-                    .AddRuntimeInstrumentation()
-                    .AddProcessInstrumentation()
-                    .AddHttpClientInstrumentation()
-                    .AddAspNetCoreInstrumentation()
-                    .AddSqlClientInstrumentation()
-                    .AddReader(new PeriodicExportingMetricReader(new OtlpMetricExporter(new OtlpExporterOptions
-                    {
-                        Endpoint = new Uri(config.OtlpEndpoint + MetricsPath),
-                        Protocol = ExportProtocol
-                    })));
-                config.ExtendedMeterConfiguration?.Invoke(metrics);
-            });
-
-            // Attach a hosted service which will allow us to get a logger provider instance from the built
-            // service collection.
-            services.AddHostedService((serviceProvider) =>
-                new LdObservabilityHostedService(config, serviceProvider));
-        }
-
-        /// <summary>
-        /// Add the LaunchDarkly Observability services. This function would typically be called by the LaunchDarkly
-        /// Observability plugin. This should only be called by the end user if the Observability plugin needs to be
-        /// initialized earlier than the LaunchDarkly client.
-        /// </summary>
-        /// <param name="services">The service collection</param>
-        /// <param name="sdkKey">The LaunchDarkly SDK</param>
-        /// <param name="configure">A method to configure the services</param>
-        /// <returns>The service collection</returns>
-        public static IServiceCollection AddLaunchDarklyObservability(
-            this IServiceCollection services,
-            string sdkKey,
-            Action<ObservabilityConfig.ObservabilityConfigBuilder> configure)
-        {
-            var builder = ObservabilityConfig.Builder();
-            configure(builder);
-
-            var config = builder.Build(sdkKey);
-            AddLaunchDarklyObservabilityWithConfig(services, config);
-            return services;
-        }
-    }
-}
diff --git a/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Observe.cs b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Observe.cs
index 0f3e03f9b..5c1c7019c 100644
--- a/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Observe.cs
+++ b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Observe.cs
@@ -31,6 +31,7 @@ private class Instance
             public readonly ConcurrentDictionary<string, UpDownCounter<long>> UpDownCounters =
                 new ConcurrentDictionary<string, UpDownCounter<long>>();
 
+#if NETSTANDARD2_0 || NET5_0_OR_GREATER
             internal Instance(ObservabilityConfig config, ILoggerProvider loggerProvider)
             {
                 Meter = new Meter(DefaultNames.MeterNameOrDefault(config.ServiceName),
@@ -42,14 +43,32 @@ internal Instance(ObservabilityConfig config, ILoggerProvider loggerProvider)
                     Logger = loggerProvider.CreateLogger(DefaultNames.LoggerNameOrDefault(config.ServiceName));
                 }
             }
+#endif
+
+#if NETFRAMEWORK
+            internal Instance(ObservabilityConfig config, ILogger logger) {
+                Meter = new Meter(DefaultNames.MeterNameOrDefault(config.ServiceName), config.ServiceVersion);
+                ActivitySource = new ActivitySource(DefaultNames.ActivitySourceNameOrDefault(config.ServiceName), config.ServiceVersion);
+                Logger = logger;
+            }
+#endif
         }
 
         private static Instance _instance;
 
+#if NETSTANDARD2_0 || NET5_0_OR_GREATER
         internal static void Initialize(ObservabilityConfig config, ILoggerProvider loggerProvider)
         {
             Volatile.Write(ref _instance, new Instance(config, loggerProvider));
         }
+#endif
+
+#if NETFRAMEWORK
+        internal static void Initialize(ObservabilityConfig config, ILogger logger)
+        {
+            Volatile.Write(ref _instance, new Instance(config, logger));
+        }
+#endif
 
         private static Instance GetInstance()
         {
@@ -130,6 +149,16 @@ public static void RecordException(Exception exception, IDictionary<string, obje
             });
         }
 
+        /// <summary>
+        /// Record a metric gauge value.
+        /// <para>
+        /// Records a measurement value for a gauge metric with the specified name and optional attributes.
+        /// </para>
+        /// </summary>
+        /// <param name="name">the name of the metric</param>
+        /// <param name="value">the value to record</param>
+        /// <param name="attributes">any additional attributes to add to the metric</param>
+        /// <exception cref="ArgumentNullException">thrown when name is null</exception>
         public static void RecordMetric(string name, double value, IDictionary<string, object> attributes = null)
         {
             if (name == null) throw new ArgumentNullException(nameof(name), "Metric name cannot be null.");
@@ -149,6 +178,17 @@ public static void RecordMetric(string name, double value, IDictionary<string, o
             });
         }
 
+        /// <summary>
+        /// Record a counter value.
+        /// <para>
+        /// Records a count value for a counter metric with the specified name and optional attributes.
+        /// Counter values should be monotonically increasing.
+        /// </para>
+        /// </summary>
+        /// <param name="name">the name of the counter</param>
+        /// <param name="value">the value to add to the counter</param>
+        /// <param name="attributes">any additional attributes to add to the counter</param>
+        /// <exception cref="ArgumentNullException">thrown when name is null</exception>
         public static void RecordCount(string name, long value, IDictionary<string, object> attributes = null)
         {
             if (name == null) throw new ArgumentNullException(nameof(name), "Count name cannot be null.");
@@ -168,11 +208,30 @@ public static void RecordCount(string name, long value, IDictionary<string, obje
             });
         }
 
+        /// <summary>
+        /// Increment a counter by 1.
+        /// <para>
+        /// This is a convenience method equivalent to calling RecordCount with a value of 1.
+        /// </para>
+        /// </summary>
+        /// <param name="name">the name of the counter</param>
+        /// <param name="attributes">any additional attributes to add to the counter</param>
         public static void RecordIncr(string name, IDictionary<string, object> attributes = null)
         {
             RecordCount(name, 1, attributes);
         }
 
+        /// <summary>
+        /// Record a histogram value.
+        /// <para>
+        /// Records a measurement value for a histogram metric with the specified name and optional attributes.
+        /// Histograms are used to record distributions of values.
+        /// </para>
+        /// </summary>
+        /// <param name="name">the name of the histogram</param>
+        /// <param name="value">the value to record</param>
+        /// <param name="attributes">any additional attributes to add to the histogram</param>
+        /// <exception cref="ArgumentNullException">thrown when name is null</exception>
         public static void RecordHistogram(string name, double value, IDictionary<string, object> attributes = null)
         {
             if (name == null) throw new ArgumentNullException(nameof(name), "Histogram name cannot be null.");
@@ -193,6 +252,17 @@ public static void RecordHistogram(string name, double value, IDictionary<string
             });
         }
 
+        /// <summary>
+        /// Record an up-down counter value.
+        /// <para>
+        /// Records a delta value for an up-down counter metric with the specified name and optional attributes.
+        /// Up-down counters can increase or decrease and are useful for tracking values like queue size.
+        /// </para>
+        /// </summary>
+        /// <param name="name">the name of the up-down counter</param>
+        /// <param name="delta">the delta value to add (can be positive or negative)</param>
+        /// <param name="attributes">any additional attributes to add to the counter</param>
+        /// <exception cref="ArgumentNullException">thrown when name is null</exception>
         public static void RecordUpDownCounter(string name, long delta, IDictionary<string, object> attributes = null)
         {
             if (name == null) throw new ArgumentNullException(nameof(name), "UpDownCounter name cannot be null.");
@@ -214,6 +284,16 @@ public static void RecordUpDownCounter(string name, long delta, IDictionary<stri
             });
         }
 
+        /// <summary>
+        /// Record a log message.
+        /// <para>
+        /// Records a log message with the specified level and optional attributes using the configured logger.
+        /// If no logger is configured, the log message will be ignored.
+        /// </para>
+        /// </summary>
+        /// <param name="message">the log message</param>
+        /// <param name="level">the log level</param>
+        /// <param name="attributes">any additional attributes to add to the log entry</param>
         public static void RecordLog(string message, LogLevel level, IDictionary<string, object> attributes)
         {
             WithInstance(instance =>
@@ -228,6 +308,17 @@ public static void RecordLog(string message, LogLevel level, IDictionary<string,
             });
         }
 
+        /// <summary>
+        /// Start a new activity (span) with the specified name and kind.
+        /// <para>
+        /// Creates and starts a new activity using the configured ActivitySource. The activity
+        /// should be disposed when the operation is complete to properly end the span.
+        /// </para>
+        /// </summary>
+        /// <param name="name">the name of the activity</param>
+        /// <param name="kind">the kind of activity (defaults to Internal)</param>
+        /// <param name="attributes">any initial attributes to add to the activity</param>
+        /// <returns>the started activity, or null if the observability system is not initialized</returns>
         public static Activity StartActivity(string name, ActivityKind kind = ActivityKind.Internal,
             IDictionary<string, object> attributes = null)
         {
@@ -244,5 +335,19 @@ public static Activity StartActivity(string name, ActivityKind kind = ActivityKi
 
             return activity;
         }
+
+#if NETFRAMEWORK
+        /// <summary>
+        /// Shutdown LaunchDarkly Observability.
+        /// <para>
+        /// Properly shuts down the OpenTelemetry system and flushes any pending telemetry data.
+        /// This method is only available on .NET Framework.
+        /// </para>
+        /// </summary>
+        public static void Shutdown()
+        {
+            OpenTelemetry.Shutdown();
+        }
+#endif
     }
 }
diff --git a/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Otel/CommonOtelOptions.cs b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Otel/CommonOtelOptions.cs
new file mode 100644
index 000000000..3f765ada2
--- /dev/null
+++ b/sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Otel/CommonOtelOptions.cs
@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using LaunchDarkly.Observability.Logging;
+using LaunchDarkly.Observability.Sampling;
+using LaunchDarkly.Sdk.Internal.Concurrent;
+using OpenTelemetry;
+using OpenTelemetry.Exporter;
+using OpenTelemetry.Logs;
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Resources;
+using OpenTelemetry.Trace;
+
+namespace LaunchDarkly.Observability.Otel
+{
+    internal static class CommonOtelOptions
+    {
+        private const OtlpExportProtocol ExportProtocol = OtlpExportProtocol.HttpProtobuf;
+        private const int FlushIntervalMs = 5 * 1000;
+        private const int MaxExportBatchSize = 10000;
+        private const int MaxQueueSize = 10000;
+        private const int ExportTimeoutMs = 30000;
+
+        private const string TracesPath = "/v1/traces";
+        private const string LogsPath = "/v1/logs";
+        private const string MetricsPath = "/v1/metrics";
+
+        private static readonly ConcurrentDictionary<string, CustomSampler> Samplers =
+            new ConcurrentDictionary<string, CustomSampler>();
+
+        private static async Task GetSamplingConfigAsync(CustomSampler sampler, ObservabilityConfig config)
+        {
+            using (var samplingClient = new SamplingConfigClient(config.BackendUrl))
+            {
+                try
+                {
+                    var res = await samplingClient.GetSamplingConfigAsync(config.SdkKey).ConfigureAwait(false);
+                    if (res == null) return;
+                    sampler.SetConfig(res);
+                }
+                catch (Exception ex)
+                {
+                    DebugLogger.DebugLog($"Exception while getting sampling config: {ex}");
+                }
+            }
+        }
+
+        private static IEnumerable<KeyValuePair<string, object>> GetResourceAttributes(ObservabilityConfig config)
+        {
+            var attrs = new List<KeyValuePair<string, object>>();
+
+            if (!string.IsNullOrWhiteSpace(config.Environment))
+            {
+                attrs.Add(
+                    new KeyValuePair<string, object>(AttributeNames.DeploymentEnvironment, config.Environment));
+            }
+
+            attrs.Add(new KeyValuePair<string, object>(AttributeNames.ProjectId, config.SdkKey));
+
+            return attrs;
+        }
+
+        public static CustomSampler GetSampler(ObservabilityConfig config)
+        {
+            return Samplers.GetOrAdd(config.SdkKey, _ =>
+            {
+                var sampler = new CustomSampler();
+                Task.Run(() => GetSamplingConfigAsync(sampler, config));
+                return sampler;
+            });
+        }
+
+        public static ResourceBuilder GetResourceBuilder(ObservabilityConfig config)
+        {
+            var resourceBuilder = ResourceBuilder.CreateDefault();
+            if (string.IsNullOrWhiteSpace(config.ServiceName)) return resourceBuilder;
+            resourceBuilder.AddService(config.ServiceName, serviceVersion: config.ServiceVersion);
+            resourceBuilder.AddAttributes(GetResourceAttributes(config));
+            return resourceBuilder;
+        }
+
+
+        public static TracerProviderBuilder WithCommonLaunchDarklyConfig(this TracerProviderBuilder builder,
+            ObservabilityConfig config, ResourceBuilder resourceBuilder, CustomSampler sampler)
+        {
+            var samplingTraceExporter = new SamplingTraceExporter(sampler, new OtlpExporterOptions
+            {
+                Endpoint = new Uri(config.OtlpEndpoint + TracesPath),
+                Protocol = OtlpExportProtocol.HttpProtobuf,
+                BatchExportProcessorOptions =
+                {
+                    MaxExportBatchSize = MaxExportBatchSize,
+                    MaxQueueSize = MaxQueueSize,
+                    ScheduledDelayMilliseconds = FlushIntervalMs
+                }
+            });
+
+            builder.SetResourceBuilder(resourceBuilder)
+                .AddHttpClientInstrumentation()
+                .AddGrpcClientInstrumentation()
+                .AddWcfInstrumentation()
+                .AddQuartzInstrumentation()
+                .AddSqlClientInstrumentation(options => { options.SetDbStatementForText = true; })
+                .AddSource(DefaultNames.ActivitySourceNameOrDefault(config.ServiceName))
+                .AddProcessor(new BatchActivityExportProcessor(samplingTraceExporter, MaxQueueSize,
+                    FlushIntervalMs, ExportTimeoutMs, MaxExportBatchSize));
+
+            config.ExtendedTracerConfiguration?.Invoke(builder);
+            return builder;
+        }
+
+        public static MeterProviderBuilder WithCommonLaunchDarklyConfig(this MeterProviderBuilder builder,
+            ObservabilityConfig config, ResourceBuilder resourceBuilder)
+        {
+            builder.SetResourceBuilder(resourceBuilder)
+                .AddMeter(DefaultNames.MeterNameOrDefault(config.ServiceName))
+                .AddRuntimeInstrumentation()
+                .AddProcessInstrumentation()
+                .AddHttpClientInstrumentation()
+                .AddSqlClientInstrumentation()
+                .AddReader(new PeriodicExportingMetricReader(new OtlpMetricExporter(new OtlpExporterOptions
+                {
+                    Endpoint = new Uri(config.OtlpEndpoint + MetricsPath),
+                    Protocol = ExportProtocol
+                })));
+            config.ExtendedMeterConfiguration?.Invoke(builder);
+            return builder;
+        }
+
+        public static void WithCommonLaunchDarklyLoggingExport(this OtlpExporterOptions options,
+            ObservabilityConfig config)
+        {
+            options.Endpoint = new Uri(config.OtlpEndpoint + LogsPath);
+            options.Protocol = ExportProtocol;
+            options.BatchExportProcessorOptions.MaxExportBatchSize = MaxExportBatchSize;
+            options.BatchExportProcessorOptions.MaxQueueSize = MaxQueueSize;
+            options.BatchExportProcessorOptions.ScheduledDelayMilliseconds = FlushIntervalMs;
+        }
+    }
+}