public virtual async Task MeasureSerializerSimpleThroughputAsync() { var cache = GetCacheClient(); if (cache == null) { return; } using (cache) { await cache.RemoveAllAsync(); var start = SystemClock.UtcNow; const int itemCount = 10000; var metrics = new InMemoryMetricsClient(new InMemoryMetricsClientOptions()); for (int i = 0; i < itemCount; i++) { await cache.SetAsync("test", new SimpleModel { Data1 = "Hello", Data2 = 12 }); var model = await cache.GetAsync <SimpleModel>("test"); Assert.True(model.HasValue); Assert.Equal("Hello", model.Value.Data1); Assert.Equal(12, model.Value.Data2); metrics.Counter("work"); } var workCounter = metrics.GetCounterStatsAsync("work", start, SystemClock.UtcNow); } }
public virtual async Task MeasureThroughputAsync() { var cache = GetCacheClient(); if (cache == null) { return; } using (cache) { await cache.RemoveAllAsync(); var start = SystemClock.UtcNow; const int itemCount = 10000; var metrics = new InMemoryMetricsClient(new InMemoryMetricsClientOptions()); for (int i = 0; i < itemCount; i++) { await cache.SetAsync("test", 13422); await cache.SetAsync("flag", true); Assert.Equal(13422, (await cache.GetAsync <int>("test")).Value); Assert.Null(await cache.GetAsync <int>("test2")); Assert.True((await cache.GetAsync <bool>("flag")).Value); metrics.Counter("work"); } var workCounter = metrics.GetCounterStatsAsync("work", start, SystemClock.UtcNow); } }
public virtual async Task MeasureSerializerComplexThroughputAsync() { var cache = GetCacheClient(); if (cache == null) { return; } using (cache) { await cache.RemoveAllAsync(); var start = SystemClock.UtcNow; const int itemCount = 10000; var metrics = new InMemoryMetricsClient(new InMemoryMetricsClientOptions()); for (int i = 0; i < itemCount; i++) { await cache.SetAsync("test", new ComplexModel { Data1 = "Hello", Data2 = 12, Data3 = true, Simple = new SimpleModel { Data1 = "hi", Data2 = 13 }, Simples = new List <SimpleModel> { new SimpleModel { Data1 = "hey", Data2 = 45 }, new SimpleModel { Data1 = "next", Data2 = 3423 } }, DictionarySimples = new Dictionary <string, SimpleModel> { { "sdf", new SimpleModel { Data1 = "Sachin" } } }, DerivedDictionarySimples = new SampleDictionary <string, SimpleModel> { { "sdf", new SimpleModel { Data1 = "Sachin" } } } }); var model = await cache.GetAsync <ComplexModel>("test"); Assert.True(model.HasValue); Assert.Equal("Hello", model.Value.Data1); Assert.Equal(12, model.Value.Data2); metrics.Counter("work"); } var workCounter = metrics.GetCounterStatsAsync("work", start, SystemClock.UtcNow); } }
public async Task JobLoopPerf() { const int iterations = 10000; var metrics = new InMemoryMetricsClient(); var job = new SampleJob(metrics, Log); var sw = Stopwatch.StartNew(); await job.RunContinuousAsync(null, iterations); sw.Stop(); await metrics.FlushAsync(); _logger.Trace((await metrics.GetCounterStatsAsync("runs")).ToString()); _logger.Trace((await metrics.GetCounterStatsAsync("errors")).ToString()); _logger.Trace((await metrics.GetCounterStatsAsync("failed")).ToString()); _logger.Trace((await metrics.GetCounterStatsAsync("completed")).ToString()); }
public virtual async Task CanRunMultipleQueueJobs() { const int jobCount = 5; const int workItemCount = 100; Log.SetLogLevel <SampleQueueJob>(LogLevel.Error); Log.SetLogLevel <InMemoryMetricsClient>(LogLevel.Trace); var metrics = new InMemoryMetricsClient(true, loggerFactory: Log); var queues = new List <IQueue <SampleQueueWorkItem> >(); for (int i = 0; i < jobCount; i++) { var q = GetSampleWorkItemQueue(retries: 3, retryDelay: TimeSpan.FromSeconds(1)); await q.DeleteQueueAsync(); q.AttachBehavior(new MetricsQueueBehavior <SampleQueueWorkItem>(metrics, "test", Log)); queues.Add(q); } var enqueueTask = Run.InParallel(workItemCount, async index => { var queue = queues[RandomData.GetInt(0, jobCount - 1)]; await queue.EnqueueAsync(new SampleQueueWorkItem { Created = DateTime.Now, Path = RandomData.GetString() }); }); var cancellationTokenSource = new CancellationTokenSource(); await Run.InParallel(jobCount, async index => { var queue = queues[index - 1]; var job = new SampleQueueJob(queue, metrics, Log); await job.RunUntilEmptyAsync(cancellationTokenSource.Token); cancellationTokenSource.Cancel(); }); await enqueueTask; var queueStats = new List <QueueStats>(); for (int i = 0; i < queues.Count; i++) { var stats = await queues[i].GetQueueStatsAsync(); _logger.Info("Queue#{i}: Working: {working} Completed: {completed} Abandoned: {abandoned} Error: {errors} Deadletter: {deadletter}", i, stats.Working, stats.Completed, stats.Abandoned, stats.Errors, stats.Deadletter); queueStats.Add(stats); } await metrics.FlushAsync(); var counter = await metrics.GetCounterStatsAsync("completed"); Assert.Equal(queueStats.Sum(s => s.Completed), counter.Count); Assert.InRange(queueStats.Sum(s => s.Completed), 0, workItemCount); }
public async Task MeasureThroughputWithRandomFailures() { var queue = GetQueue(retries: 3, workItemTimeout: TimeSpan.FromSeconds(2), retryDelay: TimeSpan.Zero); if (queue == null) { return; } FlushAll(); using (queue) { await queue.DeleteQueueAsync(); const int workItemCount = 1000; for (int i = 0; i < workItemCount; i++) { await queue.EnqueueAsync(new SimpleWorkItem { Data = "Hello" }); } Assert.Equal(workItemCount, (await queue.GetQueueStatsAsync()).Queued); var metrics = new InMemoryMetricsClient(); var workItem = await queue.DequeueAsync(TimeSpan.Zero); while (workItem != null) { Assert.Equal("Hello", workItem.Value.Data); if (RandomData.GetBool(10)) { await workItem.AbandonAsync(); } else { await workItem.CompleteAsync(); } await metrics.CounterAsync("work"); workItem = await queue.DequeueAsync(TimeSpan.FromMilliseconds(100)); } _logger.Trace((await metrics.GetCounterStatsAsync("work")).ToString()); var stats = await queue.GetQueueStatsAsync(); Assert.True(stats.Dequeued >= workItemCount); Assert.Equal(workItemCount, stats.Completed + stats.Deadletter); Assert.Equal(0, stats.Queued); Trace.WriteLine(CountAllKeys()); } }
public async Task MeasureWorkerThroughput() { var queue = GetQueue(retries: 3, workItemTimeout: TimeSpan.FromSeconds(2), retryDelay: TimeSpan.FromSeconds(1)); if (queue == null) { return; } using (queue) { await queue.DeleteQueueAsync(); const int workItemCount = 1; for (int i = 0; i < workItemCount; i++) { await queue.EnqueueAsync(new SimpleWorkItem { Data = "Hello" }); } Assert.Equal(workItemCount, (await queue.GetQueueStatsAsync()).Queued); var countdown = new AsyncCountdownEvent(workItemCount); var metrics = new InMemoryMetricsClient(new InMemoryMetricsClientOptions()); await queue.StartWorkingAsync(async workItem => { Assert.Equal("Hello", workItem.Value.Data); await workItem.CompleteAsync(); metrics.Counter("work"); countdown.Signal(); }); await countdown.WaitAsync(TimeSpan.FromMinutes(1)); Assert.Equal(0, countdown.CurrentCount); _logger.LogTrace((await metrics.GetCounterStatsAsync("work")).ToString()); var stats = await queue.GetQueueStatsAsync(); Assert.Equal(workItemCount, stats.Dequeued); Assert.Equal(workItemCount, stats.Completed); Assert.Equal(0, stats.Queued); var muxer = SharedConnection.GetMuxer(); _logger.LogTrace("# Keys: {0}", muxer.CountAllKeysAsync()); } }
public async Task MeasureThroughput() { var queue = GetQueue(retries: 3, workItemTimeout: TimeSpan.FromSeconds(2), retryDelay: TimeSpan.FromSeconds(1)); if (queue == null) { return; } using (queue) { await queue.DeleteQueueAsync(); const int workItemCount = 1000; for (int i = 0; i < workItemCount; i++) { await queue.EnqueueAsync(new SimpleWorkItem { Data = "Hello" }); } Assert.Equal(workItemCount, (await queue.GetQueueStatsAsync()).Queued); var metrics = new InMemoryMetricsClient(); var workItem = await queue.DequeueAsync(TimeSpan.Zero); while (workItem != null) { Assert.Equal("Hello", workItem.Value.Data); await workItem.CompleteAsync(); await metrics.CounterAsync("work"); workItem = await queue.DequeueAsync(TimeSpan.Zero); } _logger.Trace((await metrics.GetCounterStatsAsync("work")).ToString()); var stats = await queue.GetQueueStatsAsync(); Assert.Equal(workItemCount, stats.Dequeued); Assert.Equal(workItemCount, stats.Completed); Assert.Equal(0, stats.Queued); var muxer = SharedConnection.GetMuxer(); _logger.Trace("# Keys: {0}", muxer.CountAllKeysAsync()); } }