feat: Add support for environment variable configuration. (#205)

## Summary

Add support for common OTEL environment variables.

The underlying OTEL libraries support most variables, but our default
configuration would interfere with these specific ones without explicit
support.

## How did you test this change?

<!--
Frontend - Leave a screencast or a screenshot to visually describe the
changes.
-->

## Are there any deployment considerations?

<!--
 Backend - Do we need to consider migrations or backfilling data?
-->

Author: kinyoklion

sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/BaseBuilder.cs

@@ -23,8 +23,8 @@ public class BaseBuilder<TBuilder> where TBuilder : BaseBuilder<TBuilder>
     {
         private const string DefaultOtlpEndpoint = "https://otel.observability.app.launchdarkly.com:4318";
         private const string DefaultBackendUrl = "https://pub.observability.app.launchdarkly.com";
-        private string _otlpEndpoint = DefaultOtlpEndpoint;
-        private string _backendUrl = DefaultBackendUrl;
+        private string _otlpEndpoint = string.Empty;
+        private string _backendUrl = string.Empty;
         private string _serviceName = string.Empty;
         private string _environment = string.Empty;
         private string _serviceVersion = string.Empty;
@@ -42,14 +42,19 @@ protected BaseBuilder()
         /// For most configurations, the OTLP endpoint will not need to be set.
         /// </para>
         /// <para>
+        /// If not explicitly set, set to null, or set to whitespace/empty string, the OTLP endpoint will be read from
+        /// the OTEL_EXPORTER_OTLP_ENDPOINT environment variable. Values set with this method take precedence over the
+        /// environment variable.
+        /// </para>
+        /// <para>
         /// Setting the endpoint to null will reset the builder value to the default.
         /// </para>
         /// </summary>
         /// <param name="otlpEndpoint">The OTLP exporter endpoint URL.</param>
         /// <returns>A reference to this builder.</returns>
         public TBuilder WithOtlpEndpoint(string otlpEndpoint)
         {
-            _otlpEndpoint = otlpEndpoint ?? DefaultOtlpEndpoint;
+            _otlpEndpoint = otlpEndpoint;
             return (TBuilder)this;
         }
 
@@ -66,12 +71,17 @@ public TBuilder WithOtlpEndpoint(string otlpEndpoint)
         /// <returns>A reference to this builder.</returns>
         public TBuilder WithBackendUrl(string backendUrl)
         {
-            _backendUrl = backendUrl ?? DefaultBackendUrl;
+            _backendUrl = backendUrl;
             return (TBuilder)this;
         }
 
         /// <summary>
         /// Set the service name.
+        /// <para>
+        /// If not explicitly set, set to null, or set to whitespace/empty string, the service name will be read from
+        /// the OTEL_SERVICE_NAME environment variable. Values set with this method take precedence over the environment
+        /// variable.
+        /// </para>
         /// </summary>
         /// <param name="serviceName">The logical service name used in telemetry resource attributes.</param>
         /// <returns>A reference to this builder.</returns>
@@ -234,10 +244,22 @@ internal ObservabilityConfig BuildConfig(string sdkKey)
                     "SDK key cannot be null when creating an ObservabilityConfig builder.");
             }
 
-            return new ObservabilityConfig(
-                _otlpEndpoint,
-                _backendUrl,
+            var effectiveServiceName = EnvironmentHelper.GetValueOrEnvironment(
                 _serviceName,
+                EnvironmentVariables.OtelServiceName,
+                string.Empty);
+
+            var effectiveOtlpEndpoint = EnvironmentHelper.GetValueOrEnvironment(
+                _otlpEndpoint,
+                EnvironmentVariables.OtelExporterOtlpEndpoint,
+                DefaultOtlpEndpoint);
+
+            var effectiveBackendUrl = string.IsNullOrWhiteSpace(_backendUrl) ? DefaultBackendUrl : _backendUrl;
+
+            return new ObservabilityConfig(
+                effectiveOtlpEndpoint,
+                effectiveBackendUrl,
+                effectiveServiceName,
                 _environment,
                 _serviceVersion,
                 sdkKey,

sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/EnvironmentHelper.cs

@@ -0,0 +1,29 @@
+using System;
+
+namespace LaunchDarkly.Observability
+{
+    /// <summary>
+    /// Helper methods for working with environment variables.
+    /// </summary>
+    internal static class EnvironmentHelper
+    {
+        /// <summary>
+        /// Returns the provided value if it's not null or empty, otherwise attempts to get the value from the specified environment variable.
+        /// If the environment variable is also not set, returns the default value.
+        /// </summary>
+        /// <param name="value">The primary value to use.</param>
+        /// <param name="environmentVariable">The name of the environment variable to check if the primary value is null or empty.</param>
+        /// <param name="defaultValue">The default value to use if both the primary value and environment variable are not set.</param>
+        /// <returns>The resolved value based on the precedence: primary value > environment variable > default value.</returns>
+        public static string GetValueOrEnvironment(string value, string environmentVariable, string defaultValue = "")
+        {
+            if (!string.IsNullOrWhiteSpace(value))
+            {
+                return value;
+            }
+
+            var envValue = Environment.GetEnvironmentVariable(environmentVariable);
+            return !string.IsNullOrWhiteSpace(envValue) ? envValue : defaultValue;
+        }
+    }
+}

sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/EnvironmentVariables.cs

@@ -0,0 +1,20 @@
+namespace LaunchDarkly.Observability
+{
+    /// <summary>
+    /// Contains constants for environment variable names used by the Observability SDK.
+    /// </summary>
+    internal static class EnvironmentVariables
+    {
+        /// <summary>
+        /// The OpenTelemetry standard environment variable for the service name.
+        /// When not explicitly set via WithServiceName(), this environment variable will be used.
+        /// </summary>
+        public const string OtelServiceName = "OTEL_SERVICE_NAME";
+
+        /// <summary>
+        /// The OpenTelemetry standard environment variable for the OTLP exporter endpoint.
+        /// When not explicitly set via WithOtlpEndpoint(), this environment variable will be used.
+        /// </summary>
+        public const string OtelExporterOtlpEndpoint = "OTEL_EXPORTER_OTLP_ENDPOINT";
+    }
+}

sdk/@launchdarkly/observability-dotnet/test/LaunchDarkly.Observability.Tests/ObservabilityConfigBuilderTests.cs

@@ -1,5 +1,4 @@
 using System;
-using LaunchDarkly.Observability;
 using NUnit.Framework;
 using OpenTelemetry.Logs;
 using OpenTelemetry.Metrics;
@@ -10,6 +9,13 @@ namespace LaunchDarkly.Observability.Test
     [TestFixture]
     public class ObservabilityConfigBuilderTests
     {
+        [SetUp]
+        public void SetUp()
+        {
+            Environment.SetEnvironmentVariable(EnvironmentVariables.OtelExporterOtlpEndpoint, null);
+            Environment.SetEnvironmentVariable(EnvironmentVariables.OtelServiceName, null);
+        }
+
         [Test]
         public void Build_WithAllFields_SetsValues()
         {
@@ -256,5 +262,111 @@ public void WithExtendedConfigurations_NullActionsAreAccepted()
                 Assert.That(config.ExtendedMeterConfiguration, Is.Null);
             });
         }
+
+        [Test]
+        public void Build_UsesOtelServiceNameEnvironmentVariable_WhenServiceNameNotSet()
+        {
+            Environment.SetEnvironmentVariable(EnvironmentVariables.OtelServiceName, "service-from-env");
+
+            // Build config without setting service name explicitly
+            var config = ObservabilityConfig.Builder().Build("sdk-key");
+
+            // Should use the environment variable value
+            Assert.That(config.ServiceName, Is.EqualTo("service-from-env"));
+        }
+
+        [Test]
+        public void Build_PrefersExplicitServiceName_OverEnvironmentVariable()
+        {
+            Environment.SetEnvironmentVariable(EnvironmentVariables.OtelServiceName, "service-from-env");
+
+            // Build config with explicit service name
+            var config = ObservabilityConfig.Builder()
+                .WithServiceName("explicit-service")
+                .Build("sdk-key");
+
+            // Should use the explicitly set value, not the environment variable
+            Assert.That(config.ServiceName, Is.EqualTo("explicit-service"));
+        }
+
+        [Test]
+        public void Build_HandlesAbsentOtelServiceNameEnvironmentVariable()
+        {
+            Environment.SetEnvironmentVariable(EnvironmentVariables.OtelServiceName, null);
+
+            // Build config without setting service name
+            var config = ObservabilityConfig.Builder().Build("sdk-key");
+
+            // Should use empty string as default
+            Assert.That(config.ServiceName, Is.EqualTo(string.Empty));
+        }
+
+        [Test]
+        public void Build_WithServiceNameSetToNull_UsesEnvironmentVariable()
+        {
+            Environment.SetEnvironmentVariable(EnvironmentVariables.OtelServiceName, "service-from-env");
+
+            // Build config with service name explicitly set to null (which becomes empty string in WithServiceName)
+            var config = ObservabilityConfig.Builder()
+                .WithServiceName(null)
+                .Build("sdk-key");
+
+            // Should use the environment variable since WithServiceName(null) sets it to empty string
+            Assert.That(config.ServiceName, Is.EqualTo("service-from-env"));
+        }
+
+        [Test]
+        public void Build_UsesOtelExporterOtlpEndpointEnvironmentVariable_WhenOtlpEndpointNotSet()
+        {
+            Environment.SetEnvironmentVariable(EnvironmentVariables.OtelExporterOtlpEndpoint,
+                "https://custom-otlp.example.com:4318");
+
+            // Build config without setting OTLP endpoint explicitly
+            var config = ObservabilityConfig.Builder().Build("sdk-key");
+
+            // Should use the environment variable value
+            Assert.That(config.OtlpEndpoint, Is.EqualTo("https://custom-otlp.example.com:4318"));
+        }
+
+        [Test]
+        public void Build_PrefersExplicitOtlpEndpoint_OverEnvironmentVariable()
+        {
+            Environment.SetEnvironmentVariable(EnvironmentVariables.OtelExporterOtlpEndpoint,
+                "https://env-otlp.example.com:4318");
+
+            // Build config with explicit OTLP endpoint
+            var config = ObservabilityConfig.Builder()
+                .WithOtlpEndpoint("https://explicit-otlp.example.com:4318")
+                .Build("sdk-key");
+
+            // Should use the explicitly set value, not the environment variable
+            Assert.That(config.OtlpEndpoint, Is.EqualTo("https://explicit-otlp.example.com:4318"));
+        }
+
+        [Test]
+        public void Build_HandlesAbsentOtelExporterOtlpEndpointEnvironmentVariable()
+        {
+            // Clear the environment variable
+            Environment.SetEnvironmentVariable(EnvironmentVariables.OtelExporterOtlpEndpoint, null);
+
+            // Build config without setting OTLP endpoint
+            var config = ObservabilityConfig.Builder().Build("sdk-key");
+
+            // Should use default OTLP endpoint
+            Assert.That(config.OtlpEndpoint, Is.EqualTo("https://otel.observability.app.launchdarkly.com:4318"));
+        }
+
+        [Test]
+        public void Build_WithOtlpEndpointSetToNull_UsesEnvironmentVariableIfSet()
+        {
+            Environment.SetEnvironmentVariable(EnvironmentVariables.OtelExporterOtlpEndpoint,
+                "https://env-otlp.example.com:4318");
+
+            var config = ObservabilityConfig.Builder()
+                .WithOtlpEndpoint(null)
+                .Build("sdk-key");
+
+            Assert.That(config.OtlpEndpoint, Is.EqualTo("https://env-otlp.example.com:4318"));
+        }
     }
 }

sdk/@launchdarkly/observability-dotnet/test/LaunchDarkly.Observability.Tests/ObservabilityPluginBuilderTests.cs

@@ -65,5 +65,55 @@ public void Build_WithNullValues_HandlesNullsCorrectly()
 
             Assert.That(plugin, Is.InstanceOf<ObservabilityPlugin>());
         }
+
+        [Test]
+        public void Build_UsesOtelServiceNameEnvironmentVariable_WhenServiceNameNotSet()
+        {
+            // Save the original environment variable value
+            var originalValue = Environment.GetEnvironmentVariable(EnvironmentVariables.OtelServiceName);
+
+            try
+            {
+                // Set the environment variable
+                Environment.SetEnvironmentVariable(EnvironmentVariables.OtelServiceName, "plugin-service-from-env");
+
+                // Build plugin without setting service name explicitly
+                var plugin = ObservabilityPlugin.Builder(_services).Build();
+
+                // Plugin should be created successfully and will use the env var internally
+                Assert.That(plugin, Is.InstanceOf<ObservabilityPlugin>());
+            }
+            finally
+            {
+                // Restore the original environment variable value
+                Environment.SetEnvironmentVariable(EnvironmentVariables.OtelServiceName, originalValue);
+            }
+        }
+
+        [Test]
+        public void Build_PrefersExplicitServiceName_OverEnvironmentVariable()
+        {
+            // Save the original environment variable value
+            var originalValue = Environment.GetEnvironmentVariable(EnvironmentVariables.OtelServiceName);
+
+            try
+            {
+                // Set the environment variable
+                Environment.SetEnvironmentVariable(EnvironmentVariables.OtelServiceName, "plugin-service-from-env");
+
+                // Build plugin with explicit service name
+                var plugin = ObservabilityPlugin.Builder(_services)
+                    .WithServiceName("explicit-plugin-service")
+                    .Build();
+
+                // Plugin should be created successfully and will use the explicit value internally
+                Assert.That(plugin, Is.InstanceOf<ObservabilityPlugin>());
+            }
+            finally
+            {
+                // Restore the original environment variable value
+                Environment.SetEnvironmentVariable(EnvironmentVariables.OtelServiceName, originalValue);
+            }
+        }
     }
 }