prepare 6.3.0 release (#147)

Author: LaunchDarklyReleaseBot

src/LaunchDarkly.ServerSdk/Components.cs

@@ -311,6 +311,31 @@ public static PersistentDataStoreBuilder PersistentDataStore(IPersistentDataStor
         public static PollingDataSourceBuilder PollingDataSource() =>
             new PollingDataSourceBuilder();
 
+        /// <summary>
+        /// Returns a builder for configuring custom service URIs.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// Passing this to <see cref="ConfigurationBuilder.ServiceEndpoints(ServiceEndpointsBuilder)" />,
+        /// after setting any desired properties on the builder, applies this configuration to the SDK.
+        /// </para>
+        /// <para>
+        /// Most applications will never need to use this method. The main use case is when connecting
+        /// to a <a href="https://docs.launchdarkly.com/home/advanced/relay-proxy">LaunchDarkly
+        /// Relay Proxy</a> instance. For more information, see <see cref="ServiceEndpointsBuilder"/>.
+        /// </para>
+        /// </remarks>
+        /// <example>
+        /// <code>
+        ///     var config = Configuration.Builder(mobileKey)
+        ///         .ServiceEndpoints(Components.ServiceEndpoints().RelayProxy("http://my-relay-hostname:80"))
+        ///         .Build();
+        /// </code>
+        /// </example>
+        /// <returns>a configuration builder</returns>
+        /// <seealso cref="ConfigurationBuilder.ServiceEndpoints(ServiceEndpointsBuilder)" />
+        public static ServiceEndpointsBuilder ServiceEndpoints() => new ServiceEndpointsBuilder();
+
         /// <summary>
         /// Returns a configurable factory for using streaming mode to get feature flag data.
         /// </summary>

src/LaunchDarkly.ServerSdk/Configuration.cs

@@ -78,6 +78,11 @@ public class Configuration
         /// </summary>
         public string SdkKey { get; }
 
+        /// <summary>
+        /// Defines the base service URIs used by SDK components.
+        /// </summary>
+        public ServiceEndpoints ServiceEndpoints { get; }
+
         /// <summary>
         /// How long the client constructor will block awaiting a successful connection to
         /// LaunchDarkly.
@@ -160,6 +165,7 @@ internal Configuration(ConfigurationBuilder builder)
             LoggingConfigurationFactory = builder._loggingConfigurationFactory;
             Offline = builder._offline;
             SdkKey = builder._sdkKey;
+            ServiceEndpoints = (builder._serviceEndpointsBuilder ?? Components.ServiceEndpoints()).Build();
             StartWaitTime = builder._startWaitTime;
         }
 

src/LaunchDarkly.ServerSdk/ConfigurationBuilder.cs

@@ -39,6 +39,7 @@ public sealed class ConfigurationBuilder
         internal ILoggingConfigurationFactory _loggingConfigurationFactory = null;
         internal bool _offline = false;
         internal string _sdkKey;
+        internal ServiceEndpointsBuilder _serviceEndpointsBuilder = null;
         internal TimeSpan _startWaitTime = DefaultStartWaitTime;
 
         #endregion
@@ -61,6 +62,7 @@ internal ConfigurationBuilder(Configuration copyFrom)
             _loggingConfigurationFactory = copyFrom.LoggingConfigurationFactory;
             _offline = copyFrom.Offline;
             _sdkKey = copyFrom.SdkKey;
+            _serviceEndpointsBuilder = new ServiceEndpointsBuilder(copyFrom.ServiceEndpoints);
             _startWaitTime = copyFrom.StartWaitTime;
         }
 
@@ -292,6 +294,24 @@ public ConfigurationBuilder SdkKey(string sdkKey)
             return this;
         }
 
+        /// <summary>
+        /// Sets the SDK's service URIs, using a configuration builder obtained from
+        /// <see cref="Components.ServiceEndpoints"/>.
+        /// </summary>
+        /// <remarks>
+        /// This overwrites any previous options set with <see cref="ServiceEndpoints(ServiceEndpointsBuilder)"/>.
+        /// If you want to set multiple options, set them on the same <see cref="ServiceEndpointsBuilder"/>.
+        /// </remarks>
+        /// <param name="serviceEndpointsBuilder">the subconfiguration builder object</param>
+        /// <returns>the main configuration builder</returns>
+        /// <seealso cref="Components.ServiceEndpoints"/>
+        /// <seealso cref="ServiceEndpointsBuilder"/>
+        public ConfigurationBuilder ServiceEndpoints(ServiceEndpointsBuilder serviceEndpointsBuilder)
+        {
+            _serviceEndpointsBuilder = serviceEndpointsBuilder;
+            return this;
+        }
+
         /// <summary>
         /// Sets how long the client constructor will block awaiting a successful connection to
         /// LaunchDarkly.

src/LaunchDarkly.ServerSdk/Integrations/EventProcessorBuilder.cs

@@ -1,12 +1,15 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using LaunchDarkly.Logging;
 using LaunchDarkly.Sdk.Internal;
 using LaunchDarkly.Sdk.Internal.Events;
 using LaunchDarkly.Sdk.Server.Interfaces;
 using LaunchDarkly.Sdk.Server.Internal;
 using LaunchDarkly.Sdk.Server.Internal.Events;
 
+using static LaunchDarkly.Sdk.Internal.Events.DiagnosticConfigProperties;
+
 namespace LaunchDarkly.Sdk.Server.Integrations
 {
     /// <summary>
@@ -58,10 +61,8 @@ public sealed class EventProcessorBuilder : IEventProcessorFactory, IDiagnosticD
         /// </summary>
         public static readonly TimeSpan MinimumDiagnosticRecordingInterval = TimeSpan.FromMinutes(1);
 
-        internal static readonly Uri DefaultBaseUri = new Uri("https://events.launchdarkly.com");
-
         internal bool _allAttributesPrivate = false;
-        internal Uri _baseUri = DefaultBaseUri;
+        internal Uri _baseUri = null;
         internal int _capacity = DefaultCapacity;
         internal TimeSpan _diagnosticRecordingInterval = DefaultDiagnosticRecordingInterval;
         internal TimeSpan _flushInterval = DefaultFlushInterval;
@@ -88,10 +89,18 @@ public EventProcessorBuilder AllAttributesPrivate(bool allAttributesPrivate)
         }
 
         /// <summary>
-        /// Sets a custom base URI for the events service.
+        /// Deprecated method for setting a custom base URI for the events service.
         /// </summary>
         /// <remarks>
+        /// <para>
+        /// The preferred way to set this option is now with
+        /// <see cref="ConfigurationBuilder.ServiceEndpoints(ServiceEndpointsBuilder)"/>. If you set
+        /// this deprecated option, it overrides any value that was set with
+        /// <see cref="ConfigurationBuilder.ServiceEndpoints(ServiceEndpointsBuilder)"/>.
+        /// </para>
+        /// <para>
         /// You will only need to change this value in the following cases:
+        /// </para>
         /// <list type="bullet">
         /// <item><description>
         /// You are using the <a href="https://docs.launchdarkly.com/home/relay-proxy">Relay Proxy</a>.
@@ -104,9 +113,11 @@ public EventProcessorBuilder AllAttributesPrivate(bool allAttributesPrivate)
         /// </remarks>
         /// <param name="baseUri">the base URI of the events service; null to use the default</param>
         /// <returns>the builder</returns>
+        /// <seealso cref="ConfigurationBuilder.ServiceEndpoints(ServiceEndpointsBuilder)"/>
+        [Obsolete("Use ConfigurationBuilder.ServiceEndpoints instead")]
         public EventProcessorBuilder BaseUri(Uri baseUri)
         {
-            _baseUri = baseUri ?? DefaultBaseUri;
+            _baseUri = baseUri;
             return this;
         }
 
@@ -278,19 +289,7 @@ public EventProcessorBuilder UserKeysFlushInterval(TimeSpan userKeysFlushInterva
         /// <inheritdoc/>
         public IEventProcessor CreateEventProcessor(LdClientContext context)
         {
-            var eventsConfig = new EventsConfiguration
-            {
-                AllAttributesPrivate = _allAttributesPrivate,
-                DiagnosticRecordingInterval = _diagnosticRecordingInterval,
-                EventCapacity = _capacity,
-                EventFlushInterval = _flushInterval,
-                EventsUri = _baseUri.AddPath("bulk"),
-                DiagnosticUri = _baseUri.AddPath("diagnostic"),
-                InlineUsersInEvents = _inlineUsersInEvents,
-                PrivateAttributeNames = _privateAttributes.ToImmutableHashSet(),
-                UserKeysCapacity = _userKeysCapacity,
-                UserKeysFlushInterval = _userKeysFlushInterval
-            };
+            var eventsConfig = MakeEventsConfiguration(context.Basic, true);
             var logger = context.Basic.Logger.SubLogger(LogNames.EventsSubLog);
             var eventSender = _eventSender ??
                 new DefaultEventSender(
@@ -310,20 +309,35 @@ public IEventProcessor CreateEventProcessor(LdClientContext context)
                     ));
         }
 
-        /// <inheritdoc/>
-        public LdValue DescribeConfiguration(BasicConfiguration basic)
+        private EventsConfiguration MakeEventsConfiguration(BasicConfiguration basic, bool logConfigErrors)
         {
-            return LdValue.BuildObject()
-                .Add("allAttributesPrivate", _allAttributesPrivate)
-                .Add("customEventsURI", !_baseUri.Equals(DefaultBaseUri))
-                .Add("diagnosticRecordingIntervalMillis", _diagnosticRecordingInterval.TotalMilliseconds)
-                .Add("eventsCapacity", _capacity)
-                .Add("eventsFlushIntervalMillis", _flushInterval.TotalMilliseconds)
-                .Add("inlineUsersInEvents", _inlineUsersInEvents)
-                .Add("samplingInterval", 0) // no longer implemented
-                .Add("userKeysCapacity", _userKeysCapacity)
+            var configuredBaseUri = _baseUri ??
+                StandardEndpoints.SelectBaseUri(basic.ServiceEndpoints, e => e.EventsBaseUri, "Events",
+                    logConfigErrors ? basic.Logger : Logs.None.Logger(""));
+            return new EventsConfiguration
+            {
+                AllAttributesPrivate = _allAttributesPrivate,
+                DiagnosticRecordingInterval = _diagnosticRecordingInterval,
+                EventCapacity = _capacity,
+                EventFlushInterval = _flushInterval,
+                EventsUri = configuredBaseUri.AddPath("bulk"),
+                DiagnosticUri = configuredBaseUri.AddPath("diagnostic"),
+                InlineUsersInEvents = _inlineUsersInEvents,
+                PrivateAttributeNames = _privateAttributes.ToImmutableHashSet(),
+                UserKeysCapacity = _userKeysCapacity,
+                UserKeysFlushInterval = _userKeysFlushInterval
+            };
+        }
+
+        /// <inheritdoc/>
+        public LdValue DescribeConfiguration(BasicConfiguration basic) =>
+            LdValue.BuildObject()
+                .WithEventProperties(
+                    MakeEventsConfiguration(basic, false),
+                    StandardEndpoints.IsCustomUri(basic.ServiceEndpoints, _baseUri, e => e.EventsBaseUri)
+                )
+                .Add("userKeysCapacity", _userKeysCapacity) // these two properties are specific to the server-side SDK
                 .Add("userKeysFlushIntervalMillis", _userKeysFlushInterval.TotalMilliseconds)
                 .Build();
-        }
     }
 }

src/LaunchDarkly.ServerSdk/Integrations/HttpConfigurationBuilder.cs

@@ -6,6 +6,8 @@
 using LaunchDarkly.Sdk.Internal.Http;
 using LaunchDarkly.Sdk.Server.Interfaces;
 
+using static LaunchDarkly.Sdk.Internal.Events.DiagnosticConfigProperties;
+
 namespace LaunchDarkly.Sdk.Server.Integrations
 {
     /// <summary>
@@ -123,8 +125,15 @@ public HttpConfigurationBuilder MessageHandler(HttpMessageHandler messageHandler
         /// Sets an HTTP proxy for making connections to LaunchDarkly.
         /// </summary>
         /// <remarks>
+        /// <para>
         /// This is ignored if you have specified a custom message handler with <see cref="MessageHandler(HttpMessageHandler)"/>,
         /// since proxy behavior is implemented by the message handler.
+        /// </para>
+        /// <para>
+        /// Note that this is not the same as the <see href="https://docs.launchdarkly.com/home/relay-proxy">LaunchDarkly
+        /// Relay Proxy</see>, which would be set with
+        /// <see cref="ServiceEndpointsBuilder.RelayProxy(Uri)"/>.
+        /// </para>
         /// </remarks>
         /// <example>
         /// <code>
@@ -213,6 +222,16 @@ public HttpConfigurationBuilder Wrapper(string wrapperName, string wrapperVersio
 
         /// <inheritdoc/>
         public HttpConfiguration CreateHttpConfiguration(BasicConfiguration basicConfiguration)
+        {
+            var httpProperties = MakeHttpProperties(basicConfiguration);
+            return new HttpConfiguration(
+                httpProperties,
+                _messageHandler,
+                _responseStartTimeout
+                );
+        }
+
+        private HttpProperties MakeHttpProperties(BasicConfiguration basicConfiguration)
         {
             var httpProperties = HttpProperties.Default
                 .WithAuthorizationKey(basicConfiguration.SdkKey)
@@ -230,33 +249,13 @@ public HttpConfiguration CreateHttpConfiguration(BasicConfiguration basicConfigu
                 httpProperties = httpProperties.WithHeader(kv.Key, kv.Value);
             }
 
-            return new HttpConfiguration(
-                httpProperties,
-                _messageHandler,
-                _responseStartTimeout
-                );
+            return httpProperties;
         }
 
         /// <inheritdoc/>
         public LdValue DescribeConfiguration(BasicConfiguration basic) =>
             LdValue.BuildObject()
-                .Add("connectTimeoutMillis", _connectTimeout.TotalMilliseconds)
-                .Add("socketTimeoutMillis", _readTimeout.TotalMilliseconds)
-                .Add("usingProxy", DetectProxy())
-                .Add("usingProxyAuthenticator", DetectProxyAuth())
+                .WithHttpProperties(MakeHttpProperties(basic))
                 .Build();
-
-        // DetectProxy and DetectProxyAuth do not cover every mechanism that could be used to configure
-        // a proxy; for instance, there is HttpClient.DefaultProxy, which only exists in .NET Core 3.x and
-        // .NET 5.x. But since we're only trying to gather diagnostic stats, this doesn't have to be perfect.
-        private bool DetectProxy() =>
-            _proxy != null ||
-            !string.IsNullOrEmpty(System.Environment.GetEnvironmentVariable("HTTP_PROXY")) ||
-            !string.IsNullOrEmpty(System.Environment.GetEnvironmentVariable("HTTPS_PROXY")) ||
-            !string.IsNullOrEmpty(System.Environment.GetEnvironmentVariable("ALL_PROXY"));
-
-        private bool DetectProxyAuth() =>
-            _proxy is WebProxy wp &&
-            (wp.Credentials != null || wp.UseDefaultCredentials);
     }
 }

src/LaunchDarkly.ServerSdk/Integrations/PollingDataSourceBuilder.cs

@@ -1,7 +1,10 @@
 using System;
 using LaunchDarkly.Sdk.Server.Interfaces;
+using LaunchDarkly.Sdk.Server.Internal;
 using LaunchDarkly.Sdk.Server.Internal.DataSources;
 
+using static LaunchDarkly.Sdk.Internal.Events.DiagnosticConfigProperties;
+
 namespace LaunchDarkly.Sdk.Server.Integrations
 {
     /// <summary>
@@ -33,21 +36,27 @@ namespace LaunchDarkly.Sdk.Server.Integrations
     /// </example>
     public sealed class PollingDataSourceBuilder : IDataSourceFactory, IDiagnosticDescription
     {
-        internal static readonly Uri DefaultBaseUri = new Uri("https://sdk.launchdarkly.com");
-
         /// <summary>
         /// The default value for <see cref="PollInterval(TimeSpan)"/>: 30 seconds.
         /// </summary>
         public static readonly TimeSpan DefaultPollInterval = TimeSpan.FromSeconds(30);
 
-        internal Uri _baseUri = DefaultBaseUri;
+        internal Uri _baseUri = null;
         internal TimeSpan _pollInterval = DefaultPollInterval;
 
         /// <summary>
-        /// Sets a custom base URI for the polling service.
+        /// Deprecated method for setting a custom base URI for the polling service.
         /// </summary>
         /// <remarks>
+        /// <para>
+        /// The preferred way to set this option is now with
+        /// <see cref="ConfigurationBuilder.ServiceEndpoints(ServiceEndpointsBuilder)"/>. If you set
+        /// this deprecated option, it overrides any value that was set with
+        /// <see cref="ConfigurationBuilder.ServiceEndpoints(ServiceEndpointsBuilder)"/>.
+        /// </para>
+        /// <para>
         /// You will only need to change this value in the following cases:
+        /// </para>
         /// <list type="bullet">
         /// <item><description>
         /// You are using the <a href="https://docs.launchdarkly.com/home/relay-proxy">Relay Proxy</a>.
@@ -60,9 +69,11 @@ public sealed class PollingDataSourceBuilder : IDataSourceFactory, IDiagnosticDe
         /// </remarks>
         /// <param name="baseUri">the base URI of the polling service; null to use the default</param>
         /// <returns>the builder</returns>
+        /// <seealso cref="ConfigurationBuilder.ServiceEndpoints(ServiceEndpointsBuilder)"/>
+        [Obsolete("Use ConfigurationBuilder.ServiceEndpoints instead")]
         public PollingDataSourceBuilder BaseUri(Uri baseUri)
         {
-            _baseUri = baseUri ?? DefaultBaseUri;
+            _baseUri = baseUri;
             return this;
         }
 
@@ -93,8 +104,12 @@ internal PollingDataSourceBuilder PollIntervalNoMinimum(TimeSpan pollInterval)
         /// <inheritdoc/>
         public IDataSource CreateDataSource(LdClientContext context, IDataSourceUpdates dataSourceUpdates)
         {
+            var configuredBaseUri = _baseUri ??
+                StandardEndpoints.SelectBaseUri(context.Basic.ServiceEndpoints, e => e.PollingBaseUri, "Polling",
+                    context.Basic.Logger);
+
             context.Basic.Logger.Warn("You should only disable the streaming API if instructed to do so by LaunchDarkly support");
-            FeatureRequestor requestor = new FeatureRequestor(context, _baseUri ?? DefaultBaseUri);
+            FeatureRequestor requestor = new FeatureRequestor(context, configuredBaseUri);
             return new PollingProcessor(
                 context,
                 requestor,
@@ -104,16 +119,13 @@ public IDataSource CreateDataSource(LdClientContext context, IDataSourceUpdates
         }
 
         /// <inheritdoc/>
-        public LdValue DescribeConfiguration(BasicConfiguration basic)
-        {
-            return LdValue.BuildObject()
-                .Add("streamingDisabled", true)
-                .Add("customBaseURI",
-                    !(_baseUri ?? DefaultBaseUri).Equals(DefaultBaseUri))
-                .Add("customStreamURI", false)
-                .Add("pollingIntervalMillis", _pollInterval.TotalMilliseconds)
-                .Add("usingRelayDaemon", false)
+        public LdValue DescribeConfiguration(BasicConfiguration basic) =>
+            LdValue.BuildObject()
+                .WithPollingProperties(
+                    StandardEndpoints.IsCustomUri(basic.ServiceEndpoints, _baseUri, e => e.StreamingBaseUri),
+                    _pollInterval
+                )
+                .Add("usingRelayDaemon", false) // this property is specific to the server-side SDK
                 .Build();
-        }
     }
 }