DataStreamsMonitoringAwsKinesisTests.cs

// <copyright file="DataStreamsMonitoringAwsKinesisTests.cs" company="Datadog">
// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License.
// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc.
// </copyright>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Datadog.Trace.Configuration;
using Datadog.Trace.TestHelpers;
using Datadog.Trace.TestHelpers.DataStreamsMonitoring;
using FluentAssertions;
using VerifyXunit;
using Xunit;
using Xunit.Abstractions;

namespace Datadog.Trace.ClrProfiler.IntegrationTests.AWS
{
    [Trait("RequiresDockerDependency", "true")]
    [Trait("DockerGroup", "2")]
    [UsesVerify]
    public class DataStreamsMonitoringAwsKinesisTests : TracingIntegrationTest
    {
        public DataStreamsMonitoringAwsKinesisTests(ITestOutputHelper output)
            : base("AWS.Kinesis", output)
        {
        }

        public static IEnumerable<object[]> GetEnabledConfig()
            => from packageVersionArray in PackageVersions.AwsKinesis
               from metadataSchemaVersion in new[] { "v0", "v1" }
               select new[] { packageVersionArray[0], metadataSchemaVersion };

        public override Result ValidateIntegrationSpan(MockSpan span, string metadataSchemaVersion) => span.Tags["span.kind"] switch
        {
            SpanKinds.Producer => span.IsAwsKinesisOutbound(),
            _ => throw new ArgumentException($"span.Tags[\"span.kind\"] is not a supported value for the AWS Kinesis integration: {span.Tags["span.kind"]}", nameof(span)),
        };

        [SkippableTheory]
        [MemberData(nameof(GetEnabledConfig))]
        [Trait("Category", "EndToEnd")]
        public async Task SubmitsDsmMetrics(string packageVersion, string metadataSchemaVersion)
        {
            SetEnvironmentVariable(ConfigurationKeys.DataStreamsMonitoring.Enabled, "1");
            SetEnvironmentVariable("DD_TRACE_SPAN_ATTRIBUTE_SCHEMA", metadataSchemaVersion);
            var isExternalSpan = metadataSchemaVersion == "v0";
            var clientSpanServiceName = isExternalSpan ? $"{EnvironmentHelper.FullSampleName}-aws-kinesis" : EnvironmentHelper.FullSampleName;

            using var telemetry = this.ConfigureTelemetry();
            using (var agent = EnvironmentHelper.GetMockAgent())
            using (await RunSampleAndWaitForExit(agent, packageVersion: packageVersion))
            {
#if NETFRAMEWORK
                var expectedCount = 10;
                var frameworkName = "NetFramework";
#else
                var expectedCount = 5;
                var frameworkName = "NetCore";
#endif
                var spans = await agent.WaitForSpansAsync(expectedCount);
                var kinesisSpans = spans.Where(
                    span => span.Tags.TryGetValue("component", out var component) && component == "aws-sdk");

                kinesisSpans.Should().NotBeEmpty();

                var taggedSpans = kinesisSpans.Where(s => s.Tags.ContainsKey("pathway.hash"));
                taggedSpans.Should().HaveCount(expected: 2); // a send and a receive

                var dsPoints = await agent.WaitForDataStreamsPointsAsync(statsCount: 2);

                var host = Environment.GetEnvironmentVariable("AWS_SDK_HOST");

                var settings = VerifyHelper.GetSpanVerifierSettings();
                settings.UseFileName($"{nameof(DataStreamsMonitoringAwsKinesisTests)}.{frameworkName}.Schema{metadataSchemaVersion.ToUpper()}");
                settings.AddDataStreamsScrubber();
                if (!string.IsNullOrWhiteSpace(host))
                {
                    settings.AddSimpleScrubber(host, "localhost:00000");
                }

                await Verifier.Verify(MockDataStreamsPayload.Normalize(dsPoints), settings)
                          .DisableRequireUniquePrefix();

                await telemetry.AssertIntegrationEnabledAsync(IntegrationId.AwsKinesis);
            }
        }
    }
}