public NancyAdapterGlobalMetrics() { this.clock = new TestClock(); this.scheduler = new TestScheduler(clock); this.timer = new TimerMetric(SamplingType.SlidingWindow, new MeterMetric(clock, scheduler), clock); this.meter = new MeterMetric(clock, scheduler); this.counter = new CounterMetric(); this.size = new HistogramMetric(); this.browser = new Browser(with => { with.ApplicationStartup((c, p) => { Metric.Config.WithNancy(new TestRegistry { TimerInstance = timer, MeterInstance = meter, CounterInstance = counter, HistogramInstance = size }, nancy => nancy.WithGlobalMetrics(config => config.RegisterAllMetrics(p))); }); with.Module(new TestModule(this.clock)); with.Module(new ActiveRequestsModule(this.requestTrigger.Task, result1, result2)); }); }
static JsonExtensions() { JsonStreamDeserializationsPerSecond = new MeterMetric(MetricsScheduler.Instance); JsonStreamDeserializedBytesPerSecond = new MeterMetric(MetricsScheduler.Instance); JsonStreamSerializationsPerSecond = new MeterMetric(MetricsScheduler.Instance); JsonStreamSerializedBytesPerSecond = new MeterMetric(MetricsScheduler.Instance); }
public void Dispose() { if (_isDisposed) { return; } Stream?.Dispose(); TcpClient?.Dispose(); _running.Wait(); try { if (_isDisposed) { return; } _isDisposed = true; DocumentDatabase?.RunningTcpConnections.TryRemove(this); Stream = null; TcpClient = null; _bytesReceivedMetric = null; _bytesSentMetric = null; } finally { _running.Release(); } // we'll let the _running be finalized, because otherwise we have // a possible race condition on dispose }
public void can_clear_payload() { var metricsMock = new Mock <IMetrics>(); var clock = new TestClock(); var meter = new MeterMetric(clock); meter.Mark(new MetricItem().With("item1", "value1"), 1); meter.Mark(new MetricItem().With("item2", "value2"), 1); var meterValueSource = new MeterValueSource("test meter", ConstantValue.Provider(meter.Value), Unit.None, TimeUnit.Milliseconds, MetricTags.None); var payloadBuilder = new LineProtocolPayloadBuilder(); var reporter = CreateReporter(payloadBuilder); reporter.StartReportRun(metricsMock.Object); reporter.ReportMetric("test", meterValueSource); var sr = new StringWriter(); payloadBuilder.Payload().Format(sr); sr.ToString().Should().NotBeNullOrWhiteSpace(); payloadBuilder.Clear(); payloadBuilder.Payload().Should().BeNull(); }
public static MeterValueSource ToMetricValueSource(this MeterMetric source) { var rateUnit = source.RateUnit.FromUnit(); var items = source.Items.Select( i => { var value = new MeterValue( i.Count, i.MeanRate, i.OneMinuteRate, i.FiveMinuteRate, i.FifteenMinuteRate, rateUnit); return(new MeterValue.SetItem( i.Item, i.Percent, value)); }).ToArray(); var meterValue = new MeterValue( source.Count, source.MeanRate, source.OneMinuteRate, source.FiveMinuteRate, source.FifteenMinuteRate, rateUnit, items); return(new MeterValueSource(source.Name, ConstantValue.Provider(meterValue), source.Unit, rateUnit, source.Tags)); }
public void MeterStartsAtZero() { var meter = new MeterMetric(); meter.Value.MeanRate.Should().Be(0L); meter.Value.OneMinuteRate.Should().Be(0L); meter.Value.FiveMinuteRate.Should().Be(0L); meter.Value.FifteenMinuteRate.Should().Be(0L); }
private static void AppendMeter(StringBuilder sb, MeterMetric meter) { sb.Append("{\"count\":").Append(meter.Count) .Append(",\"rate_unit\":\"").Append(meter.RateUnit).Append("\"") .Append(",\"fifteen_minute_rate\":").Append(meter.FifteenMinuteRate) .Append(",\"five_minute_rate\":").Append(meter.FiveMinuteRate) .Append(",\"one_minute_rate\":").Append(meter.OneMinuteRate) .Append(",\"mean_rate\":").Append(meter.MeanRate).Append("}"); }
private void CreateNew() { RequestsMeter = new MeterMetric(); RequestsPerSecondCounter = new MeterMetric(); DocPutsPerSecond = new MeterMetric(); IndexedPerSecond = new MeterMetric(); MapReduceMappedPerSecond = new MeterMetric(); MapReduceReducedPerSecond = new MeterMetric(); SqlReplicationBatchSizeMeter = new MeterMetric(); }
public static MeterData GetMeterData(this MeterMetric metric, int accuracy) { return(new MeterData() { Count = metric.Count, FifteenMinuteRate = Math.Round(metric.FifteenMinuteRate, accuracy), FiveMinuteRate = Math.Round(metric.FiveMinuteRate, accuracy), MeanRate = Math.Round(metric.MeanRate, accuracy), OneMinuteRate = Math.Round(metric.OneMinuteRate, accuracy) }); }
public TcpConnectionOptions() { _bytesReceivedMetric = new MeterMetric(); _bytesSentMetric = new MeterMetric(); MetricsScheduler.Instance.StartTickingMetric(_bytesSentMetric); MetricsScheduler.Instance.StartTickingMetric(_bytesReceivedMetric); _connectedAt = DateTime.UtcNow; Id = Interlocked.Increment(ref _sequence); }
private static MeterData CreateMeterData(MeterMetric metric) { return(new MeterData { Count = metric.Count, FifteenMinuteRate = Math.Round(metric.FifteenMinuteRate, 3), FiveMinuteRate = Math.Round(metric.FiveMinuteRate, 3), MeanRate = Math.Round(metric.MeanRate, 3), OneMinuteRate = Math.Round(metric.OneMinuteRate, 3), }); }
public static MeterData CreateMeterData(this MeterMetric self) { return(new MeterData { Count = self.Count, FifteenMinuteRate = Math.Round(self.FifteenMinuteRate, 3), FiveMinuteRate = Math.Round(self.FiveMinuteRate, 3), MeanRate = Math.Round(self.MeanRate, 3), OneMinuteRate = Math.Round(self.OneMinuteRate, 3), }); }
public void can_report_meters() { var expected = StringReporterSamples.Meters.ExtractStringReporterSampleFromResourceFile(); var clock = new TestClock(); var sr = new StringReporter(); var metric = new MeterMetric(clock, new TestTaskScheduler(clock)); metric.Mark(1); sr.ReportMetric("test", new MeterValueSource("meter_name", metric, Unit.None, TimeUnit.Milliseconds, MetricTags.None)); AssertReportResult(sr.Result, expected); }
public static DynamicJsonValue CreateMeterData(this MeterMetric self) { var meterValue = self; return(new DynamicJsonValue { ["Count"] = meterValue.Count, ["FifteenMinuteRate"] = Math.Round(meterValue.FifteenMinuteRate, 3), ["FiveMinuteRate"] = Math.Round(meterValue.FiveMinuteRate, 3), ["MeanRate"] = Math.Round(meterValue.MeanRate, 3), ["OneMinuteRate"] = Math.Round(meterValue.OneMinuteRate, 3), }); }
public void MeterCanCount() { var meter = new MeterMetric(); meter.Mark(); meter.Value.Count.Should().Be(1L); meter.Mark(); meter.Value.Count.Should().Be(2L); meter.Mark(8L); meter.Value.Count.Should().Be(10L); }
public void Dispose() { if (_isDisposed) { return; } #if !RELEASE GC.SuppressFinalize(this); #endif using (TcpClient) using (Stream) { if (Operation == TcpConnectionHeaderMessage.OperationTypes.Cluster) { try { TcpClient?.Client?.Disconnect(reuseSocket: false); } catch { // nothing we can do } } } _running.Wait(); try { if (_isDisposed) { return; } _isDisposed = true; DocumentDatabase?.RunningTcpConnections.TryRemove(this); Stream = null; TcpClient = null; _bytesReceivedMetric = null; _bytesSentMetric = null; } finally { _running.Release(); } // we'll let the _running be finalized, because otherwise we have // a possible race condition on dispose }
static JsonExtensions() { JsonStreamSerializationsPerSecond = _dbMetrics.Meter("metrics", "ser/sec", "JsonStreamSerializationsPerSecond Meter", TimeUnit.Seconds);; MetricsTicker.Instance.AddMeterMetric(JsonStreamSerializationsPerSecond); JsonStreamSerializedBytesPerSecond = _dbMetrics.Meter("metrics", "serbytes/sec", "JsonStreamSerializedBytesPerSecondMeter", TimeUnit.Seconds);; MetricsTicker.Instance.AddMeterMetric(JsonStreamSerializedBytesPerSecond); JsonStreamDeserializationsPerSecond = _dbMetrics.Meter("metrics", "deser/sec", "JsonStreamDeserializationsPerSecond Meter", TimeUnit.Seconds); MetricsTicker.Instance.AddMeterMetric(JsonExtensions.JsonStreamDeserializationsPerSecond); JsonStreamDeserializedBytesPerSecond = _dbMetrics.Meter("metrics", "deserbytes/sec", "JsonStreamDeserializedBytesPerSecond Meter", TimeUnit.Seconds); MetricsTicker.Instance.AddMeterMetric(JsonStreamDeserializedBytesPerSecond); }
/// <summary> /// Creates a new meter metric and registers it under the given type and name /// </summary> /// <param name="context">The context for this metric</param> /// <param name="name">The metric name</param> /// <param name="eventType">The plural name of the type of events the meter is measuring (e.g., <code>"requests"</code>)</param> /// <param name="unit">The rate unit of the new meter</param> /// <returns></returns> public MeterMetric Meter(string context, string name, string eventType, TimeUnit unit) { var metricName = new MetricName(context, name); IMetric existingMetric; if (_metrics.TryGetValue(metricName, out existingMetric)) { return((MeterMetric)existingMetric); } var metric = MeterMetric.New(eventType, unit); var justAddedMetric = _metrics.GetOrAdd(metricName, metric); return(justAddedMetric == null ? metric : (MeterMetric)justAddedMetric); }
public void MeterCanCalculateMeanRate() { TestClock clock = new TestClock(); TestScheduler scheduler = new TestScheduler(clock); var meter = new MeterMetric(clock, scheduler); meter.Mark(); clock.Advance(TimeUnit.Seconds, 1); meter.Value.MeanRate.Should().Be(1); clock.Advance(TimeUnit.Seconds, 1); meter.Value.MeanRate.Should().Be(0.5); }
public void Dispose() { if (_isDisposed) { return; } #if !RELEASE GC.SuppressFinalize(this); #endif _running.Wait(); try { if (_isDisposed) { return; } _isDisposed = true; if (Operation == TcpConnectionHeaderMessage.OperationTypes.Cluster) { try { TcpClient?.Client?.Disconnect(reuseSocket: false); } catch { // nothing we can do } } SafelyDispose(Stream); SafelyDispose(TcpClient); DocumentDatabase?.RunningTcpConnections.TryRemove(this); Stream = null; TcpClient = null; _bytesReceivedMetric = null; _bytesSentMetric = null; } finally { _running.Release(); }
public void can_report_meters() { var metricsMock = new Mock <IMetrics>(); var clock = new TestClock(); var meter = new MeterMetric(clock); meter.Mark(1); var meterValueSource = new MeterValueSource("test meter", ConstantValue.Provider(meter.Value), Unit.None, TimeUnit.Milliseconds, MetricTags.None); var payloadBuilder = new LineProtocolPayloadBuilder(); var reporter = CreateReporter(payloadBuilder); reporter.StartReportRun(metricsMock.Object); reporter.ReportMetric("test", meterValueSource); payloadBuilder.PayloadFormatted().Should().Be("test__test_meter count.meter=1i,rate1m=0,rate5m=0,rate15m=0,rate.mean=Infinity\n"); }
public void MeterCanComputeRates() { TestClock clock = new TestClock(); TestScheduler scheduler = new TestScheduler(clock); var meter = new MeterMetric(clock, scheduler); meter.Mark(); clock.Advance(TimeUnit.Seconds, 10); meter.Mark(2); var value = meter.Value; value.MeanRate.Should().BeApproximately(0.3, 0.001); value.OneMinuteRate.Should().BeApproximately(0.1840, 0.001); value.FiveMinuteRate.Should().BeApproximately(0.1966, 0.001); value.FifteenMinuteRate.Should().BeApproximately(0.1988, 0.001); }
public void can_report_meters_with_items() { var metricsMock = new Mock <IMetrics>(); var clock = new TestClock(); var meter = new MeterMetric(clock); meter.Mark(new MetricItem().With("item1", "value1"), 1); meter.Mark(new MetricItem().With("item2", "value2"), 1); var meterValueSource = new MeterValueSource("test meter", ConstantValue.Provider(meter.Value), Unit.None, TimeUnit.Milliseconds, MetricTags.None); var payloadBuilder = new LineProtocolPayloadBuilder(); var reporter = CreateReporter(payloadBuilder); reporter.StartReportRun(metricsMock.Object); reporter.ReportMetric("test", meterValueSource); payloadBuilder.PayloadFormatted() .Should() .Be( "test__test_meter__items,item=item1:value1 count.meter=1i,rate1m=0,rate5m=0,rate15m=0,rate.mean=Infinity,percent=50\ntest__test_meter__items,item=item2:value2 count.meter=1i,rate1m=0,rate5m=0,rate15m=0,rate.mean=Infinity,percent=50\ntest__test_meter count.meter=2i,rate1m=0,rate5m=0,rate15m=0,rate.mean=Infinity\n"); }
private void LogMeter(IRequest request, MetricName metricName, MeterMetric metric, long timestamp) { request.AddCounter(new DatadogCounter(_nameFormatter.Format(metricName.Name, _path), metric.Count, timestamp, _globalTags)); }
private void CreateUploadTaskIfNeeded <S, T>( S settings, List <Task> tasks, string backupPath, bool isFullBackup, Func <S, FileStream, Progress, Task> uploadToServer, T uploadStatus, Action <IOperationProgress> onProgress) where S : BackupSettings where T : CloudUploadStatus { if (PeriodicBackupConfiguration.CanBackupUsing(settings) == false) { return; } Debug.Assert(uploadStatus != null); var localUploadStatus = uploadStatus; tasks.Add(Task.Run(async() => { using (localUploadStatus.UpdateStats(isFullBackup)) using (var fileStream = File.OpenRead(backupPath)) { var uploadProgress = localUploadStatus.UploadProgress; localUploadStatus.Skipped = false; uploadProgress.ChangeState(UploadState.PendingUpload); uploadProgress.SetTotal(fileStream.Length); AddInfo($"Starting {uploadStatus.GetType().AssemblyQualifiedName}", onProgress); try { var bytesPutsPerSec = new MeterMetric(); long lastUploadedInBytes = 0; var totalToUpload = new Sparrow.Size(uploadProgress.TotalInBytes, SizeUnit.Bytes).ToString(); var sw = Stopwatch.StartNew(); var progress = new Progress(uploadProgress) { OnUploadProgress = () => { if (sw.ElapsedMilliseconds <= 1000) { return; } var totalUploadedInBytes = uploadProgress.UploadedInBytes; bytesPutsPerSec.MarkSingleThreaded(totalUploadedInBytes - lastUploadedInBytes); lastUploadedInBytes = totalUploadedInBytes; var uploaded = new Sparrow.Size(totalUploadedInBytes, SizeUnit.Bytes); uploadProgress.BytesPutsPerSec = bytesPutsPerSec.MeanRate; AddInfo($"Uploaded: {uploaded} / {totalToUpload}", onProgress); sw.Restart(); } }; await uploadToServer(settings, fileStream, progress); AddInfo($"Total uploaded: {totalToUpload}, " + $"took: {MsToHumanReadableString(uploadProgress.UploadTimeInMs)}", onProgress); } catch (OperationCanceledException e) { // shutting down localUploadStatus.Exception = e.ToString(); throw; } catch (Exception e) { localUploadStatus.Exception = e.ToString(); throw new InvalidOperationException($"Failed to backup to {uploadStatus.GetType().FullName}", e); } finally { uploadProgress.ChangeState(UploadState.Done); } } })); }
public PrefetchingBehavior(PrefetchingUser prefetchingUser, WorkContext context, BaseBatchSizeAutoTuner autoTuner, string prefetchingUserDescription, bool isDefault = false, Func<int> getPrefetchintBehavioursCount = null, Func<PrefetchingSummary> getPrefetcherSummary = null) { this.context = context; this.autoTuner = autoTuner; PrefetchingUser = prefetchingUser; this.userDescription = prefetchingUserDescription; this.IsDefault = isDefault; this.getPrefetchintBehavioursCount = getPrefetchintBehavioursCount ?? (() => 1); this.getPrefetcherSummary = getPrefetcherSummary ?? GetSummary; MemoryStatistics.RegisterLowMemoryHandler(this); LastTimeUsed = DateTime.MinValue; ingestMeterName = "ingest/sec for " + prefetchingUserDescription; returnedDocsMeterName = "returned docs/sec " + prefetchingUserDescription; ingestMeter = context.MetricsCounters.DbMetrics.Meter(MeterContext, ingestMeterName, "In memory documents held by this prefetcher", TimeUnit.Seconds); MetricsTicker.Instance.AddMeterMetric(ingestMeter); returnedDocsMeter = context.MetricsCounters.DbMetrics.Meter(MeterContext, returnedDocsMeterName, "Documents being served by this prefetcher", TimeUnit.Seconds); MetricsTicker.Instance.AddMeterMetric(returnedDocsMeter); if (isDefault) { context.Database.TransactionalStorage.Batch(accessor => { recentEtag = accessor.Staleness.GetMostRecentDocumentEtag(); }); } }
public OwinMetricsTestData() { const int timePerRequest = 100; const string json = "{ 'id': '1'} "; Clock = new TestClock(); var scheduler = new TestScheduler(Clock); TimerMetric = new TimerMetric(SamplingType.SlidingWindow, new MeterMetric(Clock, scheduler), Clock); CounterMetric = new TestCounter(); HistogramMetric = new HistogramMetric(); MeterMetric = new MeterMetric(Clock, scheduler); var server = TestServer.Create(app => { var registery = new TestRegistry { TimerInstance = TimerMetric, CounterInstance = CounterMetric, HistogramInstance = HistogramMetric, MeterInstance = MeterMetric }; OwinMetricsConfig owin = new OwinMetricsConfig(middleware => app.Use(middleware), registery, Metric.Config.HealthStatus); owin.WithRequestMetricsConfig(c => c.RegisterAllMetrics()); app.Run(context => { Clock.Advance(TimeUnit.Milliseconds, timePerRequest); if (context.Request.Path.ToString() == "/test/action") { return context.Response.WriteAsync("response"); } if (context.Request.Path.ToString() == "/test/error") { context.Response.StatusCode = 500; return context.Response.WriteAsync("response"); } if (context.Request.Path.ToString() == "/test/size") { return context.Response.WriteAsync("response"); } if (context.Request.Path.ToString() == "/test/post") { return context.Response.WriteAsync("response"); } context.Response.StatusCode = 404; return context.Response.WriteAsync("not found"); }); }); ExpectedResults = new OwinExpectedMetrics(timePerRequest, 6, 1); server.HttpClient.GetAsync("http://local.test/test/error").Result.StatusCode.Should().Be(HttpStatusCode.InternalServerError); server.HttpClient.GetAsync("http://local.test/test/action").Result.StatusCode.Should().Be(HttpStatusCode.OK); server.HttpClient.GetAsync("http://local.test/test/action").Result.StatusCode.Should().Be(HttpStatusCode.OK); server.HttpClient.GetAsync("http://local.test/test/action").Result.StatusCode.Should().Be(HttpStatusCode.OK); server.HttpClient.GetAsync("http://local.test/test/action").Result.StatusCode.Should().Be(HttpStatusCode.OK); var postContent = new StringContent(json); postContent.Headers.Add("Content-Length", json.Length.ToString()); server.HttpClient.PostAsync("http://local.test/test/post", postContent); }
public void Initialize() { PutsPerSec = new MeterMetric(); BytesPutsPerSec = new MeterMetric(); }
public MeterMetricTests() { this.scheduler = new TestScheduler(this.clock); this.meter = new MeterMetric(this.clock, this.scheduler); }
private void CreateUploadTaskIfNeeded <S, T>(S settings, Action <S, FileStream, Progress> uploadToServer, T uploadStatus, string targetName) where S : BackupSettings where T : CloudUploadStatus { if (PeriodicBackupConfiguration.CanBackupUsing(settings) == false) { return; } Debug.Assert(uploadStatus != null); var localUploadStatus = uploadStatus; var thread = PoolOfThreads.GlobalRavenThreadPool.LongRunning(_ => { try { Thread.CurrentThread.Priority = ThreadPriority.BelowNormal; NativeMemory.EnsureRegistered(); using (localUploadStatus.UpdateStats(_isFullBackup)) using (var fileStream = File.OpenRead(_settings.BackupPath)) { var uploadProgress = localUploadStatus.UploadProgress; try { localUploadStatus.Skipped = false; uploadProgress.ChangeState(UploadState.PendingUpload); uploadProgress.SetTotal(fileStream.Length); AddInfo($"Starting the upload of backup file to {targetName}."); var bytesPutsPerSec = new MeterMetric(); long lastUploadedInBytes = 0; var totalToUpload = new Size(uploadProgress.TotalInBytes, SizeUnit.Bytes).ToString(); var sw = Stopwatch.StartNew(); var progress = new Progress(uploadProgress) { OnUploadProgress = () => { if (sw.ElapsedMilliseconds <= 1000) { return; } var totalUploadedInBytes = uploadProgress.UploadedInBytes; bytesPutsPerSec.MarkSingleThreaded(totalUploadedInBytes - lastUploadedInBytes); lastUploadedInBytes = totalUploadedInBytes; var uploaded = new Size(totalUploadedInBytes, SizeUnit.Bytes); uploadProgress.BytesPutsPerSec = bytesPutsPerSec.MeanRate; AddInfo($"Uploaded: {uploaded} / {totalToUpload}"); sw.Restart(); } }; uploadToServer(settings, fileStream, progress); AddInfo($"Total uploaded: {totalToUpload}, took: {MsToHumanReadableString(uploadProgress.UploadTimeInMs)}"); } finally { uploadProgress.ChangeState(UploadState.Done); } } } catch (Exception e) { var extracted = e.ExtractSingleInnerException(); var error = $"Failed to upload the backup file to {targetName}."; Exception exception = null; if (extracted is OperationCanceledException) { // shutting down or HttpClient timeout exception = TaskCancelToken.Token.IsCancellationRequested ? extracted : new TimeoutException(error, e); } localUploadStatus.Exception = (exception ?? e).ToString(); _exceptions.Add(exception ?? new InvalidOperationException(error, e)); } }, null, $"Upload backup file of database '{_settings.DatabaseName}' to {targetName} (task: '{_settings.TaskName}')"); _threads.Add(thread); }
public void AddMeterMetric(MeterMetric newMeterMetric) { meterMetrics.Add(newMeterMetric); }
public SubscriptionConnectionStats() { DocsRate = new MeterMetric(); BytesRate = new MeterMetric(); AckRate = new MeterMetric(); }
public static void SetMinimalHumaneMeterData(this MeterMetric self, string name, DynamicJsonValue obj) { obj["HumaneTotal" + name] = Sizes.Humane(self.Count); obj["Humane" + name + "Rate"] = Sizes.Humane((long)self.OneMinuteRate); }
public static void SetMinimalMeterData(this MeterMetric self, string name, DynamicJsonValue obj) { obj["Total" + name] = self.Count; obj[name + "Rate"] = Math.Round(self.OneMinuteRate, 2); }
public void RemoveMeterMetric(MeterMetric meterMetricToRemove) { meterMetrics.TryRemove(meterMetricToRemove); }