public EventuousMetrics() { _meter = EventuousDiagnostics.GetMeter(MeterName); var eventStoreMetric = _meter.CreateHistogram <double>( Constants.Components.EventStore, "ms", "Event store operation duration, milliseconds" ); var appServiceMetric = _meter.CreateHistogram <double>( Constants.Components.AppService, "ms", "Application service operation duration, milliseconds" ); _listener = new ActivityListener { ShouldListenTo = x => x.Name == EventuousDiagnostics.InstrumentationName, Sample = (ref ActivityCreationOptions <ActivityContext> _) => ActivitySamplingResult.AllData, ActivityStopped = Record }; ActivitySource.AddActivityListener(_listener); void Record(Activity activity) { var dot = activity.OperationName.IndexOf('.'); if (dot == -1) { return; } var prefix = activity.OperationName[..dot];
private void MultithreadedHistogramTest <T>(long[] expected, T[] values) where T : struct, IComparable { var bucketCounts = new long[11]; var metricReader = new BaseExportingMetricReader(new TestExporter <Metric>(batch => { foreach (var metric in batch) { foreach (var metricPoint in metric.GetMetricPoints()) { bucketCounts = metricPoint.GetHistogramBuckets().RunningBucketCounts; } } })); using var meter = new Meter($"{Utils.GetCurrentMethodName()}.{typeof(T).Name}"); using var meterProvider = Sdk.CreateMeterProviderBuilder() .AddMeter(meter.Name) .AddReader(metricReader) .Build(); var argsToThread = new UpdateThreadArguments <T> { Instrument = meter.CreateHistogram <T>("histogram"), MreToBlockUpdateThread = new ManualResetEvent(false), MreToEnsureAllThreadsStart = new ManualResetEvent(false), ValuesToRecord = values, }; Thread[] t = new Thread[numberOfThreads]; for (int i = 0; i < numberOfThreads; i++) { t[i] = new Thread(HistogramUpdateThread <T>); t[i].Start(argsToThread); } argsToThread.MreToEnsureAllThreadsStart.WaitOne(); Stopwatch sw = Stopwatch.StartNew(); argsToThread.MreToBlockUpdateThread.Set(); for (int i = 0; i < numberOfThreads; i++) { t[i].Join(); } this.output.WriteLine($"Took {sw.ElapsedMilliseconds} msecs. Total threads: {numberOfThreads}, each thread doing {numberOfMetricUpdateByEachThread * values.Length} recordings."); metricReader.Collect(); Assert.Equal(expected, bucketCounts); }
public void ApplicationInsights_Metrics_Collection_Raises_Histogram_Metrics() { // arrange const string gateway = "foogateway"; using var meter = new Meter("LoRaWan", "1.0"); const int value = 1; var histogram = meter.CreateHistogram <int>(HistogramMetric.Name); // act this.applicationInsightsMetricExporter.Start(); histogram.Record(value, KeyValuePair.Create(MetricRegistry.ConcentratorIdTagName, (object)gateway)); // assert this.trackValueMock.Verify(me => me.Invoke(It.Is <Metric>(m => m.Identifier.MetricNamespace == MetricRegistry.Namespace && m.Identifier.MetricId == HistogramMetric.Name), value, new[] { gateway }), Times.Once); }
private static string WriteHistogram(Meter meter, KeyValuePair <string, object>[] tags, string tagsExpected) { var histogram = meter.CreateHistogram <long>("histogram_name"); histogram.Record(100, tags); histogram.Record(18, tags); return("# TYPE histogram_name histogram\nhistogram_name_sum{key1=\"value1\",key2=\"value2\"} 118 1633041000000\n" + "histogram_name_count{key1=\"value1\",key2=\"value2\"} 2 1633041000000\n" + "histogram_name_bucket{key1=\"value1\",key2=\"value2\",le=\"0\"} 0 1633041000000\n" + "histogram_name_bucket{key1=\"value1\",key2=\"value2\",le=\"5\"} 0 1633041000000\n" + "histogram_name_bucket{key1=\"value1\",key2=\"value2\",le=\"10\"} 0 1633041000000\n" + "histogram_name_bucket{key1=\"value1\",key2=\"value2\",le=\"25\"} 1 1633041000000\n" + "histogram_name_bucket{key1=\"value1\",key2=\"value2\",le=\"50\"} 1 1633041000000\n" + "histogram_name_bucket{key1=\"value1\",key2=\"value2\",le=\"75\"} 1 1633041000000\n" + "histogram_name_bucket{key1=\"value1\",key2=\"value2\",le=\"100\"} 2 1633041000000\n" + "histogram_name_bucket{key1=\"value1\",key2=\"value2\",le=\"250\"} 2 1633041000000\n" + "histogram_name_bucket{key1=\"value1\",key2=\"value2\",le=\"500\"} 2 1633041000000\n" + "histogram_name_bucket{key1=\"value1\",key2=\"value2\",le=\"1000\"} 2 1633041000000\n" + "histogram_name_bucket{key1=\"value1\",key2=\"value2\",le=\"+Inf\"} 2 1633041000000\n"); }
public MessageDispatcher( NetworkServerConfiguration configuration, ILoRaDeviceRegistry deviceRegistry, ILoRaDeviceFrameCounterUpdateStrategyProvider frameCounterUpdateStrategyProvider, IJoinRequestMessageHandler joinRequestHandler, ILoggerFactory loggerFactory, ILogger <MessageDispatcher> logger, Meter meter) { this.configuration = configuration ?? throw new ArgumentNullException(nameof(configuration)); this.deviceRegistry = deviceRegistry; this.frameCounterUpdateStrategyProvider = frameCounterUpdateStrategyProvider; // Register frame counter initializer // It will take care of seeding ABP devices created here for single gateway scenarios this.deviceRegistry.RegisterDeviceInitializer(new FrameCounterLoRaDeviceInitializer(configuration.GatewayID, frameCounterUpdateStrategyProvider)); this.joinRequestHandler = joinRequestHandler; this.loggerFactory = loggerFactory; this.logger = logger; this.d2cMessageDeliveryLatencyHistogram = meter?.CreateHistogram <double>(MetricRegistry.D2CMessageDeliveryLatency); }
public void When_Histogram_Series_Is_Recorded_Should_Export_To_Prometheus() { // arrange const string gatewayId = "fooGateway"; var values = new[] { 1, 3, 10, -2 }; this.prometheusMetricExporter.Start(); // act using var meter = new Meter("LoRaWan", "1.0"); var histogram = meter.CreateHistogram <int>(Histogram.Name); foreach (var value in values) { histogram.Record(value, KeyValuePair.Create(MetricRegistry.ConcentratorIdTagName, (object?)gatewayId)); } // assert foreach (var value in values) { this.recordHistogramMock.Verify(c => c.Invoke(Histogram.Name, new[] { gatewayId }, value), Times.Once); } }
internal static object Run(MetricsOptions options) { using var meter = new Meter("TestMeter"); var providerBuilder = Sdk.CreateMeterProviderBuilder() .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("myservice")) .AddMeter(meter.Name); // All instruments from this meter are enabled. if (options.UseExporter.ToLower() == "otlp") { /* * Prerequisite to run this example: * Set up an OpenTelemetry Collector to run on local docker. * * Open a terminal window at the examples/Console/ directory and * launch the OpenTelemetry Collector with an OTLP receiver, by running: * * - On Unix based systems use: * docker run --rm -it -p 4317:4317 -v $(pwd):/cfg otel/opentelemetry-collector:0.33.0 --config=/cfg/otlp-collector-example/config.yaml * * - On Windows use: * docker run --rm -it -p 4317:4317 -v "%cd%":/cfg otel/opentelemetry-collector:0.33.0 --config=/cfg/otlp-collector-example/config.yaml * * Open another terminal window at the examples/Console/ directory and * launch the OTLP example by running: * * dotnet run metrics --useExporter otlp * * The OpenTelemetry Collector will output all received metrics to the stdout of its terminal. * */ // Adding the OtlpExporter creates a GrpcChannel. // This switch must be set before creating a GrpcChannel/HttpClient when calling an insecure gRPC service. // See: https://docs.microsoft.com/aspnet/core/grpc/troubleshoot#call-insecure-grpc-services-with-net-core-client AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true); providerBuilder .AddOtlpExporter(o => { o.MetricExportIntervalMilliseconds = options.DefaultCollectionPeriodMilliseconds; o.AggregationTemporality = options.IsDelta ? AggregationTemporality.Delta : AggregationTemporality.Cumulative; }); } else { providerBuilder .AddConsoleExporter(o => { o.MetricExportIntervalMilliseconds = options.DefaultCollectionPeriodMilliseconds; o.AggregationTemporality = options.IsDelta ? AggregationTemporality.Delta : AggregationTemporality.Cumulative; }); } using var provider = providerBuilder.Build(); Counter <int> counter = null; if (options.FlagCounter ?? true) { counter = meter.CreateCounter <int>("counter", "things", "A count of things"); } Histogram <int> histogram = null; if (options.FlagHistogram ?? false) { histogram = meter.CreateHistogram <int>("histogram"); } if (options.FlagGauge ?? false) { var observableCounter = meter.CreateObservableGauge("gauge", () => { return(new List <Measurement <int> >() { new Measurement <int>( (int)Process.GetCurrentProcess().PrivateMemorySize64, new KeyValuePair <string, object>("tag1", "value1")), }); }); } var cts = new CancellationTokenSource(); var tasks = new List <Task>(); for (int i = 0; i < options.NumTasks; i++) { var taskno = i; tasks.Add(Task.Run(() => { System.Console.WriteLine($"Task started {taskno + 1}/{options.NumTasks}."); var loops = 0; while (!cts.IsCancellationRequested) { if (options.MaxLoops > 0 && loops >= options.MaxLoops) { break; } histogram?.Record(10); histogram?.Record( 100, new KeyValuePair <string, object>("tag1", "value1")); histogram?.Record( 200, new KeyValuePair <string, object>("tag1", "value2"), new KeyValuePair <string, object>("tag2", "value2")); histogram?.Record( 100, new KeyValuePair <string, object>("tag1", "value1")); histogram?.Record( 200, new KeyValuePair <string, object>("tag2", "value2"), new KeyValuePair <string, object>("tag1", "value2")); counter?.Add(10); counter?.Add( 100, new KeyValuePair <string, object>("tag1", "value1")); counter?.Add( 200, new KeyValuePair <string, object>("tag1", "value2"), new KeyValuePair <string, object>("tag2", "value2")); counter?.Add( 100, new KeyValuePair <string, object>("tag1", "value1")); counter?.Add( 200, new KeyValuePair <string, object>("tag2", "value2"), new KeyValuePair <string, object>("tag1", "value2")); loops++; } })); } cts.CancelAfter(options.RunTime); System.Console.WriteLine($"Wait for {options.RunTime} milliseconds."); while (!cts.IsCancellationRequested) { Task.Delay(1000).Wait(); } Task.WaitAll(tasks.ToArray()); return(null); }
public void ViewToProduceCustomHistogramBound() { using var meter = new Meter(Utils.GetCurrentMethodName()); var exportedItems = new List <Metric>(); var boundaries = new double[] { 10, 20 }; using var meterProvider = Sdk.CreateMeterProviderBuilder() .AddMeter(meter.Name) .AddView("MyHistogram", new ExplicitBucketHistogramConfiguration() { Name = "MyHistogramDefaultBound" }) .AddView("MyHistogram", new ExplicitBucketHistogramConfiguration() { Boundaries = boundaries }) .AddInMemoryExporter(exportedItems) .Build(); var histogram = meter.CreateHistogram <long>("MyHistogram"); histogram.Record(-10); histogram.Record(0); histogram.Record(1); histogram.Record(9); histogram.Record(10); histogram.Record(11); histogram.Record(19); meterProvider.ForceFlush(MaxTimeToAllowForFlush); Assert.Equal(2, exportedItems.Count); var metricDefault = exportedItems[0]; var metricCustom = exportedItems[1]; Assert.Equal("MyHistogramDefaultBound", metricDefault.Name); Assert.Equal("MyHistogram", metricCustom.Name); List <MetricPoint> metricPointsDefault = new List <MetricPoint>(); foreach (ref readonly var mp in metricDefault.GetMetricPoints()) { metricPointsDefault.Add(mp); } Assert.Single(metricPointsDefault); var histogramPoint = metricPointsDefault[0]; var count = histogramPoint.GetHistogramCount(); var sum = histogramPoint.GetHistogramSum(); Assert.Equal(40, sum); Assert.Equal(7, count); int index = 0; int actualCount = 0; var expectedBucketCounts = new long[] { 2, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0 }; foreach (var histogramMeasurement in histogramPoint.GetHistogramBuckets()) { Assert.Equal(expectedBucketCounts[index], histogramMeasurement.BucketCount); index++; actualCount++; } Assert.Equal(Metric.DefaultHistogramBounds.Length + 1, actualCount); List <MetricPoint> metricPointsCustom = new List <MetricPoint>(); foreach (ref readonly var mp in metricCustom.GetMetricPoints()) { metricPointsCustom.Add(mp); } Assert.Single(metricPointsCustom); histogramPoint = metricPointsCustom[0]; count = histogramPoint.GetHistogramCount(); sum = histogramPoint.GetHistogramSum(); Assert.Equal(40, sum); Assert.Equal(7, count); index = 0; actualCount = 0; expectedBucketCounts = new long[] { 5, 2, 0 }; foreach (var histogramMeasurement in histogramPoint.GetHistogramBuckets()) { Assert.Equal(expectedBucketCounts[index], histogramMeasurement.BucketCount); index++; actualCount++; } Assert.Equal(boundaries.Length + 1, actualCount); }
public void ViewConflict_TwoIdenticalInstruments_TwoViews_DifferentHistogramBounds() { var exportedItems = new List <Metric>(); using var meter = new Meter($"{Utils.GetCurrentMethodName()}"); var meterProviderBuilder = Sdk.CreateMeterProviderBuilder() .AddMeter(meter.Name) .AddView((instrument) => { return(new ExplicitBucketHistogramConfiguration { Boundaries = new[] { 5.0, 10.0 } }); }) .AddView((instrument) => { return(new ExplicitBucketHistogramConfiguration { Boundaries = new[] { 10.0, 20.0 } }); }) .AddInMemoryExporter(exportedItems); using var meterProvider = meterProviderBuilder.Build(); var instrument1 = meter.CreateHistogram <long>("name"); var instrument2 = meter.CreateHistogram <long>("name"); instrument1.Record(15); instrument2.Record(15); meterProvider.ForceFlush(MaxTimeToAllowForFlush); Assert.Equal(2, exportedItems.Count); var metric1 = exportedItems[0]; var metric2 = exportedItems[1]; Assert.Equal("name", exportedItems[0].Name); Assert.Equal("name", exportedItems[1].Name); var metricPoints = new List <MetricPoint>(); foreach (ref readonly var mp in metric1.GetMetricPoints()) { metricPoints.Add(mp); } Assert.Single(metricPoints); var metricPoint = metricPoints[0]; Assert.Equal(2, metricPoint.GetHistogramCount()); Assert.Equal(30, metricPoint.GetHistogramSum()); var index = 0; var actualCount = 0; var expectedBucketCounts = new long[] { 0, 0, 2 }; foreach (var histogramMeasurement in metricPoint.GetHistogramBuckets()) { Assert.Equal(expectedBucketCounts[index], histogramMeasurement.BucketCount); index++; actualCount++; } metricPoints = new List <MetricPoint>(); foreach (ref readonly var mp in metric2.GetMetricPoints()) { metricPoints.Add(mp); } Assert.Single(metricPoints); metricPoint = metricPoints[0]; Assert.Equal(2, metricPoint.GetHistogramCount()); Assert.Equal(30, metricPoint.GetHistogramSum()); index = 0; actualCount = 0; expectedBucketCounts = new long[] { 0, 2, 0 }; foreach (var histogramMeasurement in metricPoint.GetHistogramBuckets()) { Assert.Equal(expectedBucketCounts[index], histogramMeasurement.BucketCount); index++; actualCount++; } }
public HttpInMetricsListener(string name, Meter meter) : base(name) { this.meter = meter; this.httpServerDuration = meter.CreateHistogram <double>("http.server.duration", "ms", "measures the duration of the inbound HTTP request"); }
public void TestHistogramToOltpMetric(string name, string description, string unit, long?longValue, double?doubleValue, AggregationTemporality aggregationTemporality, params object[] keysValues) { var metrics = new List <Metric>(); var metricReader = new BaseExportingMetricReader(new InMemoryExporter <Metric>(metrics)); metricReader.Temporality = aggregationTemporality; using var meter = new Meter(Utils.GetCurrentMethodName()); using var provider = Sdk.CreateMeterProviderBuilder() .AddMeter(meter.Name) .AddReader(metricReader) .Build(); var attributes = ToAttributes(keysValues).ToArray(); if (longValue.HasValue) { var histogram = meter.CreateHistogram <long>(name, unit, description); histogram.Record(longValue.Value, attributes); } else { var histogram = meter.CreateHistogram <double>(name, unit, description); histogram.Record(doubleValue.Value, attributes); } provider.ForceFlush(); var batch = new Batch <Metric>(metrics.ToArray(), metrics.Count); var request = new OtlpCollector.ExportMetricsServiceRequest(); request.AddMetrics(ResourceBuilder.CreateEmpty().Build().ToOtlpResource(), batch); var resourceMetric = request.ResourceMetrics.Single(); var instrumentationLibraryMetrics = resourceMetric.InstrumentationLibraryMetrics.Single(); var actual = instrumentationLibraryMetrics.Metrics.Single(); Assert.Equal(name, actual.Name); Assert.Equal(description ?? string.Empty, actual.Description); Assert.Equal(unit ?? string.Empty, actual.Unit); Assert.Equal(OtlpMetrics.Metric.DataOneofCase.Histogram, actual.DataCase); Assert.Null(actual.Gauge); Assert.Null(actual.Sum); Assert.NotNull(actual.Histogram); Assert.Null(actual.ExponentialHistogram); Assert.Null(actual.Summary); var otlpAggregationTemporality = aggregationTemporality == AggregationTemporality.Cumulative ? OtlpMetrics.AggregationTemporality.Cumulative : OtlpMetrics.AggregationTemporality.Delta; Assert.Equal(otlpAggregationTemporality, actual.Histogram.AggregationTemporality); Assert.Single(actual.Histogram.DataPoints); var dataPoint = actual.Histogram.DataPoints.First(); Assert.True(dataPoint.StartTimeUnixNano > 0); Assert.True(dataPoint.TimeUnixNano > 0); Assert.Equal(1UL, dataPoint.Count); if (longValue.HasValue) { Assert.Equal((double)longValue, dataPoint.Sum); } else { Assert.Equal(doubleValue, dataPoint.Sum); } int bucketIndex; for (bucketIndex = 0; bucketIndex < dataPoint.ExplicitBounds.Count; ++bucketIndex) { if (dataPoint.Sum <= dataPoint.ExplicitBounds[bucketIndex]) { break; } Assert.Equal(0UL, dataPoint.BucketCounts[bucketIndex]); } Assert.Equal(1UL, dataPoint.BucketCounts[bucketIndex]); if (attributes.Length > 0) { OtlpTestHelpers.AssertOtlpAttributes(attributes, dataPoint.Attributes); } else { Assert.Empty(dataPoint.Attributes); } Assert.Empty(dataPoint.Exemplars); #pragma warning disable CS0612 // Type or member is obsolete Assert.Null(actual.IntGauge); Assert.Null(actual.IntSum); Assert.Null(actual.IntHistogram); Assert.Empty(dataPoint.Labels); #pragma warning restore CS0612 // Type or member is obsolete }
internal static object Run(MetricsOptions options) { using var meter = new Meter("TestMeter"); var providerBuilder = Sdk.CreateMeterProviderBuilder() .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("myservice")) .AddMeter(meter.Name); // All instruments from this meter are enabled. if (options.UseExporter.Equals("otlp", StringComparison.OrdinalIgnoreCase)) { /* * Prerequisite to run this example: * Set up an OpenTelemetry Collector to run on local docker. * * Open a terminal window at the examples/Console/ directory and * launch the OpenTelemetry Collector with an OTLP receiver, by running: * * - On Unix based systems use: * docker run --rm -it -p 4317:4317 -v $(pwd):/cfg otel/opentelemetry-collector:0.33.0 --config=/cfg/otlp-collector-example/config.yaml * * - On Windows use: * docker run --rm -it -p 4317:4317 -v "%cd%":/cfg otel/opentelemetry-collector:0.33.0 --config=/cfg/otlp-collector-example/config.yaml * * Open another terminal window at the examples/Console/ directory and * launch the OTLP example by running: * * dotnet run metrics --useExporter otlp * * The OpenTelemetry Collector will output all received metrics to the stdout of its terminal. * */ // Adding the OtlpExporter creates a GrpcChannel. // This switch must be set before creating a GrpcChannel when calling an insecure gRPC service. // See: https://docs.microsoft.com/aspnet/core/grpc/troubleshoot#call-insecure-grpc-services-with-net-core-client AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true); providerBuilder .AddOtlpExporter((exporterOptions, metricReaderOptions) => { exporterOptions.Protocol = options.UseGrpc ? OtlpExportProtocol.Grpc : OtlpExportProtocol.HttpProtobuf; metricReaderOptions.PeriodicExportingMetricReaderOptions.ExportIntervalMilliseconds = options.DefaultCollectionPeriodMilliseconds; metricReaderOptions.TemporalityPreference = options.IsDelta ? MetricReaderTemporalityPreference.Delta : MetricReaderTemporalityPreference.Cumulative; }); } else { providerBuilder .AddConsoleExporter((exporterOptions, metricReaderOptions) => { exporterOptions.Targets = ConsoleExporterOutputTargets.Console; metricReaderOptions.PeriodicExportingMetricReaderOptions.ExportIntervalMilliseconds = options.DefaultCollectionPeriodMilliseconds; metricReaderOptions.TemporalityPreference = options.IsDelta ? MetricReaderTemporalityPreference.Delta : MetricReaderTemporalityPreference.Cumulative; }); } using var provider = providerBuilder.Build(); Counter <int> counter = null; if (options.FlagCounter ?? true) { counter = meter.CreateCounter <int>("counter", "things", "A count of things"); } Histogram <int> histogram = null; if (options.FlagHistogram ?? false) { histogram = meter.CreateHistogram <int>("histogram"); } if (options.FlagGauge ?? false) { var observableCounter = meter.CreateObservableGauge("gauge", () => { return(new List <Measurement <int> >() { new Measurement <int>( (int)Process.GetCurrentProcess().PrivateMemorySize64, new KeyValuePair <string, object>("tag1", "value1")), }); }); } System.Console.WriteLine("Press any key to exit."); while (!System.Console.KeyAvailable) { histogram?.Record(10); histogram?.Record( 100, new KeyValuePair <string, object>("tag1", "value1")); histogram?.Record( 200, new KeyValuePair <string, object>("tag1", "value2"), new KeyValuePair <string, object>("tag2", "value2")); histogram?.Record( 100, new KeyValuePair <string, object>("tag1", "value1")); histogram?.Record( 200, new KeyValuePair <string, object>("tag2", "value2"), new KeyValuePair <string, object>("tag1", "value2")); counter?.Add(10); counter?.Add( 100, new KeyValuePair <string, object>("tag1", "value1")); counter?.Add( 200, new KeyValuePair <string, object>("tag1", "value2"), new KeyValuePair <string, object>("tag2", "value2")); counter?.Add( 100, new KeyValuePair <string, object>("tag1", "value1")); counter?.Add( 200, new KeyValuePair <string, object>("tag2", "value2"), new KeyValuePair <string, object>("tag1", "value2")); Task.Delay(500).Wait(); } return(null); }
public static void Main(string[] args) { using var meterProvider = Sdk.CreateMeterProviderBuilder() .AddMeter(Meter1.Name) .AddMeter(Meter2.Name) // Rename an instrument to new name. .AddView(instrumentName: "MyCounter", name: "MyCounterRenamed") // Change Histogram bounds .AddView(instrumentName: "MyHistogram", new HistogramConfiguration() { BucketBounds = new double[] { 10, 20 } }) // For the instrument "MyCounterCustomTags", aggregate with only the keys "tag1", "tag2". .AddView(instrumentName: "MyCounterCustomTags", new MetricStreamConfiguration() { TagKeys = new string[] { "tag1", "tag2" } }) // Drop the instrument "MyCounterDrop". .AddView(instrumentName: "MyCounterDrop", MetricStreamConfiguration.Drop) // Advanced selection criteria and config via Func<Instrument, MetricStreamConfiguration> .AddView((instrument) => { if (instrument.Meter.Name.Equals("CompanyA.ProductB.Library2") && instrument.GetType().Name.Contains("Histogram")) { return(new HistogramConfiguration() { BucketBounds = new double[] { 10, 20 } }); } return(null); }) // An instrument which does not match any views // gets processed with default behavior. (SDK default) // Uncommenting the following line will // turn off the above default. i.e any // instrument which does not match any views // gets dropped. // .AddView(instrumentName: "*", new MetricStreamConfiguration() { Aggregation = Aggregation.Drop }) .AddConsoleExporter() .Build(); var random = new Random(); var counter = Meter1.CreateCounter <long>("MyCounter"); for (int i = 0; i < 20000; i++) { counter.Add(1, new("tag1", "value1"), new("tag2", "value2")); } var histogram = Meter1.CreateHistogram <long>("MyHistogram"); for (int i = 0; i < 20000; i++) { histogram.Record(random.Next(1, 1000), new("tag1", "value1"), new("tag2", "value2")); } var counterCustomTags = Meter1.CreateCounter <long>("MyCounterCustomTags"); for (int i = 0; i < 20000; i++) { counterCustomTags.Add(1, new("tag1", "value1"), new("tag2", "value2"), new("tag3", "value4")); } var counterDrop = Meter1.CreateCounter <long>("MyCounterDrop"); for (int i = 0; i < 20000; i++) { counterDrop.Add(1, new("tag1", "value1"), new("tag2", "value2")); } var histogram2 = Meter2.CreateHistogram <long>("MyHistogram2"); for (int i = 0; i < 20000; i++) { histogram2.Record(random.Next(1, 1000), new("tag1", "value1"), new("tag2", "value2")); } }
public void ViewToProduceCustomHistogramBound() { using var meter1 = new Meter("ViewToProduceCustomHistogramBoundTest"); var exportedItems = new List <Metric>(); var bounds = new double[] { 10, 20 }; using var meterProvider = Sdk.CreateMeterProviderBuilder() .AddMeter(meter1.Name) .AddView("MyHistogram", new HistogramConfiguration() { Name = "MyHistogramDefaultBound" }) .AddView("MyHistogram", new HistogramConfiguration() { BucketBounds = bounds }) .AddInMemoryExporter(exportedItems) .Build(); var histogram = meter1.CreateHistogram <long>("MyHistogram"); histogram.Record(-10); histogram.Record(0); histogram.Record(1); histogram.Record(9); histogram.Record(10); histogram.Record(11); histogram.Record(19); meterProvider.ForceFlush(MaxTimeToAllowForFlush); Assert.Equal(2, exportedItems.Count); var metricDefault = exportedItems[0]; var metricCustom = exportedItems[1]; Assert.Equal("MyHistogramDefaultBound", metricDefault.Name); Assert.Equal("MyHistogram", metricCustom.Name); List <MetricPoint> metricPointsDefault = new List <MetricPoint>(); foreach (ref var mp in metricDefault.GetMetricPoints()) { metricPointsDefault.Add(mp); } Assert.Single(metricPointsDefault); var histogramPoint = metricPointsDefault[0]; Assert.Equal(40, histogramPoint.DoubleValue); Assert.Equal(7, histogramPoint.LongValue); Assert.Equal(Metric.DefaultHistogramBounds.Length + 1, histogramPoint.BucketCounts.Length); Assert.Equal(2, histogramPoint.BucketCounts[0]); Assert.Equal(1, histogramPoint.BucketCounts[1]); Assert.Equal(2, histogramPoint.BucketCounts[2]); Assert.Equal(2, histogramPoint.BucketCounts[3]); Assert.Equal(0, histogramPoint.BucketCounts[4]); Assert.Equal(0, histogramPoint.BucketCounts[5]); List <MetricPoint> metricPointsCustom = new List <MetricPoint>(); foreach (ref var mp in metricCustom.GetMetricPoints()) { metricPointsCustom.Add(mp); } Assert.Single(metricPointsCustom); histogramPoint = metricPointsCustom[0]; Assert.Equal(40, histogramPoint.DoubleValue); Assert.Equal(7, histogramPoint.LongValue); Assert.Equal(bounds.Length + 1, histogramPoint.BucketCounts.Length); Assert.Equal(5, histogramPoint.BucketCounts[0]); Assert.Equal(2, histogramPoint.BucketCounts[1]); Assert.Equal(0, histogramPoint.BucketCounts[2]); }
public HttpInMetricsListener(Meter meter) { this.httpServerDuration = meter.CreateHistogram <double>("http.server.duration", "ms", "measures the duration of the inbound HTTP request"); TelemetryHttpModule.Options.OnRequestStoppedCallback += this.OnStopActivity; }
public HttpHandlerMetricsDiagnosticListener(string name, Meter meter) : base(name) { this.httpClientDuration = meter.CreateHistogram <double>("http.client.duration", "milliseconds", "measure the duration of the outbound HTTP request"); }