public void HandleHeapEvent_RecordsValues()
        {
            var options  = new MetricsObserverOptions();
            var stats    = new TestOpenTelemetryMetrics();
            var observer = new CLRRuntimeObserver(options, stats, null);
            var factory  = stats.Factory;

            var metrics = new CLRRuntimeSource.HeapMetrics(1000, new List <long>()
            {
                10, 20, 30
            });

            observer.HandleHeapEvent(metrics);
            factory.CollectAllMetrics();

            var processor = stats.Processor;

            var metricName = "clr.memory.used";
            var summary    = processor.GetMetricByName <long>(metricName);

            Assert.NotNull(summary);
            var mean = summary.Sum / summary.Count;

            Assert.Equal(1000, mean);
            Assert.Equal(1000, summary.Min);
            Assert.Equal(1000, summary.Max);

            metricName = "clr.gc.collections";
            var gen0Label = new Dictionary <string, string>()
            {
                { "generation", "gen0" }
            }.ToList();

            summary = processor.GetMetricByName <long>(metricName, gen0Label);
            Assert.NotNull(summary);
            Assert.Equal(10, summary.Sum);

            var gen1Label = new Dictionary <string, string>()
            {
                { "generation", "gen1" }
            }.ToList();

            summary = processor.GetMetricByName <long>(metricName, gen1Label);
            Assert.NotNull(summary);
            Assert.Equal(20, summary.Sum);

            var gen2Label = new Dictionary <string, string>()
            {
                { "generation", "gen2" }
            }.ToList();

            summary = processor.GetMetricByName <long>(metricName, gen2Label);
            Assert.NotNull(summary);
            Assert.Equal(30, summary.Sum);

            processor.Clear();
            observer = new CLRRuntimeObserver(options, stats, null);

            metrics = new CLRRuntimeSource.HeapMetrics(1000, new List <long>()
            {
                10, 20, 30
            });
            observer.HandleHeapEvent(metrics);
            metrics = new CLRRuntimeSource.HeapMetrics(5000, new List <long>()
            {
                15, 25, 30
            });
            observer.HandleHeapEvent(metrics);
            factory.CollectAllMetrics();

            metricName = "clr.memory.used";
            summary    = processor.GetMetricByName <long>(metricName);
            Assert.Equal(5000 + 1000, summary.Sum);
            Assert.Equal(5000, summary.Max);
            Assert.Equal(1000, summary.Min);

            metricName = "clr.gc.collections";
            summary    = processor.GetMetricByName <long>(metricName, gen0Label);
            Assert.Equal(15, summary.Sum);

            summary = processor.GetMetricByName <long>(metricName, gen1Label);
            Assert.NotNull(summary);
            Assert.Equal(25, summary.Sum);

            summary = processor.GetMetricByName <long>(metricName, gen2Label);
            Assert.NotNull(summary);
            Assert.Equal(30, summary.Sum);
        }
Esempio n. 2
0
        public void HandleHeapEvent_RecordsValues()
        {
            var options  = new MetricsEndpointOptions();
            var stats    = new OpenCensusStats();
            var tags     = new OpenCensusTags();
            var observer = new CLRRuntimeObserver(options, stats, tags, null);

            CLRRuntimeSource.HeapMetrics metrics = new CLRRuntimeSource.HeapMetrics(1000, new List <long>()
            {
                10, 20, 30
            });
            observer.HandleHeapEvent(metrics);

            var memUsedViewData = stats.ViewManager.GetView(ViewName.Create("clr.memory.used"));
            var aggData         = MetricsHelpers.SumWithTags(memUsedViewData) as IMeanData;

            Assert.Equal(1000, aggData.Mean);
            Assert.Equal(1000, aggData.Max);
            Assert.Equal(1000, aggData.Min);

            var gcViewData = stats.ViewManager.GetView(ViewName.Create("clr.gc.collections"));
            var aggData2   = MetricsHelpers.SumWithTags(gcViewData) as ISumDataLong;

            Assert.Equal(60, aggData2.Sum);

            aggData2 = MetricsHelpers.SumWithTags(gcViewData, new List <ITagValue>()
            {
                TagValue.Create("gen0")
            }) as ISumDataLong;
            Assert.Equal(10, aggData2.Sum);

            aggData2 = MetricsHelpers.SumWithTags(gcViewData, new List <ITagValue>()
            {
                TagValue.Create("gen1")
            }) as ISumDataLong;
            Assert.Equal(20, aggData2.Sum);

            aggData2 = MetricsHelpers.SumWithTags(gcViewData, new List <ITagValue>()
            {
                TagValue.Create("gen2")
            }) as ISumDataLong;
            Assert.Equal(30, aggData2.Sum);

            metrics = new CLRRuntimeSource.HeapMetrics(5000, new List <long>()
            {
                15, 25, 30
            });
            observer.HandleHeapEvent(metrics);

            memUsedViewData = stats.ViewManager.GetView(ViewName.Create("clr.memory.used"));
            aggData         = MetricsHelpers.SumWithTags(memUsedViewData) as IMeanData;
            Assert.Equal((5000 + 1000) / 2, aggData.Mean);
            Assert.Equal(5000, aggData.Max);
            Assert.Equal(1000, aggData.Min);

            gcViewData = stats.ViewManager.GetView(ViewName.Create("clr.gc.collections"));
            aggData2   = MetricsHelpers.SumWithTags(gcViewData) as ISumDataLong;
            Assert.Equal(70, aggData2.Sum);

            aggData2 = MetricsHelpers.SumWithTags(gcViewData, new List <ITagValue>()
            {
                TagValue.Create("gen0")
            }) as ISumDataLong;
            Assert.Equal(15, aggData2.Sum);

            aggData2 = MetricsHelpers.SumWithTags(gcViewData, new List <ITagValue>()
            {
                TagValue.Create("gen1")
            }) as ISumDataLong;
            Assert.Equal(25, aggData2.Sum);

            aggData2 = MetricsHelpers.SumWithTags(gcViewData, new List <ITagValue>()
            {
                TagValue.Create("gen2")
            }) as ISumDataLong;
            Assert.Equal(30, aggData2.Sum);
        }