internal virtual async Task <bool> UpdateQueueMetrics() { CloudQueue workItemQueue = AzureStorageOrchestrationService.GetWorkItemQueue(this.storageAccount, this.taskHub); CloudQueue[] controlQueues = await AzureStorageOrchestrationService.GetControlQueuesAsync( this.storageAccount, this.taskHub, defaultPartitionCount : AzureStorageOrchestrationServiceSettings.DefaultPartitionCount); Task <QueueMetric> workItemMetricTask = GetQueueMetricsAsync(workItemQueue); List <Task <QueueMetric> > controlQueueMetricTasks = controlQueues.Select(GetQueueMetricsAsync).ToList(); var tasks = new List <Task>(controlQueueMetricTasks.Count + 1); tasks.Add(workItemMetricTask); tasks.AddRange(controlQueueMetricTasks); try { await Task.WhenAll(tasks); } catch (StorageException e) when(e.RequestInformation?.HttpStatusCode == 404) { // The queues are not yet provisioned. AnalyticsEventSource.Log.MonitorWarning( this.storageAccount.Credentials.AccountName, this.taskHub, $"Task hub has not been provisioned: {e.RequestInformation.ExtendedErrorInformation?.ErrorMessage}"); return(false); } QueueMetric workItemQueueMetric = workItemMetricTask.Result; this.WorkItemQueueLatencies.Add((int)workItemQueueMetric.Latency.TotalMilliseconds); int i; for (i = 0; i < controlQueueMetricTasks.Count; i++) { QueueMetric controlQueueMetric = controlQueueMetricTasks[i].Result; if (i >= this.ControlQueueLatencies.Count) { this.ControlQueueLatencies.Add(new QueueMetricHistory(QueueLengthSampleSize)); } this.ControlQueueLatencies[i].Add((int)controlQueueMetric.Latency.TotalMilliseconds); } // Handle the case where the number of control queues has been reduced since we last checked. while (i < this.ControlQueueLatencies.Count && this.ControlQueueLatencies.Count > 0) { this.ControlQueueLatencies.RemoveAt(this.ControlQueueLatencies.Count - 1); } this.currentPartitionCount = controlQueues.Length; this.currentWorkItemQueueLength = workItemQueueMetric.Length; this.currentControlQueueLengths = controlQueueMetricTasks.Select(t => t.Result.Length).ToArray(); return(true); }
public static async Task <IActionResult> Run( // Using /a/p/i route prefix, to let Functions Host distinguish api methods from statics [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "a/p/i/delete-task-hub")] HttpRequest req ) { // Checking that the call is authenticated properly try { Globals.ValidateIdentity(req.HttpContext.User, req.Headers); } catch (UnauthorizedAccessException ex) { return(new OkObjectResult(ex.Message) { StatusCode = 401 }); } string hubName = Environment.GetEnvironmentVariable(EnvVariableNames.DFM_HUB_NAME); string connectionString = Environment.GetEnvironmentVariable(EnvVariableNames.AzureWebJobsStorage); var orcService = new AzureStorageOrchestrationService(new AzureStorageOrchestrationServiceSettings { StorageConnectionString = connectionString, TaskHubName = hubName, }); await orcService.DeleteAsync(); return(new OkResult()); }
/// <inheritdoc /> public override Task PurgeInstanceHistoryAsync(DateTime createdTimeFrom, DateTime?createdTimeTo, IEnumerable <OrchestrationStatus> runtimeStatus) { // TODO this cast is to avoid to change DurableTask.Core. Change it to use TaskHubClient. AzureStorageOrchestrationService serviceClient = (AzureStorageOrchestrationService)this.client.ServiceClient; return(serviceClient.PurgeInstanceHistoryAsync(createdTimeFrom, createdTimeTo, runtimeStatus)); }
public static void Main(string[] args) { AzureStorageOrchestrationService orchestrationService = new AzureStorageOrchestrationService(new AzureStorageOrchestrationServiceSettings() { StorageConnectionString = ServiceSettings.StorageConnectionString, TaskHubName = ServiceSettings.TaskHubName }); TaskHubClient client = new TaskHubClient(orchestrationService); Console.WriteLine("Enter -1 to exit anything else will be fed to the orchestration"); do { var s = Console.ReadLine(); if (s == "-1") { break; } var instance = client.CreateOrchestrationInstanceAsync(typeof(LetterCountOrchestration), s).Result; Console.WriteLine("Workflow Instance Started: " + instance); var result = client.WaitForOrchestrationAsync(instance, TimeSpan.MaxValue).Result; Console.WriteLine($"Task done: {result?.OrchestrationStatus}"); } while (1 == 1); }
public LegacyPartitionManager( AzureStorageOrchestrationService service, AzureStorageOrchestrationServiceSettings settings, CloudStorageAccount account, AzureStorageOrchestrationServiceStats stats) { this.service = service; this.settings = settings; this.stats = stats; this.leaseManager = new BlobLeaseManager( settings, settings.TaskHubName.ToLowerInvariant() + "-leases", string.Empty, "default", account.CreateCloudBlobClient(), skipBlobContainerCreation: false, stats); this.leaseCollectionManager = new LeaseCollectionBalancer <BlobLease>( "default", settings, account.Credentials.AccountName, leaseManager, new LeaseCollectionBalancerOptions { AcquireInterval = settings.LeaseAcquireInterval, RenewInterval = settings.LeaseRenewInterval, LeaseInterval = settings.LeaseInterval, ShouldStealLeases = true, }); }
public TestOrchestrationHost(AzureStorageOrchestrationService service) { this.worker = new TaskHubWorker(service); this.client = new TaskHubClient(service); this.addedOrchestrationTypes = new HashSet <Type>(); this.addedActivityTypes = new HashSet <Type>(); }
/// <inheritdoc /> public override Task PurgeInstanceHistoryAsync(string instanceId) { // TODO this cast is to avoid to change DurableTask.Core. Change it to use TaskHubClient. AzureStorageOrchestrationService serviceClient = (AzureStorageOrchestrationService)this.client.ServiceClient; return(serviceClient.PurgeInstanceHistoryAsync(instanceId)); }
private void SetStorageServiceAndTaskHubClient(out AzureStorageOrchestrationService orchestrationService, out TaskHubClient taskHubClient, string connectionStringKey = null, string taskHubName = null) { _connectionStringKey = connectionStringKey ?? _connectionStringKey; _taskHubName = taskHubName ?? _taskHubName; var connectionString = Environment.GetEnvironmentVariable(_connectionStringKey); // Prioritize environment variables connectionString = connectionString ?? _secretsManager.GetSecrets().FirstOrDefault(s => s.Key.Equals(_connectionStringKey, StringComparison.OrdinalIgnoreCase)).Value; if (!string.IsNullOrEmpty(connectionString)) { var settings = new AzureStorageOrchestrationServiceSettings { TaskHubName = _taskHubName, StorageConnectionString = connectionString, }; orchestrationService = new AzureStorageOrchestrationService(settings); taskHubClient = new TaskHubClient(orchestrationService); } else { throw new CliException("No storage connection string found."); } }
/// <summary> /// Gets a <see cref="DurableOrchestrationClient"/> using configuration from a <see cref="OrchestrationClientAttribute"/> instance. /// </summary> /// <param name="attribute">The attribute containing the client configuration parameters.</param> /// <returns>Returns a <see cref="DurableOrchestrationClient"/> instance. The returned instance may be a cached instance.</returns> protected internal virtual DurableOrchestrationClient GetClient(OrchestrationClientAttribute attribute) { DurableOrchestrationClient client = this.cachedClients.GetOrAdd( attribute, attr => { AzureStorageOrchestrationServiceSettings settings = this.GetOrchestrationServiceSettings(attr); AzureStorageOrchestrationService innerClient; if (this.orchestrationServiceSettings != null && this.orchestrationService != null && string.Equals(this.orchestrationServiceSettings.TaskHubName, settings.TaskHubName, StringComparison.OrdinalIgnoreCase) && string.Equals(this.orchestrationServiceSettings.StorageConnectionString, settings.StorageConnectionString, StringComparison.OrdinalIgnoreCase)) { // It's important that clients use the same AzureStorageOrchestrationService instance // as the host when possible to ensure we any send operations can be picked up // immediately instead of waiting for the next queue polling interval. innerClient = this.orchestrationService; } else { innerClient = new AzureStorageOrchestrationService(settings); } return(new DurableOrchestrationClient(innerClient, this, attr)); }); return(client); }
public async Task <IList <OrchestrationState> > GetStateAsync(string instanceId) { Trace.TraceInformation($"Getting orchestration state with instance id - {this.instanceId}"); // The GetStateAsync only exists in the service object AzureStorageOrchestrationService service = (AzureStorageOrchestrationService)this.client.ServiceClient; return(await service.GetOrchestrationStateAsync(instanceId, true)); }
public Task RewindAsync(string reason) { Trace.TraceInformation($"Rewinding instance {this.instanceId} with reason = {reason}."); // The Rewind API currently only exists in the service object AzureStorageOrchestrationService service = (AzureStorageOrchestrationService)this.client.serviceClient; return(service.RewindTaskOrchestrationAsync(this.instanceId, reason)); }
public async Task <IList <OrchestrationState> > GetAllOrchestrationInstancesAsync() { // This API currently only exists in the service object and is not yet exposed on the TaskHubClient AzureStorageOrchestrationService service = (AzureStorageOrchestrationService)this.client.ServiceClient; IList <OrchestrationState> instances = await service.GetOrchestrationStateAsync(); Trace.TraceInformation($"Found {instances.Count} in the task hub instance store."); return(instances); }
public Task PurgeInstanceHistoryByTimePeriod(DateTime createdTimeFrom, DateTime?createdTimeTo, IEnumerable <OrchestrationStatus> runtimeStatus) { Trace.TraceInformation($"Purging history from {createdTimeFrom} to {createdTimeTo}"); // The Purge Instance History API only exists in the service object AzureStorageOrchestrationService service = (AzureStorageOrchestrationService)this.client.ServiceClient; return(service.PurgeInstanceHistoryAsync(createdTimeFrom, createdTimeTo, runtimeStatus)); }
public Task PurgeInstanceHistory() { Trace.TraceInformation($"Purging history for instance with id - {this.instanceId}"); // The Purge Instance History API only exists in the service object AzureStorageOrchestrationService service = (AzureStorageOrchestrationService)this.client.ServiceClient; return(service.PurgeInstanceHistoryAsync(this.instanceId)); }
async Task DequeueLoop(string partitionId, ControlQueue controlQueue, CancellationToken cancellationToken) { this.settings.Logger.PartitionManagerInfo( this.storageAccountName, this.settings.TaskHubName, this.settings.WorkerId, partitionId, $"Started listening for messages on queue {controlQueue.Name}."); while (!controlQueue.IsReleased) { try { // Every dequeue operation has a common trace ID so that batches of dequeued messages can be correlated together. // Both the dequeue traces and the processing traces will share the same "related" trace activity ID. Guid traceActivityId = AzureStorageOrchestrationService.StartNewLogicalTraceScope(useExisting: false); // This will block until either new messages arrive or the queue is released. IReadOnlyList <MessageData> messages = await controlQueue.GetMessagesAsync(cancellationToken); if (messages.Count > 0) { // De-dupe any execution started messages IEnumerable <MessageData> filteredMessages = await this.DedupeExecutionStartedMessagesAsync( controlQueue, messages, traceActivityId, cancellationToken); this.AddMessageToPendingOrchestration(controlQueue, filteredMessages, traceActivityId, cancellationToken); } } catch (OperationCanceledException) when(cancellationToken.IsCancellationRequested) { // shutting down break; } catch (Exception e) { this.settings.Logger.PartitionManagerWarning( this.storageAccountName, this.settings.TaskHubName, this.settings.WorkerId, partitionId, $"Exception in the dequeue loop for control queue {controlQueue.Name}. Exception: {e}"); Thread.Sleep(TimeSpan.FromSeconds(1)); } } this.settings.Logger.PartitionManagerInfo( this.storageAccountName, this.settings.TaskHubName, this.settings.WorkerId, partitionId, $"Stopped listening for messages on queue {controlQueue.Name}."); }
/// <inheritdoc /> public override async Task <PurgeHistoryResult> PurgeInstanceHistoryAsync(string instanceId) { // TODO this cast is to avoid to change DurableTask.Core. Change it to use TaskHubClient. AzureStorageOrchestrationService serviceClient = (AzureStorageOrchestrationService)this.client.ServiceClient; DurableTask.AzureStorage.PurgeHistoryResult purgeHistoryResult = await serviceClient.PurgeInstanceHistoryAsync(instanceId); return(new PurgeHistoryResult(purgeHistoryResult.InstancesDeleted)); }
public DurabilityProvider GetDurabilityProvider() { if (this.defaultStorageProvider == null) { var defaultService = new AzureStorageOrchestrationService(this.defaultSettings); this.defaultStorageProvider = new AzureStorageDurabilityProvider(defaultService, this.defaultConnectionName); } return(this.defaultStorageProvider); }
/// <inheritdoc /> public override async Task <PurgeHistoryResult> PurgeInstanceHistoryAsync(DateTime createdTimeFrom, DateTime?createdTimeTo, IEnumerable <OrchestrationStatus> runtimeStatus) { // TODO this cast is to avoid to change DurableTask.Core. Change it to use TaskHubClient. AzureStorageOrchestrationService serviceClient = (AzureStorageOrchestrationService)this.client.ServiceClient; DurableTask.AzureStorage.PurgeHistoryResult purgeHistoryResult = await serviceClient.PurgeInstanceHistoryAsync(createdTimeFrom, createdTimeTo, runtimeStatus); return(new PurgeHistoryResult(purgeHistoryResult.InstancesDeleted)); }
public async Task <List <HistoryStateEvent> > GetOrchestrationHistoryAsync(string instanceId) { Trace.TraceInformation($"Getting history for instance with id - {this.instanceId}"); // GetOrchestrationHistoryAsync is exposed in the TaskHubClinet but requires execution id. // However, we need to get all the history records for an instance id not for specific execution. AzureStorageOrchestrationService service = (AzureStorageOrchestrationService)this.client.ServiceClient; string historyString = await service.GetOrchestrationHistoryAsync(instanceId, null); return(JsonConvert.DeserializeObject <List <HistoryStateEvent> >(historyString)); }
public TestOrchestrationHost(AzureStorageOrchestrationServiceSettings settings) { this.service = new AzureStorageOrchestrationService(settings); this.service.CreateAsync().GetAwaiter().GetResult(); this.settings = settings; this.worker = new TaskHubWorker(service, loggerFactory: settings.LoggerFactory); this.client = new TaskHubClient(service, loggerFactory: settings.LoggerFactory); this.addedOrchestrationTypes = new HashSet <Type>(); this.addedActivityTypes = new HashSet <Type>(); }
public async Task MonitorIdleTaskHubDisconnected() { var settings = new AzureStorageOrchestrationServiceSettings { StorageConnectionString = TestHelpers.GetTestStorageAccountConnectionString(), TaskHubName = nameof(MonitorIdleTaskHubDisconnected), PartitionCount = 4, }; var service = new AzureStorageOrchestrationService(settings); var monitor = new DisconnectedPerformanceMonitor(settings.StorageConnectionString, settings.TaskHubName); await service.DeleteAsync(); // A null heartbeat is expected when the task hub does not exist. PerformanceHeartbeat heartbeat = await monitor.PulseAsync(currentWorkerCount : 0); Assert.IsNull(heartbeat); await service.CreateAsync(); ScaleRecommendation recommendation; for (int i = 0; i < 10; i++) { heartbeat = await monitor.PulseAsync(currentWorkerCount : 0); Assert.IsNotNull(heartbeat); Assert.AreEqual(settings.PartitionCount, heartbeat.PartitionCount); Assert.AreEqual(settings.PartitionCount, heartbeat.ControlQueueLengths.Count); Assert.AreEqual(settings.PartitionCount, heartbeat.ControlQueueLatencies.Count); Assert.AreEqual(0, heartbeat.ControlQueueLengths.Count(l => l != 0)); Assert.AreEqual(0, heartbeat.ControlQueueLatencies.Count(l => l != TimeSpan.Zero)); Assert.AreEqual(0, heartbeat.WorkItemQueueLength); Assert.AreEqual(0.0, heartbeat.WorkItemQueueLatencyTrend); Assert.AreEqual(TimeSpan.Zero, heartbeat.WorkItemQueueLatency); recommendation = heartbeat.ScaleRecommendation; Assert.IsNotNull(recommendation); Assert.AreEqual(ScaleAction.None, recommendation.Action); Assert.AreEqual(false, recommendation.KeepWorkersAlive); Assert.IsNotNull(recommendation.Reason); } // If any workers are assigned, the recommendation should be to have them removed. heartbeat = await monitor.PulseAsync(currentWorkerCount : 1); recommendation = heartbeat.ScaleRecommendation; Assert.IsNotNull(recommendation); Assert.AreEqual(ScaleAction.RemoveWorker, recommendation.Action); Assert.AreEqual(false, recommendation.KeepWorkersAlive); Assert.IsNotNull(recommendation.Reason); }
/// <summary> /// Internal initialization call from the WebJobs host. /// </summary> /// <param name="context">Extension context provided by WebJobs.</param> void IExtensionConfigProvider.Initialize(ExtensionConfigContext context) { ConfigureLoaderHooks(); // Functions V1 has it's configuration initialized at startup time (now). // For Functions V2 (and for some unit tests) configuration happens earlier in the pipeline. if (!this.isOptionsConfigured) { this.InitializeForFunctionsV1(context); } if (this.nameResolver.TryResolveWholeString(this.Options.HubName, out string taskHubName)) { // use the resolved task hub name this.Options.HubName = taskHubName; } // Throw if any of the configured options are invalid this.Options.Validate(); // For 202 support if (this.Options.NotificationUrl == null) { #pragma warning disable CS0618 // Type or member is obsolete this.Options.NotificationUrl = context.GetWebhookHandler(); #pragma warning restore CS0618 // Type or member is obsolete } this.TraceConfigurationSettings(); var bindings = new BindingHelper(this, this.TraceHelper); // Note that the order of the rules is important var rule = context.AddBindingRule <OrchestrationClientAttribute>() .AddConverter <string, StartOrchestrationArgs>(bindings.StringToStartOrchestrationArgs) .AddConverter <JObject, StartOrchestrationArgs>(bindings.JObjectToStartOrchestrationArgs) .AddConverter <DurableOrchestrationClient, string>(bindings.DurableOrchestrationClientToString); rule.BindToCollector <StartOrchestrationArgs>(bindings.CreateAsyncCollector); rule.BindToInput <DurableOrchestrationClient>(this.GetClient); context.AddBindingRule <OrchestrationTriggerAttribute>() .BindToTrigger(new OrchestrationTriggerAttributeBindingProvider(this, context, this.TraceHelper)); context.AddBindingRule <ActivityTriggerAttribute>() .BindToTrigger(new ActivityTriggerAttributeBindingProvider(this, context, this.TraceHelper)); this.orchestrationServiceSettings = this.GetOrchestrationServiceSettings(); this.orchestrationService = new AzureStorageOrchestrationService(this.orchestrationServiceSettings); this.taskHubWorker = new TaskHubWorker(this.orchestrationService, this, this); this.taskHubWorker.AddOrchestrationDispatcherMiddleware(this.OrchestrationMiddleware); }
public static Task DeleteTaskHubResources(string testName, bool enableExtendedSessions) { string hubName = GetTaskHubNameFromTestName(testName, enableExtendedSessions); var settings = new AzureStorageOrchestrationServiceSettings { TaskHubName = hubName, StorageConnectionString = GetStorageConnectionString(), }; var service = new AzureStorageOrchestrationService(settings); return(service.DeleteAsync()); }
/// <summary> /// Gets a <see cref="DurableOrchestrationClient"/> using configuration from a <see cref="OrchestrationClientAttribute"/> instance. /// </summary> /// <param name="attribute">The attribute containing the client configuration parameters.</param> /// <returns>Returns a <see cref="DurableOrchestrationClient"/> instance. The returned instance may be a cached instance.</returns> protected internal virtual DurableOrchestrationClient GetClient(OrchestrationClientAttribute attribute) { DurableOrchestrationClient client = this.cachedClients.GetOrAdd( attribute, attr => { AzureStorageOrchestrationServiceSettings settings = this.GetOrchestrationServiceSettings(attr); var innerClient = new AzureStorageOrchestrationService(settings); return(new DurableOrchestrationClient(innerClient, this, attr, this.traceHelper)); }); return(client); }
public DurabilityProvider GetDurabilityProvider() { this.EnsureInitialized(); if (this.defaultStorageProvider == null) { var defaultService = new AzureStorageOrchestrationService(this.defaultSettings); this.defaultStorageProvider = new AzureStorageDurabilityProvider( defaultService, this.defaultConnectionName, this.azureStorageOptions); } return(this.defaultStorageProvider); }
public SafePartitionManager( AzureStorageOrchestrationService service, AzureStorageClient azureStorageClient, OrchestrationSessionManager sessionManager) { this.service = service; this.azureStorageClient = azureStorageClient; this.settings = this.azureStorageClient.Settings; this.sessionManager = sessionManager; this.intentLeaseManager = AzureStorageOrchestrationService.GetBlobLeaseManager( this.azureStorageClient, "intent"); this.intentLeaseCollectionManager = new LeaseCollectionBalancer <BlobLease>( "intent", settings, this.azureStorageClient.BlobAccountName, this.intentLeaseManager, new LeaseCollectionBalancerOptions { AcquireInterval = settings.LeaseAcquireInterval, RenewInterval = settings.LeaseRenewInterval, LeaseInterval = settings.LeaseInterval, }); var currentlyOwnedIntentLeases = this.intentLeaseCollectionManager.GetCurrentlyOwnedLeases(); this.ownershipLeaseManager = AzureStorageOrchestrationService.GetBlobLeaseManager( this.azureStorageClient, "ownership"); this.ownershipLeaseCollectionManager = new LeaseCollectionBalancer <BlobLease>( "ownership", this.settings, this.azureStorageClient.BlobAccountName, this.ownershipLeaseManager, new LeaseCollectionBalancerOptions { AcquireInterval = TimeSpan.FromSeconds(5), RenewInterval = TimeSpan.FromSeconds(10), LeaseInterval = TimeSpan.FromSeconds(15), ShouldStealLeases = false }, shouldAquireLeaseDelegate: leaseKey => currentlyOwnedIntentLeases.ContainsKey(leaseKey), shouldRenewLeaseDelegate: leaseKey => currentlyOwnedIntentLeases.ContainsKey(leaseKey) || this.sessionManager.IsControlQueueReceivingMessages(leaseKey) || this.sessionManager.IsControlQueueProcessingMessages(leaseKey)); }
/// <inheritdoc /> public override async Task <IList <DurableOrchestrationStatus> > GetStatusAsync(DateTime createdTimeFrom, DateTime?createdTimeTo, IEnumerable <OrchestrationRuntimeStatus> runtimeStatus, CancellationToken cancellationToken = default(CancellationToken)) { // TODO this cast is to avoid to change DurableTask.Core. Change it to use TaskHubClient. AzureStorageOrchestrationService serviceClient = (AzureStorageOrchestrationService)this.client.ServiceClient; IList <OrchestrationState> states = await serviceClient.GetOrchestrationStateAsync(createdTimeFrom, createdTimeTo, runtimeStatus.Select(x => (OrchestrationStatus)x), cancellationToken); var results = new List <DurableOrchestrationStatus>(); foreach (OrchestrationState state in states) { results.Add(this.ConvertFrom(state)); } return(results); }
/// <inheritdoc /> public override async Task <IList <DurableOrchestrationStatus> > GetStatusAsync(CancellationToken cancellationToken = default(CancellationToken)) { // TODO this cast is to avoid to change DurableTask.Core. Change it to use TaskHubClient. AzureStorageOrchestrationService serviceClient = (AzureStorageOrchestrationService)this.client.ServiceClient; IList <OrchestrationState> states = await serviceClient.GetOrchestrationStateAsync(cancellationToken); var results = new List <DurableOrchestrationStatus>(); foreach (OrchestrationState state in states) { results.Add(this.ConvertFrom(state)); } return(results); }
public AzureStorageDurabilityProvider( AzureStorageOrchestrationService service, string connectionName, AzureStorageOptions options) : base("Azure Storage", service, service, connectionName) { this.serviceClient = service; this.connectionName = connectionName; this.storageOptionsJson = JObject.FromObject( options, new JsonSerializer { Converters = { new StringEnumConverter() }, ContractResolver = new CamelCasePropertyNamesContractResolver(), }); }
public virtual DurabilityProvider GetDurabilityProvider() { this.EnsureDefaultClientSettingsInitialized(); if (this.defaultStorageProvider == null) { var defaultService = new AzureStorageOrchestrationService(this.defaultSettings); ILogger logger = this.loggerFactory.CreateLogger(LoggerName); this.defaultStorageProvider = new AzureStorageDurabilityProvider( defaultService, this.defaultConnectionName, this.azureStorageOptions, logger); } return(this.defaultStorageProvider); }