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" } });
}
