/// <inheritdoc/> public IBigSegmentStore CreateBigSegmentStore(LdClientContext context) => new DynamoDBBigSegmentStoreImpl( MakeClient(), _existingClient != null, _tableName, _prefix, context.Basic.Logger.SubLogger("BigSegments.DynamoDB") );
/// <inheritdoc/> public IPersistentDataStoreAsync CreatePersistentDataStore(LdClientContext context) => new DynamoDBDataStoreImpl( MakeClient(), _existingClient != null, _tableName, _prefix, context.Basic.Logger.SubLogger("DataStore.DynamoDB") );
/// <inheritdoc/> public LdValue DescribeConfiguration(LdClientContext context) => LdValue.BuildObject() .WithHttpProperties(MakeHttpProperties(context.Basic)) .Add("useReport", _useReport) .Set("socketTimeoutMillis", _responseStartTimeout.TotalMilliseconds) // WithHttpProperties normally sets socketTimeoutMillis to the ReadTimeout value, // which is more correct, but we can't really set ReadTimeout in this SDK .Build();
public IDataSource CreateDataSource(LdClientContext context, IDataSourceUpdates updateSink) { if (Instance is MockDataSourceBase m) { m.UpdateSink = updateSink; } return(Instance); }
/// <inheritdoc/> public LdValue DescribeConfiguration(LdClientContext context) => LdValue.BuildObject() .WithPollingProperties( StandardEndpoints.IsCustomUri(context.ServiceEndpoints, e => e.PollingBaseUri), _pollInterval ) .Add("backgroundPollingIntervalMillis", _backgroundPollInterval.TotalMilliseconds) .Build();
internal FeatureRequestor(LdClientContext context, Uri baseUri) { _httpProperties = context.Http.HttpProperties; _httpClient = context.Http.NewHttpClient(); _connectTimeout = context.Http.ConnectTimeout; _allUri = baseUri.AddPath(StandardEndpoints.PollingRequestPath); _log = context.Basic.Logger.SubLogger(LogNames.DataSourceSubLog); }
internal void SetContext(LdClientContext context) { // This is done as a separate step, called from the LdClient constructor, because // the DiagnosticStore object has to be created before the LdClientContext - since // the LdClientContext includes a reference to the DiagnosticStore (for components // like StreamingDataSource to use). _context = context; }
/// <summary> /// Called internally by the SDK to associate this test data source with an /// <see cref="LdClient"/> instance. You do not need to call this method. /// </summary> /// <param name="context">created internally by <c>LdClient</c></param> /// <param name="dataSourceUpdates">created internally by <c>LdClient</c></param> /// <returns>a data source instance</returns> public IDataSource CreateDataSource(LdClientContext context, IDataSourceUpdates dataSourceUpdates) { var instance = new DataSourceImpl(this, dataSourceUpdates, context.Basic.Logger.SubLogger("DataSource.TestData")); lock (_lock) { _instances.Add(instance); } return(instance); }
/// <inheritdoc/> public IDataSource CreateDataSource(LdClientContext context, IDataSourceUpdates dataSourceUpdates) { return(new StreamProcessor( context, dataSourceUpdates, _baseUri ?? DefaultBaseUri, _initialReconnectDelay, _eventSourceCreator )); }
internal FeatureRequestor(LdClientContext context, Uri baseUri) { _httpProperties = context.Http.HttpProperties; _httpClient = context.Http.NewHttpClient(); _connectTimeout = context.Http.ConnectTimeout; _allUri = new Uri(baseUri.AbsoluteUri + "sdk/latest-all"); _flagsUri = new Uri(baseUri.AbsoluteUri + "sdk/latest-flags/"); _segmentsUri = new Uri(baseUri.AbsoluteUri + "sdk/latest-segments/"); _log = context.Basic.Logger.SubLogger(LogNames.DataSourceSubLog); }
private IDataSource MakeDataSourceWithDiagnostics(Uri baseUri, User user, IDiagnosticStore diagnosticStore) { var config = BasicConfig() .ServiceEndpoints(Components.ServiceEndpoints().Streaming(baseUri).Polling(baseUri)) .Build(); var context = new LdClientContext(config, null, diagnosticStore, null); return(Components.StreamingDataSource().InitialReconnectDelay(BriefReconnectDelay) .CreateDataSource(context, _updateSink, user, false)); }
/// <inheritdoc/> public BigSegmentsConfiguration CreateBigSegmentsConfiguration(LdClientContext context) { var store = _storeFactory is null ? null : _storeFactory.CreateBigSegmentStore(context); return(new BigSegmentsConfiguration( store, _userCacheSize, _userCacheTime, _statusPollInterval, _staleAfter )); }
/// <inheritdoc/> public IDataSource CreateDataSource(LdClientContext context, IDataSourceUpdates dataSourceUpdates) { 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); return(new PollingProcessor( context, requestor, dataSourceUpdates, _pollInterval )); }
public PollingProcessorTest(ITestOutputHelper testOutput) : base(testOutput) { _mockFeatureRequestor = new Mock <IFeatureRequestor>(); _featureRequestor = _mockFeatureRequestor.Object; _dataStore = new InMemoryDataStore(); var dataSourceUpdatesImpl = TestUtils.BasicDataSourceUpdates(_dataStore, testLogger); _dataSourceUpdates = dataSourceUpdatesImpl; _dataSourceStatusProvider = new DataSourceStatusProviderImpl(dataSourceUpdatesImpl); _config = Configuration.Default(sdkKey); _context = new LdClientContext(new BasicConfiguration(sdkKey, false, testLogger), _config); }
/// <inheritdoc/> public IDataSource CreateDataSource(LdClientContext context, IDataSourceUpdates dataSourceUpdates) { var configuredBaseUri = _baseUri ?? StandardEndpoints.SelectBaseUri(context.Basic.ServiceEndpoints, e => e.StreamingBaseUri, "Streaming", context.Basic.Logger); return(new StreamProcessor( context, dataSourceUpdates, configuredBaseUri, _initialReconnectDelay, _eventSourceCreator )); }
internal PollingProcessor( LdClientContext context, IFeatureRequestor featureRequestor, IDataSourceUpdates dataSourceUpdates, TimeSpan pollInterval ) { _featureRequestor = featureRequestor; _dataSourceUpdates = dataSourceUpdates; _taskExecutor = context.TaskExecutor; _pollInterval = pollInterval; _initTask = new TaskCompletionSource <bool>(); _log = context.Basic.Logger.SubLogger(LogNames.DataSourceSubLog); }
public IDataSource CreateDataSource(LdClientContext context, IDataSourceUpdates dataSourceUpdates) { if (context.Basic.Offline) { // If they have explicitly called Offline(true) to disable everything, we'll log this slightly // more specific message. context.Basic.Logger.Info("Starting LaunchDarkly client in offline mode"); } else { context.Basic.Logger.Info("LaunchDarkly client will not connect to LaunchDarkly for feature flag data"); } return(NullDataSource.Instance); }
/// <inheritdoc/> public IDataSource CreateDataSource( LdClientContext context, IDataSourceUpdateSink updateSink, User currentUser, bool inBackground ) { var baseUri = StandardEndpoints.SelectBaseUri( context.ServiceEndpoints, e => e.StreamingBaseUri, "Streaming", context.BaseLogger ); var pollingBaseUri = StandardEndpoints.SelectBaseUri( context.ServiceEndpoints, e => e.PollingBaseUri, "Polling", context.BaseLogger ); if (inBackground) { // When in the background, always use polling instead of streaming return(new PollingDataSourceBuilder() .BackgroundPollInterval(_backgroundPollInterval) .CreateDataSource(context, updateSink, currentUser, true)); } var logger = context.BaseLogger.SubLogger(LogNames.DataSourceSubLog); var requestor = new FeatureFlagRequestor( pollingBaseUri, currentUser, context.EvaluationReasons, context.Http, logger ); return(new StreamingDataSource( updateSink, currentUser, baseUri, context.EvaluationReasons, _initialReconnectDelay, requestor, context.Http, logger, context.DiagnosticStore )); }
private IDisposable CreateStoreImpl(string prefix = null) { var context = new LdClientContext(new BasicConfiguration("sdk-key", false, Logs.None.Logger("")), LaunchDarkly.Sdk.Server.Configuration.Default("sdk-key")); if (Configuration.StoreFactoryFunc != null) { return(Configuration.StoreFactoryFunc(prefix).CreatePersistentDataStore(context)); } if (Configuration.StoreAsyncFactoryFunc != null) { return(Configuration.StoreAsyncFactoryFunc(prefix).CreatePersistentDataStore(context)); } throw new InvalidOperationException("neither StoreFactoryFunc nor StoreAsyncFactoryFunc was set"); }
/// <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, configuredBaseUri); return(new PollingProcessor( context, requestor, dataSourceUpdates, _pollInterval )); }
public void LogMessageAtStartup() { var logCapture = Logs.Capture(); var logger = logCapture.Logger("BaseLoggerName"); // in real life, the SDK will provide its own base log name var context = new LdClientContext(new BasicConfiguration("", false, logger), LaunchDarkly.Sdk.Server.Configuration.Default("")); using (BaseBuilder().Prefix("my-prefix").CreatePersistentDataStore(context)) { Assert.Collection(logCapture.GetMessages(), m => { Assert.Equal(LaunchDarkly.Logging.LogLevel.Info, m.Level); Assert.Equal("BaseLoggerName.DataStore.DynamoDB", m.LoggerName); Assert.Equal("Using DynamoDB data store with table name \"" + TableName + "\" and prefix \"my-prefix\"", m.Text); }); } }
public void LogMessageAtStartup() { var logCapture = Logs.Capture(); var logger = logCapture.Logger("BaseLoggerName"); // in real life, the SDK will provide its own base log name var context = new LdClientContext(new BasicConfiguration("", false, logger), LaunchDarkly.Sdk.Server.Configuration.Default("")); using (Consul.DataStore().Address("http://localhost:8500").Prefix("my-prefix") .CreatePersistentDataStore(context)) { Assert.Collection(logCapture.GetMessages(), m => { Assert.Equal(LaunchDarkly.Logging.LogLevel.Info, m.Level); Assert.Equal("BaseLoggerName.DataStore.Consul", m.LoggerName); Assert.Equal("Using Consul data store at http://localhost:8500/ with prefix \"my-prefix\"", m.Text); }); } }
internal ConnectionManager( LdClientContext clientContext, IDataSourceFactory dataSourceFactory, IDataSourceUpdateSink updateSink, IEventProcessor eventProcessor, DiagnosticDisablerImpl diagnosticDisabler, bool enableBackgroundUpdating, User initialUser, Logger log ) { _clientContext = clientContext; _dataSourceFactory = dataSourceFactory; _updateSink = updateSink; _eventProcessor = eventProcessor; _diagnosticDisabler = diagnosticDisabler; _enableBackgroundUpdating = enableBackgroundUpdating; _user = initialUser; _log = log; }
/// <inheritdoc/> public IDataSource CreateDataSource( LdClientContext context, IDataSourceUpdateSink updateSink, User currentUser, bool inBackground ) { var instance = new DataSourceImpl( this, updateSink, currentUser, context.BaseLogger.SubLogger("DataSource.TestData") ); lock (_lock) { _instances.Add(instance); } return(instance); }
/// <inheritdoc/> public IEventProcessor CreateEventProcessor(LdClientContext context) { var eventsConfig = MakeEventsConfiguration(context.Basic, true); var logger = context.Basic.Logger.SubLogger(LogNames.EventsSubLog); var eventSender = _eventSender ?? new DefaultEventSender( context.Http.HttpProperties, eventsConfig, logger ); return(new DefaultEventProcessorWrapper( new EventProcessor( eventsConfig, eventSender, new DefaultUserDeduplicator(_userKeysCapacity, _userKeysFlushInterval), context.DiagnosticStore, null, logger, null ))); }
public void StreamInitDiagnosticRecordedOnError() { var mockDiagnosticStore = new Mock <IDiagnosticStore>(); var diagnosticStore = mockDiagnosticStore.Object; var context = new LdClientContext(BasicContext.Basic, Components.HttpConfiguration().CreateHttpConfiguration(BasicContext.Basic), diagnosticStore, BasicTaskExecutor); using (var sp = (StreamProcessor)Components.StreamingDataSource().EventSourceCreator(_eventSourceFactory.Create()) .CreateDataSource(context, _dataSourceUpdates)) { sp.Start(); Assert.True(_esStartedReady.WaitOne(TimeSpan.FromSeconds(1))); DateTime esStarted = sp._esStarted; Thread.Sleep(TimeSpan.FromMilliseconds(100)); SimulateStreamHttpError(401); DateTime startFailed = sp._esStarted; Assert.True(esStarted != startFailed); mockDiagnosticStore.Verify(ds => ds.AddStreamInit(esStarted, It.Is <TimeSpan>(ts => TimeSpan.Equals(ts, startFailed - esStarted)), true)); } }
public void StreamInitDiagnosticRecordedOnOpen() { var mockDiagnosticStore = new Mock <IDiagnosticStore>(); var diagnosticStore = mockDiagnosticStore.Object; var basicConfig = new BasicConfiguration(SDK_KEY, false, testLogger); var context = new LdClientContext(basicConfig, Components.HttpConfiguration().CreateHttpConfiguration(basicConfig), diagnosticStore, new TaskExecutor(testLogger)); using (var sp = (StreamProcessor)Components.StreamingDataSource().EventSourceCreator(_eventSourceFactory.Create()) .CreateDataSource(context, _dataSourceUpdates)) { sp.Start(); Assert.True(_esStartedReady.WaitOne(TimeSpan.FromSeconds(1))); DateTime esStarted = sp._esStarted; Thread.Sleep(TimeSpan.FromMilliseconds(100)); _mockEventSource.Raise(es => es.Opened += null, new EventSource.StateChangedEventArgs(ReadyState.Open)); DateTime startCompleted = sp._esStarted; Assert.True(esStarted != startCompleted); mockDiagnosticStore.Verify(ds => ds.AddStreamInit(esStarted, It.Is <TimeSpan>(ts => TimeSpan.Equals(ts, startCompleted - esStarted)), false)); } }
/// <inheritdoc/> public IDataSource CreateDataSource( LdClientContext context, IDataSourceUpdateSink updateSink, User currentUser, bool inBackground ) { if (!inBackground) { context.BaseLogger.Warn("You should only disable the streaming API if instructed to do so by LaunchDarkly support"); } var baseUri = StandardEndpoints.SelectBaseUri( context.ServiceEndpoints, e => e.PollingBaseUri, "Polling", context.BaseLogger ); var logger = context.BaseLogger.SubLogger(LogNames.DataSourceSubLog); var requestor = new FeatureFlagRequestor( baseUri, currentUser, context.EvaluationReasons, context.Http, logger ); return(new PollingDataSource( updateSink, currentUser, requestor, _pollInterval, TimeSpan.Zero, context.TaskExecutor, logger )); }
public async void DataStoreSkipsAndLogsTooLargeItemOnUpsert(string flagOrSegment) { var goodData = MakeGoodData(); GetTooLargeItemParams(flagOrSegment, out var dataKind, out var collIndex, out SerializedItemDescriptor item); var logCapture = Logs.Capture(); var context = new LdClientContext(new BasicConfiguration("sdk-key", false, logCapture.Logger("")), LaunchDarkly.Sdk.Server.Configuration.Default("sdk-key")); using (var store = BaseBuilder().CreatePersistentDataStore(context)) { await store.InitAsync(goodData); AssertDataSetsEqual(MakeGoodData(), await GetAllData(store)); await store.UpsertAsync(dataKind, BadItemKey, item); Assert.True(logCapture.HasMessageWithRegex(LogLevel.Error, @"""" + BadItemKey + @""".*was too large to store in DynamoDB and was dropped")); AssertDataSetsEqual(MakeGoodData(), await GetAllData(store)); } }
/// <inheritdoc/> public IDataStore CreateDataStore(LdClientContext context, IDataStoreUpdates dataStoreUpdates) { if (_coreFactory != null) { return(new PersistentStoreWrapper( _coreFactory.CreatePersistentDataStore(context), _cacheConfig, dataStoreUpdates, context.TaskExecutor, context.Basic.Logger )); } else if (_coreAsyncFactory != null) { return(new PersistentStoreWrapper( _coreAsyncFactory.CreatePersistentDataStore(context), _cacheConfig, dataStoreUpdates, context.TaskExecutor, context.Basic.Logger )); } return(null); }