public static IDisposable Latency(MetricTags tags, TimerOptions options) { Preconditions.CheckNotNull(tags); Preconditions.CheckNotNull(options); return(MetricsCollector.Map(mroot => mroot.Measure.Timer.Time(options, tags) as IDisposable).GetOrElse(() => new NullDisposable())); }
internal AgentComponents( IApmLogger logger, IConfigurationReader configurationReader, IPayloadSender payloadSender, IMetricsCollector metricsCollector, ICurrentExecutionSegmentsContainer currentExecutionSegmentsContainer, ICentralConfigFetcher centralConfigFetcher ) { var tempLogger = logger ?? ConsoleLogger.LoggerOrDefault(configurationReader?.LogLevel); ConfigurationReader = configurationReader ?? new EnvironmentConfigurationReader(tempLogger); Logger = logger ?? ConsoleLogger.LoggerOrDefault(ConfigurationReader.LogLevel); Service = Service.GetDefaultService(ConfigurationReader, Logger); var systemInfoHelper = new SystemInfoHelper(Logger); var system = systemInfoHelper.ParseSystemInfo(); ConfigStore = new ConfigStore(new ConfigSnapshotFromReader(ConfigurationReader, "local"), Logger); PayloadSender = payloadSender ?? new PayloadSenderV2(Logger, ConfigStore.CurrentSnapshot, Service, system); MetricsCollector = metricsCollector ?? new MetricsCollector(Logger, PayloadSender, ConfigurationReader); MetricsCollector.StartCollecting(); CentralConfigFetcher = centralConfigFetcher ?? new CentralConfigFetcher(Logger, ConfigStore, Service); TracerInternal = new Tracer(Logger, Service, PayloadSender, ConfigStore, currentExecutionSegmentsContainer ?? new CurrentExecutionSegmentsContainer(Logger)); }
public void CollectAllMetrics_ShouldDisableProvider_WhenSamplesAreInvalid(List <MetricSample> samples) { const int iterations = MetricsCollector.MaxTryWithoutSuccess * 2; // Arrange var logger = new NoopLogger(); var mockPayloadSender = new MockPayloadSender(); using var metricsCollector = new MetricsCollector(logger, mockPayloadSender, new ConfigStore(new MockConfigSnapshot(logger, "Information"), _logger)); var metricsProviderMock = new Mock <IMetricsProvider>(); metricsProviderMock.Setup(x => x.IsMetricAlreadyCaptured).Returns(true); metricsProviderMock .Setup(x => x.GetSamples()) .Returns(() => samples); metricsProviderMock.SetupProperty(x => x.ConsecutiveNumberOfFailedReads); metricsCollector.MetricsProviders.Clear(); metricsCollector.MetricsProviders.Add(metricsProviderMock.Object); // Act foreach (var _ in Enumerable.Range(0, iterations)) { metricsCollector.CollectAllMetrics(); } // Assert mockPayloadSender.Metrics.Should().BeEmpty(); metricsProviderMock.Verify(x => x.GetSamples(), Times.Exactly(MetricsCollector.MaxTryWithoutSuccess)); }
public static void SetGauge(GaugeOptions options, long amount) { Preconditions.CheckNotNull(options); Preconditions.CheckNotNull(amount); MetricsCollector.ForEach(mroot => { mroot.Measure.Gauge.SetValue(options, amount); }); }
internal static MetricsReport AnalyseFile(string asmFile) { var mc = new MetricsCollector(); mc.Analyze(asmFile); return(mc.Report); }
public static void CountDecrement(CounterOptions options, long amount) { Preconditions.CheckNotNull(options); Preconditions.CheckNotNull(amount); MetricsCollector.ForEach(mroot => { mroot.Measure.Counter.Decrement(options, amount); }); }
public StopwatchTimer(MetricsCollector collector, string measurement, IReadOnlyDictionary<string, string> tags = null) { _collector = collector; _measurement = measurement; _tags = tags; _stopwatch.Start(); }
public void CollectAllMetrics_ShouldNotDisableProvider_WhenAnyValueIsSamplesIsValid() { const int iterations = MetricsCollector.MaxTryWithoutSuccess * 2; // Arrange var logger = new NoopLogger(); var mockPayloadSender = new MockPayloadSender(); using var metricsCollector = new MetricsCollector(logger, mockPayloadSender, new ConfigStore(new MockConfigSnapshot(logger, "Information"), _logger)); var metricsProviderMock = new Mock <IMetricsProvider>(); metricsProviderMock.Setup(x => x.IsMetricAlreadyCaptured).Returns(true); metricsProviderMock.Setup(x => x.GetSamples()) .Returns(() => new List <MetricSample> { new MetricSample("key1", double.NaN), new MetricSample("key2", 0.95) }); metricsProviderMock.SetupProperty(x => x.ConsecutiveNumberOfFailedReads); metricsCollector.MetricsProviders.Clear(); metricsCollector.MetricsProviders.Add(metricsProviderMock.Object); // Act foreach (var _ in Enumerable.Range(0, iterations)) { metricsCollector.CollectAllMetrics(); } // Assert mockPayloadSender.Metrics.Count.Should().Be(iterations); mockPayloadSender.Metrics.Should().OnlyContain(x => x.Samples.Count() == 1); metricsProviderMock.Verify(x => x.GetSamples(), Times.Exactly(iterations)); }
/// <summary>Call getMetrics on source and get a record builder mock to verify</summary> /// <param name="source">the metrics source</param> /// <param name="all">if true, return all metrics even if not changed</param> /// <returns>the record builder mock to verify</returns> public static MetricsRecordBuilder GetMetrics(MetricsSource source, bool all) { MetricsRecordBuilder rb = MockMetricsRecordBuilder(); MetricsCollector mc = rb.Parent(); source.GetMetrics(mc, all); return(rb); }
/// <summary> /// Creates a new downstream connected server group /// </summary> /// <param name="name">The name of the group.</param> /// <param name="visibility">The groups visibility.</param> /// <param name="threadHelper">The server's thread helper.</param> /// <param name="logger">The logger to use.</param> /// <param name="remoteServerLogger">The logger to pass to created remote servers.</param> /// <param name="metricsCollector">The metrics collector to use.</param> /// <param name="remoteServerMetricsCollector">The metrics collector to pass to created remote servers.</param> internal DownstreamServerGroup(string name, ServerVisibility visibility, DarkRiftThreadHelper threadHelper, Logger logger, Logger remoteServerLogger, MetricsCollector metricsCollector, MetricsCollector remoteServerMetricsCollector) : base(name, visibility, threadHelper, logger, metricsCollector) { this.threadHelper = threadHelper; this.logger = logger; this.remoteServerLogger = remoteServerLogger; this.remoteServerMetricsCollector = remoteServerMetricsCollector; }
//generate a new key per each call public virtual void GetMetrics(MetricsCollector collector, bool all) { MetricsRecordBuilder rb = collector.AddRecord("purgablesource").SetContext("test" ); this.lastKeyName = "key" + this.nextKey++; rb.AddGauge(Interns.Info(this.lastKeyName, "desc"), 1); }
public virtual void StartService(params string[] args) { l_logger.Debug("StartService() begin"); l_metricCollector = new MetricsCollector(); l_metricCollector.ConfigureAll(); l_metricCollector.StartAll(); l_logger.Debug("StartService() return"); }
/// <summary> /// Creates an <see cref="IHistogramMetric"/> that writes to this writer. /// </summary> /// <param name="metricsCollector">The <see cref="MetricsCollector"/> used to create the metric.</param> /// <param name="name">The name of the metric.</param> /// <param name="description">The description of the metric.</param> /// <param name="buckets">The upper bounds of the buckets to aggregate into in ascending order, a bucket with value <see cref="double.PositiveInfinity"/> is always present.</param> /// <returns>The created <see cref="IHistogramMetric"/>.</returns> internal IHistogramMetric CreateHistogram(MetricsCollector metricsCollector, string name, string description, double[] buckets) { string formattedSumMetric = FormatMetric(metricsCollector.Prefix, name + "_sum"); string formattedCountMetric = FormatMetric(metricsCollector.Prefix, name + "_count"); string[] formattedBuckets = buckets.Select(b => FormatMetric(metricsCollector.Prefix, name + "_bucket", b)).ToArray(); return(GetOrCreateHistogram(name, description, buckets, formattedSumMetric, formattedCountMetric, formattedBuckets)); }
/// <inheritdoc /> protected internal override TaggedMetricBuilder <IGaugeMetric> CreateGauge(MetricsCollector metricsCollector, string name, string description, string[] tags) { return(new TaggedMetricBuilder <IGaugeMetric>(tags.Length, tagValues => { string formattedMetric = FormatMetric(metricsCollector.Prefix, name, tags, tagValues); return GetOrCreateGauge(name, description, formattedMetric); })); }
public void MetricsCollectorWithNoopConfigReader() { var noopConfigReader = new Mock <IConfigurationReader>(); noopConfigReader.SetupGet(n => n.MetricsIntervalInMilliseconds).Returns(1); var _ = new MetricsCollector(new NoopLogger(), new NoopPayloadSender(), new ConfigStore(new ConfigSnapshotFromReader(noopConfigReader.Object, ""), new NoopLogger())); }
public void CollectAllMetrics() { var mockPayloadSender = new MockPayloadSender(); using (var mc = new MetricsCollector(_logger, mockPayloadSender, new ConfigStore(new MockConfigSnapshot(_logger), _logger))) mc.CollectAllMetrics(); mockPayloadSender.Metrics.Should().NotBeEmpty(); }
/// <summary> /// Constructor for a network listener. /// </summary> /// <param name="pluginLoadData">The load data for the listener plugin.</param> public NetworkListener(NetworkListenerLoadData pluginLoadData) : base(pluginLoadData) { Address = pluginLoadData.Address; Port = pluginLoadData.Port; #if PRO MetricsManager = pluginLoadData.MetricsManager; MetricsCollector = pluginLoadData.MetricsCollector; #endif }
/// <summary> /// Creates a tagged metric builder for an <see cref="IHistogramMetric"/> that writes to this writer. /// </summary> /// <param name="metricsCollector">The <see cref="MetricsCollector"/> used to create the metric.</param> /// <param name="name">The name of the metric.</param> /// <param name="description">The description of the metric.</param> /// <param name="buckets">The upper bounds of the buckets to aggregate into in ascending order, a bucket with value <see cref="double.PositiveInfinity"/> is always present.</param> /// <param name="tags">The set of tags describing this metric as colon separated pairs.</param> /// <returns>The created <see cref="IHistogramMetric"/>.</returns> internal TaggedMetricBuilder <IHistogramMetric> CreateHistogram(MetricsCollector metricsCollector, string name, string description, double[] buckets, string[] tags) { return(new TaggedMetricBuilder <IHistogramMetric>(tags.Length, tagValues => { string formattedSumMetric = FormatMetric(metricsCollector.Prefix, name + "_sum", tags, tagValues); string formattedCountMetric = FormatMetric(metricsCollector.Prefix, name + "_count", tags, tagValues); string[] formattedBuckets = buckets.Select(b => FormatMetric(metricsCollector.Prefix, name + "_bucket", tags, tagValues, b)).ToArray(); return GetOrCreateHistogram(name, description, buckets, formattedSumMetric, formattedCountMetric, formattedBuckets); })); }
public void CollectAllMetrics() { var mockPayloadSender = new MockPayloadSender(); var testLogger = new TestLogger(); var mc = new MetricsCollector(testLogger, mockPayloadSender, new TestAgentConfigurationReader(testLogger)); mc.CollectAllMetrics(); mockPayloadSender.Metrics.Should().NotBeEmpty(); }
public virtual void GetMetrics(MetricsCollector collector, bool all) { MetricsRecordBuilder rb = collector.AddRecord(JvmMetricsInfo.JvmMetrics).SetContext ("jvm").Tag(MsInfo.ProcessName, processName).Tag(MsInfo.SessionId, sessionId); GetMemoryUsage(rb); GetGcUsage(rb); GetThreadUsage(rb); GetEventCounters(rb); }
public StatisticsProvider(InfluxDbConfiguration configuration) { configuration.ShouldNotBeNull(); _configuration = configuration; _collector = Metrics.Collector = new CollectorConfiguration() .WriteTo.InfluxDB(configuration.Url, configuration.Database) .CreateCollector(); _httpClient = new HttpClient(); }
public override void SendInflux(MetricsCollector collector, string prefix) { collector.Write( $"{prefix}{UID}", new Dictionary <string, object> { { "moisture", MoistureFraction } } ); }
public static MetricsRecordBuilder MockMetricsRecordBuilder() { MetricsCollector mc = Org.Mockito.Mockito.Mock <MetricsCollector>(); MetricsRecordBuilder rb = Org.Mockito.Mockito.Mock <MetricsRecordBuilder>(new _Answer_66 (mc)); Org.Mockito.Mockito.When(mc.AddRecord(AnyString())).ThenReturn(rb); Org.Mockito.Mockito.When(mc.AddRecord(AnyInfo())).ThenReturn(rb); return(rb); }
public void FlushedMetricDoesNotHaveData() { var collector = new MetricsCollector(); collector.Record("counter", 10M, Unit.Minute); collector.FlushToString(); Assert.Equal(string.Empty, collector.GetMetrics()["counter"].FlushToString()); }
public virtual void TestClasses() { MetricsRecordBuilder rb = MetricsAsserts.GetMetrics(MetricsAnnotations.MakeSource (new TestMetricsAnnotations.MyMetrics3())); MetricsCollector collector = rb.Parent(); Org.Mockito.Mockito.Verify(collector).AddRecord(Interns.Info("MyMetrics3", "My metrics" )); Org.Mockito.Mockito.Verify(rb).Add(Interns.Tag(MsInfo.Context, "foo")); }
public void CollectAllMetrics2X() { var noopLogger = new NoopLogger(); var mockPayloadSender = new MockPayloadSender(); using (var collector = new MetricsCollector(noopLogger, mockPayloadSender, new TestAgentConfigurationReader(noopLogger))) { collector.CollectAllMetrics(); collector.CollectAllMetrics(); } }
public void CollectAllMetrics2X() { var noopLogger = new NoopLogger(); var mockPayloadSender = new MockPayloadSender(); using (var collector = new MetricsCollector(noopLogger, mockPayloadSender, new MockConfigSnapshot(noopLogger))) { collector.CollectAllMetrics(); collector.CollectAllMetrics(); } }
public override void SendInflux(MetricsCollector collector, string prefix) { collector.Write( $"{prefix}{UID}", new Dictionary <string, object> { { "light_raw", RawLightValue }, { "light_norm", NormalizedLightValue } } ); }
public void CrossMetricMergesAreNotAllowed() { var collector = new MetricsCollector(); collector.IncrementCounter("Counter", 1); var collector2 = new MetricsCollector(); collector2.Record("Counter", 10M, Unit.Second); collector.Merge(collector2); }
public void ShouldNotCrashWhenEventRecordAfterDisposed() { var sink = new DictionarySink(); var e = new MetricsCollector(sink, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(5)); e.IncrementCounter("myCounter"); e.Dispose(); Assert.Single(sink.Counters); e.IncrementCounter("myCounter"); }
public MempoolClient(MetricsConfiguration configuration, MetricsCollector metrics) { this.configuration = configuration; this.metrics = metrics; this.client = new RestClient(configuration.MempoolApiUri) { Timeout = 8000 }; this.feesRequest = new RestRequest("fees/recommended", DataFormat.Json); }
static void Main(string[] args) { Debug.Listeners.Add(new TextWriterTraceListener(Console.Out)); Debug.AutoFlush = true; Func<Uri> getUrl = () => { return new Uri("http://192.168.99.100:8070/"); }; // for testing minimum event threshold // AggregateGauge.GetDefaultMinimumEvents = () => 306000; var options = new BosunOptions() { MetricsNamePrefix = "bret.", GetBosunUrl = getUrl, ThrowOnPostFail = true, ReportingInterval = 5, PropertyToTagName = NameTransformers.CamelToLowerSnakeCase, TagValueConverter = (name, value) => name == "converted" ? value.ToLowerInvariant() : value, DefaultTags = new Dictionary<string, string> { {"host", NameTransformers.Sanitize(Environment.MachineName.ToLower())} } }; var collector = new MetricsCollector(options); collector.OnBackgroundException += exception => { Console.WriteLine("Hey, there was an exception."); Console.WriteLine(exception); }; collector.BeforeSerialization += () => Debug.WriteLine("BosunReporter: Running metrics snapshot."); collector.AfterSerialization += info => Debug.WriteLine($"BosunReporter: Metric Snapshot took {info.MillisecondsDuration.ToString("0.##")}ms"); collector.AfterPost += info => Debug.WriteLine($"BosunReporter: {info.Count} metrics posted to Bosun in {info.MillisecondsDuration.ToString("0.##")}ms ({(info.Successful ? "SUCCESS" : "FAILED")})"); collector.BindMetric("my_counter", "increments", typeof(TestCounter)); var counter = collector.GetMetric<TestCounter>("my_counter", "increments", "This is meaningless."); counter.Increment(); counter.Increment(); var gauge = collector.CreateMetric("gauge", "watts", "Some description of a gauge.", new TestAggregateGauge("1")); if (gauge != collector.GetMetric("gauge", "watts", null, new TestAggregateGauge("1"))) throw new Exception("WAT?"); try { collector.CreateMetric("gauge", "watts", "Some description of a gauge.", new TestAggregateGauge("1")); } catch(Exception) { goto SKIP_EXCEPTION; } throw new Exception("CreateMetric should have failed for duplicate metric."); SKIP_EXCEPTION: var gauge2 = collector.GetMetric<AggregateGauge>("gauge2", "newtons", "Number of newtons currently applied."); for (var i = 0; i < 6; i++) { new Thread(Run).Start(new Tuple<AggregateGauge, AggregateGauge, int>(gauge, gauge2, i)); } var enumCounter = collector.GetMetricGroup<SomeEnum, EnumCounter>("some_enum", "things", "Some of something"); enumCounter.PopulateFromEnum(); Type t; string u; if (collector.TryGetMetricInfo("gauge2", out t, out u)) { Console.WriteLine(t); Console.WriteLine(u); } else { Console.WriteLine("NOOOOO!!!!!"); } var si = 0; var snapshot = collector.GetMetric("my_snapshot", "snappys", "Snap snap snap.", new SnapshotGauge(() => ++si % 5)); var group = collector.GetMetricGroup<string, TestGroupGauge>("test_group", "tests", "These gauges are for testing."); group.Add("low").Description = "Low testing."; group.Add("medium").Description = "Medium testing."; group.Add("high").Description = "High testing."; var sampler = collector.GetMetric("sampler", "french fries", "Collect them all.", new SamplingGauge()); var eventGauge = collector.GetMetric("event", "count", "How many last time.", new EventGauge()); var converted = collector.CreateMetric("convert_test", "units", "Checking to see if the tag value converter works.", new ConvertedTagsTestCounter("ThingsAndStuff")); var sai = 0; var random = new Random(); _samplerTimer = new Timer(o => { sampler.Record(++sai%35); eventGauge.Record(sai%35); group["low"].Record(random.Next(0, 10)); group["medium"].Record(random.Next(10, 20)); group["high"].Record(random.Next(20, 30)); enumCounter[SomeEnum.One].Increment(); enumCounter[SomeEnum.Two].Increment(2); enumCounter[SomeEnum.Three].Increment(3); enumCounter[SomeEnum.Four].Increment(4); converted.Increment(); if (sai == 40) { collector.Shutdown(); Environment.Exit(0); } }, null, 1000, 1000); Thread.Sleep(4000); collector.UpdateDefaultTags(new Dictionary<string, string> { { "host", NameTransformers.Sanitize(Environment.MachineName.ToLower()) } }); // Thread.Sleep(4000); // collector.UpdateDefaultTags(new Dictionary<string, string>() { { "host", "test_env" } }); }