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));
            });
        }
示例#2
0
 static JsonExtensions()
 {
     JsonStreamDeserializationsPerSecond  = new MeterMetric(MetricsScheduler.Instance);
     JsonStreamDeserializedBytesPerSecond = new MeterMetric(MetricsScheduler.Instance);
     JsonStreamSerializationsPerSecond    = new MeterMetric(MetricsScheduler.Instance);
     JsonStreamSerializedBytesPerSecond   = new MeterMetric(MetricsScheduler.Instance);
 }
示例#3
0
        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 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));
            });
        }
        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));
        }
示例#7
0
 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);
 }
示例#8
0
 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("}");
 }
示例#9
0
        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 void CreateNew()
 {
     RequestsMeter                = new MeterMetric();
     RequestsPerSecondCounter     = new MeterMetric();
     DocPutsPerSecond             = new MeterMetric();
     IndexedPerSecond             = new MeterMetric();
     MapReduceMappedPerSecond     = new MeterMetric();
     MapReduceReducedPerSecond    = new MeterMetric();
     SqlReplicationBatchSizeMeter = new MeterMetric();
 }
示例#11
0
 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)
     });
 }
示例#12
0
        public TcpConnectionOptions()
        {
            _bytesReceivedMetric = new MeterMetric();
            _bytesSentMetric     = new MeterMetric();

            MetricsScheduler.Instance.StartTickingMetric(_bytesSentMetric);
            MetricsScheduler.Instance.StartTickingMetric(_bytesReceivedMetric);
            _connectedAt = DateTime.UtcNow;

            Id = Interlocked.Increment(ref _sequence);
        }
示例#13
0
 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),
     });
 }
示例#14
0
 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),
     });
 }
示例#15
0
        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),
            });
        }
示例#17
0
        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);
        }
示例#18
0
        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
        }
示例#19
0
        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);
        }
示例#20
0
        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);
        }
示例#21
0
        /// <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);
        }
示例#22
0
        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);
        }
示例#23
0
        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);
        }
示例#24
0
        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();
            }
示例#25
0
        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");
        }
示例#26
0
        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);
        }
示例#27
0
        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);
        }
示例#28
0
        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));
 }
示例#30
0
        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);
                        }
                    }
            }));
        }
示例#31
0
        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();
                });
            }
        }
示例#32
0
        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);
        }
示例#33
0
 public void Initialize()
 {
     PutsPerSec      = new MeterMetric();
     BytesPutsPerSec = new MeterMetric();
 }
示例#34
0
 public MeterMetricTests()
 {
     this.scheduler = new TestScheduler(this.clock);
     this.meter = new MeterMetric(this.clock, this.scheduler);
 }
示例#35
0
        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);
        }
示例#36
0
 public void AddMeterMetric(MeterMetric newMeterMetric)
 {
     meterMetrics.Add(newMeterMetric);
 }
示例#37
0
 public SubscriptionConnectionStats()
 {
     DocsRate  = new MeterMetric();
     BytesRate = new MeterMetric();
     AckRate   = new MeterMetric();
 }
示例#38
0
 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);
 }
示例#39
0
 public static void SetMinimalMeterData(this MeterMetric self, string name, DynamicJsonValue obj)
 {
     obj["Total" + name] = self.Count;
     obj[name + "Rate"]  = Math.Round(self.OneMinuteRate, 2);
 }
示例#40
0
 public void RemoveMeterMetric(MeterMetric meterMetricToRemove)
 {
     meterMetrics.TryRemove(meterMetricToRemove);
 }