public void MetricBatchWithNoCommonElement()
        {
            var timestamp  = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
            var timestampL = timestamp;
            var interval   = 125L;
            var gaugeValue = 213d;

            var metricBatch = new NewRelicMetricBatch(
                metrics: new[]
            {
                NewRelicMetric.CreateSummaryMetric(
                    name: "SummaryMetric",
                    timestamp: timestampL,
                    attributes: null,
                    interval: interval,
                    summaryValue: new NewRelicMetricSummaryValue(
                        count: 10d,
                        sum: 64,
                        min: 3,
                        max: 15)),
                NewRelicMetric.CreateGaugeMetric(
                    name: "GaugeMetric",
                    timestamp: timestampL,
                    attributes: null,
                    value: gaugeValue),
            });

            var actualMetrics = metricBatch.Metrics.ToArray();

            Assert.Equal(2, actualMetrics.Length);
            Assert.Empty(metricBatch.CommonProperties.Attributes);
            Assert.Null(metricBatch.CommonProperties.IntervalMs);
            Assert.Null(metricBatch.CommonProperties.Timestamp);
        }
        public void BuildSummaryMetricWithValues()
        {
            var timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
            var interval  = 33L;
            var value     = new NewRelicMetricSummaryValue(10d, 64, 3, 15);

            var metric = NewRelicMetric.CreateSummaryMetric(
                name: "metricName",
                timestamp: timestamp,
                attributes: new Dictionary <string, object>
            {
                { "attrKey", "attrValue" },
                { "adsfasdf", 12 },
            },
                interval: interval,
                count: value.Count,
                min: value.Min,
                max: value.Max,
                sum: value.Sum);

            Assert.Equal("metricName", metric.Name);
            Assert.Equal("summary", metric.Type);
            Assert.Equal(value, metric.SummaryValue);
            Assert.Equal(timestamp, metric.Timestamp);
            Assert.Equal(interval, metric.IntervalMs);
            Assert.Equal(12, metric.Attributes?["adsfasdf"]);
            Assert.Equal("attrValue", metric.Attributes?["attrKey"]);
        }
        public void ToJson_NonEmptyMetricBatch()
        {
            // Arrange
            var metricBatch = new NewRelicMetricBatch(
                commonProperties: new NewRelicMetricBatchCommonProperties(
                    timestamp: _timestampL,
                    intervalMs: _interval,
                    attributes: null),
                metrics: new[]
            {
                NewRelicMetric.CreateCountMetric(
                    name: "metric1",
                    timestamp: null,
                    attributes: _customAttributes,
                    value: _countValue,
                    intervalMs: _interval),
                NewRelicMetric.CreateSummaryMetric(
                    name: "metric2",
                    timestamp: null,
                    attributes: null,
                    interval: _interval,
                    summaryValue: _summaryValue),
            });

            // Act
            var jsonString = metricBatch.ToJson();

            // Assert
            var resultMetricBatches = TestHelpers.DeserializeArray(jsonString);

            TestHelpers.AssertForCollectionLength(resultMetricBatches, 1);

            // CountMetric
            var resultMetricBatch = resultMetricBatches.First();
            var resultCommonProps = TestHelpers.DeserializeObject(resultMetricBatch["common"]);

            TestHelpers.AssertForAttribValue(resultCommonProps, "timestamp", _timestampL);
            TestHelpers.AssertForAttribValue(resultCommonProps, "interval.ms", _interval);

            var resultMetrics = TestHelpers.DeserializeArray(resultMetricBatch["metrics"]);

            TestHelpers.AssertForCollectionLength(resultMetrics, 2);

            var countMetric = resultMetrics.First();

            TestHelpers.AssertForAttribCount(countMetric, 5);

            TestHelpers.AssertForAttribValue(countMetric, "name", "metric1");
            TestHelpers.AssertForAttribValue(countMetric, "type", "count");
            TestHelpers.AssertForAttribValue(countMetric, "value", _countValue);
            TestHelpers.AssertForAttribValue(countMetric, "interval.ms", _interval);

            var countMetricAttribs = TestHelpers.DeserializeObject(countMetric["attributes"]);

            TestHelpers.AssertForAttribCount(countMetricAttribs, 1);
            TestHelpers.AssertForAttribValue(countMetricAttribs, "attr1Key", "attr1Value");

            // SummaryMetric
            var summaryMetric = resultMetrics[1];

            TestHelpers.AssertForAttribCount(summaryMetric, 4);

            TestHelpers.AssertForAttribValue(summaryMetric, "name", "metric2");
            TestHelpers.AssertForAttribValue(summaryMetric, "type", "summary");
            TestHelpers.AssertForAttribValue(summaryMetric, "value", _summaryValue);
            TestHelpers.AssertForAttribValue(countMetric, "interval.ms", _interval);
        }