diff --git a/docs/internal/internal-config.md b/docs/internal/internal-config.md index fcef9e0e6..ac6de99ca 100644 --- a/docs/internal/internal-config.md +++ b/docs/internal/internal-config.md @@ -34,6 +34,7 @@ These settings should be never used by the users. | `SIGNALFX_APPSEC_IPHEADER` | Optional name of the custom header to take into account for the ip address. | | | `SIGNALFX_APPSEC_KEEP_TRACES` | Specifies if the AppSec traces should be explicitly kept or droped. | `true` | | `SIGNALFX_APPSEC_RULES` | Overrides the default rules file provided. Must be a path to a valid JSON rules file. | | +| `SIGNALFX_CIVISIBILITY_AGENTLESS_ENABLED` | Enable to activate Agentless in CI Visibility. | `false` | | `SIGNALFX_CIVISIBILITY_ENABLED` | Enable to activate CI Visibility. | `false` | | `SIGNALFX_DOGSTATSD_ARGS` | Comma-separated list of arguments to be passed to the DogStatsD process. | | | `SIGNALFX_DOGSTATSD_PATH` | The DogStatsD path for when a standalone instance needs to be started. | | @@ -41,6 +42,8 @@ These settings should be never used by the users. | `SIGNALFX_DOGSTATSD_PORT` | The port of the targeted StatsD server. | `8125` | | `SIGNALFX_INTERNAL_TRACE_VERSION_COMPATIBILITY` | Enables the compatibility with other versions of tracer. | `false` | | `SIGNALFX_MAX_TRACES_PER_SECOND` | The number of traces allowed to be submitted per second. | `100` | +| `SIGNALFX_PROXY_HTTPS` | TConfiguration key to set a proxy server for https requests. | | +| `SIGNALFX_PROXY_NO_PROXY` | Configuration key to set a list of hosts that should bypass the proxy. The list is space-separated| | | `SIGNALFX_TRACE_{0}_ANALYTICS_ENABLED` | Enable to activate analytics for specific integration. | `false` | | `SIGNALFX_TRACE_{0}_ANALYTICS_SAMPLE_RATE` | Set sample rate for analytics in specific integration. | | | `SIGNALFX_TRACE_AGENT_ARGS` | Comma-separated list of arguments to be passed to the Trace Agent process. | | diff --git a/profiler/src/ProfilerEngine/Datadog.Profiler.Managed/Datadog.Profiler.Managed.csproj b/profiler/src/ProfilerEngine/Datadog.Profiler.Managed/Datadog.Profiler.Managed.csproj index 68b8cddc3..191c25e26 100644 --- a/profiler/src/ProfilerEngine/Datadog.Profiler.Managed/Datadog.Profiler.Managed.csproj +++ b/profiler/src/ProfilerEngine/Datadog.Profiler.Managed/Datadog.Profiler.Managed.csproj @@ -60,7 +60,7 @@ - + diff --git a/tracer/build/_build/Build.GitHub.cs b/tracer/build/_build/Build.GitHub.cs index 724674f08..b65b2641d 100644 --- a/tracer/build/_build/Build.GitHub.cs +++ b/tracer/build/_build/Build.GitHub.cs @@ -50,6 +50,9 @@ partial class Build [Parameter("The Pull Request number for GitHub Actions")] readonly int? PullRequestNumber; + [Parameter("The specific commit sha to use", List = false)] + readonly string CommitSha; + [Parameter("The git branch to use", List = false)] readonly string TargetBranch; @@ -491,57 +494,109 @@ await client.Issue.Milestone.Update( BuildArtifact artifact = null; var artifactName = $"{FullVersion}-release-artifacts"; + string commitSha = CommitSha; - Logger.Info($"Checking builds for artifact called: {artifactName}"); - string commitSha = String.Empty; - - // start from the current commit, and keep looking backwards until we find a commit that has a build - // that has successful artifacts. Should only be called from branches with a linear history (i.e. single parent) - // This solves a potential issue where we previously selecting a build by start order, not by the actual - // git commit order. Generally that shouldn't be an issue, but if we manually trigger builds on master - // (which we sometimes do e.g. trying to bisect and issue, or retrying flaky test for coverage reasons), - // then we could end up selecting the wrong build. - const int maxCommitsBack = 20; - for (var i = 0; i < maxCommitsBack; i++) + if (!string.IsNullOrEmpty(CommitSha)) { - commitSha = GitTasks.Git($"log {TargetBranch}~{i} -1 --pretty=%H") - .FirstOrDefault(x => x.Type == OutputType.Std) - .Text; + var foundSha = false; + var maxCommitsBack = 20; + // basic verification, to ensure that the provided commitsha is actually on this branch + for (var i = 0; i < maxCommitsBack; i++) + { + var sha = GitTasks.Git($"log {TargetBranch}~{i} -1 --pretty=%H") + .FirstOrDefault(x => x.Type == OutputType.Std) + .Text; - Logger.Info($"Looking for builds for {commitSha}"); + if (string.Equals(CommitSha, sha, StringComparison.OrdinalIgnoreCase)) + { + // OK, this SHA is definitely on this branch + foundSha = true; + break; + } + } - foreach (var build in builds) + if (!foundSha) { - if (string.Equals(build.SourceVersion, commitSha, StringComparison.OrdinalIgnoreCase)) - { - // Found a build for the commit, so should be successful and have an artifact - if (build.Result != BuildResult.Succeeded && build.Result != BuildResult.PartiallySucceeded) - { - Logger.Error($"::error::The build for commit {commitSha} was not successful. Please retry any failed stages for the build before creating a release"); - throw new Exception("Latest build for branch was not successful. Please retry the build before creating a release"); - } + Logger.Error($"Error: The commit {CommitSha} could not be found in the last {maxCommitsBack} of the branch {TargetBranch}" + + $"Ensure that the commit sha you have provided is correct, and you are running the create_release action from the correct branch"); + throw new Exception($"The commit {CommitSha} could not found in the latest {maxCommitsBack} of target branch {TargetBranch}"); + } - try - { - artifact = await buildHttpClient.GetArtifactAsync( - project: AzureDevopsProjectId, - buildId: build.Id, - artifactName: artifactName); - break; - } - catch (ArtifactNotFoundException) + Logger.Info($"Finding build for commit sha: {CommitSha}"); + var build = builds + .FirstOrDefault(b => string.Equals(b.SourceVersion, CommitSha, StringComparison.OrdinalIgnoreCase)); + if (build is null) + { + throw new Exception($"No builds for commit {CommitSha} found. Please check you have provided the correct SHA, and that there is a build in AzureDevops for the commit"); + } + + try + { + artifact = await buildHttpClient.GetArtifactAsync( + project: AzureDevopsProjectId, + buildId: build.Id, + artifactName: artifactName); + } + catch (ArtifactNotFoundException) + { + Logger.Error($"Error: The build {build.Id} for commit could not find {artifactName} artifact for build {build.Id} for commit {commitSha}. " + + $"Ensure the build has successfully generated artifacts for this commit before creating a release"); + throw; + } + } + else + { + Logger.Info($"Checking builds for artifact called: {artifactName}"); + + // start from the current commit, and keep looking backwards until we find a commit that has a build + // that has successful artifacts. Should only be called from branches with a linear history (i.e. single parent) + // This solves a potential issue where we previously selecting a build by start order, not by the actual + // git commit order. Generally that shouldn't be an issue, but if we manually trigger builds on master + // (which we sometimes do e.g. trying to bisect and issue, or retrying flaky test for coverage reasons), + // then we could end up selecting the wrong build. + const int maxCommitsBack = 20; + for (var i = 0; i < maxCommitsBack; i++) + { + commitSha = GitTasks.Git($"log {TargetBranch}~{i} -1 --pretty=%H") + .FirstOrDefault(x => x.Type == OutputType.Std) + .Text; + + Logger.Info($"Looking for builds for {commitSha}"); + + foreach (var build in builds) + { + if (string.Equals(build.SourceVersion, commitSha, StringComparison.OrdinalIgnoreCase)) { - Logger.Error($"Error: could not find {artifactName} artifact for build {build.Id} for commit {commitSha}. " + - $"Ensure the build has completed successfully for this commit before creating a release"); - throw; + // Found a build for the commit, so should be successful and have an artifact + if (build.Result != BuildResult.Succeeded && build.Result != BuildResult.PartiallySucceeded) + { + Logger.Error($"::error::The build for commit {commitSha} was not successful. Please retry any failed stages for the build before creating a release"); + throw new Exception("Latest build for branch was not successful. Please retry the build before creating a release"); + } + + try + { + artifact = await buildHttpClient.GetArtifactAsync( + project: AzureDevopsProjectId, + buildId: build.Id, + artifactName: artifactName); + + break; + } + catch (ArtifactNotFoundException) + { + Logger.Error($"Error: could not find {artifactName} artifact for build {build.Id} for commit {commitSha}. " + + $"Ensure the build has completed successfully for this commit before creating a release"); + throw; + } } } - } - if (artifact is not null) - { - break; + if (artifact is not null) + { + break; + } } } diff --git a/tracer/src/Datadog.Trace.BenchmarkDotNet/DatadogExporter.cs b/tracer/src/Datadog.Trace.BenchmarkDotNet/DatadogExporter.cs index 6de063bbf..60f7ea5b7 100644 --- a/tracer/src/Datadog.Trace.BenchmarkDotNet/DatadogExporter.cs +++ b/tracer/src/Datadog.Trace.BenchmarkDotNet/DatadogExporter.cs @@ -33,7 +33,7 @@ static DatadogExporter() { try { - Environment.SetEnvironmentVariable(Configuration.ConfigurationKeys.CIVisibilityEnabled, "1", EnvironmentVariableTarget.Process); + Environment.SetEnvironmentVariable(Configuration.ConfigurationKeys.CIVisibility.Enabled, "1", EnvironmentVariableTarget.Process); } catch { @@ -71,13 +71,14 @@ public IEnumerable ExportToFiles(Summary summary, ILogger consoleLogger) span.ResourceName = $"{report.BenchmarkCase.Descriptor.Type.FullName}.{report.BenchmarkCase.Descriptor.WorkloadMethod.Name}"; CIEnvironmentValues.Instance.DecorateSpan(span); + span.SetTag(Tags.Origin, TestTags.CIAppTestOriginName); + span.SetTag(Tags.Language, TracerConstants.Language); span.SetTag(TestTags.Name, report.BenchmarkCase.Descriptor.WorkloadMethodDisplayInfo); span.SetTag(TestTags.Type, TestTags.TypeBenchmark); span.SetTag(TestTags.Suite, report.BenchmarkCase.Descriptor.Type.FullName); span.SetTag(TestTags.Framework, $"BenchmarkDotNet {summary.HostEnvironmentInfo.BenchmarkDotNetVersion}"); span.SetTag(TestTags.Status, report.Success ? TestTags.StatusPass : TestTags.StatusFail); - span.SetTag(TestTags.Language, TracerConstants.Language); - span.SetTag(TestTags.CILibraryVersion, TracerConstants.AssemblyVersion); + span.SetTag(CommonTags.LibraryVersion, TracerConstants.AssemblyVersion); if (summary.HostEnvironmentInfo != null) { diff --git a/tracer/src/Datadog.Trace.MSBuild/DatadogLogger.cs b/tracer/src/Datadog.Trace.MSBuild/DatadogLogger.cs index 178275e89..c5762c707 100644 --- a/tracer/src/Datadog.Trace.MSBuild/DatadogLogger.cs +++ b/tracer/src/Datadog.Trace.MSBuild/DatadogLogger.cs @@ -33,7 +33,7 @@ static DatadogLogger() { try { - Environment.SetEnvironmentVariable(Configuration.ConfigurationKeys.CIVisibilityEnabled, "1", EnvironmentVariableTarget.Process); + Environment.SetEnvironmentVariable(Configuration.ConfigurationKeys.CIVisibility.Enabled, "1", EnvironmentVariableTarget.Process); } catch { @@ -107,6 +107,8 @@ private void EventSource_BuildStarted(object sender, BuildStartedEventArgs e) _buildSpan.SetTraceSamplingPriority(SamplingPriorityValues.AutoKeep); _buildSpan.Type = SpanTypes.Build; + _buildSpan.SetTag(Tags.Origin, TestTags.CIAppTestOriginName); + _buildSpan.SetTag(Tags.Language, TracerConstants.Language); _buildSpan.SetTag(BuildTags.BuildName, e.SenderName); foreach (KeyValuePair envValue in e.BuildEnvironment) { @@ -120,8 +122,7 @@ private void EventSource_BuildStarted(object sender, BuildStartedEventArgs e) _buildSpan.SetTag(CommonTags.OSArchitecture, Environment.Is64BitOperatingSystem ? "x64" : "x86"); _buildSpan.SetTag(CommonTags.OSVersion, Environment.OSVersion.VersionString); _buildSpan.SetTag(CommonTags.RuntimeArchitecture, Environment.Is64BitProcess ? "x64" : "x86"); - _buildSpan.SetTag(TestTags.Language, TracerConstants.Language); - _buildSpan.SetTag(TestTags.CILibraryVersion, TracerConstants.AssemblyVersion); + _buildSpan.SetTag(CommonTags.LibraryVersion, TracerConstants.AssemblyVersion); CIEnvironmentValues.Instance.DecorateSpan(_buildSpan); } catch (Exception ex) diff --git a/tracer/src/Datadog.Trace.SourceGenerators/TagsListGenerator/Sources.cs b/tracer/src/Datadog.Trace.SourceGenerators/TagsListGenerator/Sources.cs index 015b02a56..e865f27ee 100644 --- a/tracer/src/Datadog.Trace.SourceGenerators/TagsListGenerator/Sources.cs +++ b/tracer/src/Datadog.Trace.SourceGenerators/TagsListGenerator/Sources.cs @@ -5,7 +5,6 @@ // Modified by Splunk Inc. -using System.Collections.Generic; using System.Text; namespace Datadog.Trace.SourceGenerators.TagsListGenerator @@ -66,6 +65,8 @@ public static string CreateTagsList(StringBuilder sb, TagListGenerator.TagList t sb.Append(@"// #nullable enable +using Datadog.Trace.Processors; + namespace "); sb.Append(tagList.Namespace) .Append( @@ -201,7 +202,7 @@ public override void SetTag(string key, string value) sb.Append(@"Properties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; "); @@ -216,14 +217,14 @@ protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) .Append(property.PropertyName) .Append(@"Bytes, ") .Append(property.PropertyName) - .Append(@"); + .Append(@", tagProcessors); } "); } sb.Append( - @"return count + base.WriteAdditionalTags(ref bytes, ref offset); + @"return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) @@ -330,7 +331,7 @@ public override void SetMetric(string key, double? value) } } - protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; "); @@ -345,14 +346,14 @@ protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset) .Append(property.PropertyName) .Append(@"Bytes, ") .Append(property.PropertyName) - .Append(@".Value); + .Append(@".Value, tagProcessors); } "); } sb.Append( - @"return count + base.WriteAdditionalMetrics(ref bytes, ref offset); + @"return count + base.WriteAdditionalMetrics(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalMetrics(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Agent/IApiRequestFactory.cs b/tracer/src/Datadog.Trace/Agent/IApiRequestFactory.cs index b57c2d0ac..c25222914 100644 --- a/tracer/src/Datadog.Trace/Agent/IApiRequestFactory.cs +++ b/tracer/src/Datadog.Trace/Agent/IApiRequestFactory.cs @@ -4,6 +4,7 @@ // using System; +using System.Net; namespace Datadog.Trace.Agent { @@ -12,5 +13,7 @@ internal interface IApiRequestFactory string Info(Uri endpoint); IApiRequest Create(Uri endpoint); + + void SetProxy(WebProxy proxy, NetworkCredential credential); } } diff --git a/tracer/src/Datadog.Trace/Agent/MessagePack/SpanMessagePackFormatter.cs b/tracer/src/Datadog.Trace/Agent/MessagePack/SpanMessagePackFormatter.cs index 84c002f04..6b561da9e 100644 --- a/tracer/src/Datadog.Trace/Agent/MessagePack/SpanMessagePackFormatter.cs +++ b/tracer/src/Datadog.Trace/Agent/MessagePack/SpanMessagePackFormatter.cs @@ -7,6 +7,7 @@ using System; using Datadog.Trace.ExtensionMethods; +using Datadog.Trace.Processors; using Datadog.Trace.Vendors.MessagePack; using Datadog.Trace.Vendors.MessagePack.Formatters; @@ -95,7 +96,13 @@ public int Serialize(ref byte[] bytes, int offset, Span value, IFormatterResolve offset += MessagePackBinary.WriteByte(ref bytes, offset, 1); } - offset += value.Tags.SerializeTo(ref bytes, offset, value); + ITagProcessor[] tagProcessors = null; + if (value.Context.TraceContext?.Tracer is Tracer tracer) + { + tagProcessors = tracer.TracerManager?.TagProcessors; + } + + offset += value.Tags.SerializeTo(ref bytes, offset, value, tagProcessors); return offset - originalOffset; } diff --git a/tracer/src/Datadog.Trace/Agent/Transports/ApiWebRequestFactory.cs b/tracer/src/Datadog.Trace/Agent/Transports/ApiWebRequestFactory.cs index 2343cb59d..835bbdb9b 100644 --- a/tracer/src/Datadog.Trace/Agent/Transports/ApiWebRequestFactory.cs +++ b/tracer/src/Datadog.Trace/Agent/Transports/ApiWebRequestFactory.cs @@ -12,6 +12,8 @@ namespace Datadog.Trace.Agent.Transports internal class ApiWebRequestFactory : IApiRequestFactory { private readonly KeyValuePair[] _defaultHeaders; + private WebProxy _proxy; + private NetworkCredential _credential; public ApiWebRequestFactory(KeyValuePair[] defaultHeaders) { @@ -26,6 +28,15 @@ public string Info(Uri endpoint) public IApiRequest Create(Uri endpoint) { var request = WebRequest.CreateHttp(endpoint); + if (_proxy is not null) + { + request.Proxy = _proxy; + } + + if (_credential is not null) + { + request.Credentials = _credential; + } foreach (var pair in _defaultHeaders) { @@ -34,5 +45,11 @@ public IApiRequest Create(Uri endpoint) return new ApiWebRequest(request); } + + public void SetProxy(WebProxy proxy, NetworkCredential credential) + { + _proxy = proxy; + _credential = credential; + } } } diff --git a/tracer/src/Datadog.Trace/Agent/Transports/HttpClientRequestFactory.cs b/tracer/src/Datadog.Trace/Agent/Transports/HttpClientRequestFactory.cs index a615e9d0e..8cf505121 100644 --- a/tracer/src/Datadog.Trace/Agent/Transports/HttpClientRequestFactory.cs +++ b/tracer/src/Datadog.Trace/Agent/Transports/HttpClientRequestFactory.cs @@ -8,6 +8,7 @@ #if NETCOREAPP using System; using System.Collections.Generic; +using System.Net; using System.Net.Http; using Datadog.Trace.Propagation; @@ -16,10 +17,12 @@ namespace Datadog.Trace.Agent.Transports internal class HttpClientRequestFactory : IApiRequestFactory { private readonly HttpClient _client; + private readonly HttpClientHandler _handler; - public HttpClientRequestFactory(KeyValuePair[] defaultHeaders, HttpMessageHandler handler = null) + public HttpClientRequestFactory(KeyValuePair[] defaultHeaders, HttpClientHandler handler = null) { - _client = handler == null ? new HttpClient() : new HttpClient(handler); + _handler = handler ?? new HttpClientHandler(); + _client = new HttpClient(_handler); foreach (var pair in defaultHeaders) { @@ -36,6 +39,15 @@ public IApiRequest Create(Uri endpoint) { return new HttpClientRequest(_client, endpoint); } + + public void SetProxy(WebProxy proxy, NetworkCredential credential) + { + _handler.Proxy = proxy; + if (credential is not null) + { + _handler.Credentials = credential; + } + } } } #endif diff --git a/tracer/src/Datadog.Trace/Agent/Transports/HttpStreamRequestFactory.cs b/tracer/src/Datadog.Trace/Agent/Transports/HttpStreamRequestFactory.cs index 30e1f74c6..7b1b1c1cc 100644 --- a/tracer/src/Datadog.Trace/Agent/Transports/HttpStreamRequestFactory.cs +++ b/tracer/src/Datadog.Trace/Agent/Transports/HttpStreamRequestFactory.cs @@ -4,6 +4,7 @@ // using System; +using System.Net; using Datadog.Trace.HttpOverStreams; namespace Datadog.Trace.Agent.Transports @@ -28,5 +29,9 @@ public IApiRequest Create(Uri endpoint) { return new HttpStreamRequest(_httpClient, endpoint, _streamFactory); } + + public void SetProxy(WebProxy proxy, NetworkCredential credential) + { + } } } diff --git a/tracer/src/Datadog.Trace/Ci/Agent/CIAgentWriter.cs b/tracer/src/Datadog.Trace/Ci/Agent/CIAgentWriter.cs index 358f8df3b..a05b25196 100644 --- a/tracer/src/Datadog.Trace/Ci/Agent/CIAgentWriter.cs +++ b/tracer/src/Datadog.Trace/Ci/Agent/CIAgentWriter.cs @@ -8,22 +8,57 @@ using System; using System.Threading.Tasks; using Datadog.Trace.Agent; -using Datadog.Trace.Ci.Tags; +using Datadog.Trace.Ci.EventModel; using Datadog.Trace.Configuration; using Datadog.Trace.Sampling; namespace Datadog.Trace.Ci.Agent { - internal class CIAgentWriter : IAgentWriter + /// + /// CI Visibility Agent Writer + /// + internal class CIAgentWriter : IEventWriter { - private readonly AgentWriter _agentWriter = null; - private readonly bool _isPartialFlushEnabled = false; + private const int DefaultMaxBufferSize = 1024 * 1024 * 10; - public CIAgentWriter(ImmutableTracerSettings settings, ISampler sampler) + [ThreadStatic] + private static Span[] _spanArray; + private readonly AgentWriter _agentWriter; + + public CIAgentWriter(ImmutableTracerSettings settings, ISampler sampler, int maxBufferSize = DefaultMaxBufferSize) + { + var isPartialFlushEnabled = settings.ExporterSettings.PartialFlushEnabled; + var apiRequestFactory = TracesTransportStrategy.Get(settings.ExporterSettings); + var api = new Api(settings.ExporterSettings.AgentUri, apiRequestFactory, null, rates => sampler.SetDefaultSampleRates(rates), isPartialFlushEnabled); + _agentWriter = new AgentWriter(api, null, maxBufferSize: maxBufferSize); + } + + public CIAgentWriter(IApi api, int maxBufferSize = DefaultMaxBufferSize) { - _isPartialFlushEnabled = settings.ExporterSettings.PartialFlushEnabled; - var api = new Api(settings.ExporterSettings.AgentUri, TracesTransportStrategy.Get(settings.ExporterSettings), null, rates => sampler.SetDefaultSampleRates(rates), _isPartialFlushEnabled); - _agentWriter = new AgentWriter(api, null, maxBufferSize: settings.TraceBufferSize); + _agentWriter = new AgentWriter(api, null, maxBufferSize: maxBufferSize); + } + + public void WriteEvent(IEvent @event) + { + // To keep compatibility with the agent version of the payload, any IEvent conversion to span + // goes here. + + if (_spanArray is not { } spanArray) + { + spanArray = new Span[1]; + _spanArray = spanArray; + } + + if (@event is TestEvent testEvent) + { + spanArray[0] = testEvent.Content; + WriteTrace(new ArraySegment(spanArray)); + } + else if (@event is SpanEvent spanEvent) + { + spanArray[0] = spanEvent.Content; + WriteTrace(new ArraySegment(spanArray)); + } } public Task FlushAndCloseAsync() @@ -43,36 +78,6 @@ public Task Ping() public void WriteTrace(ArraySegment trace) { - // We ensure there's no trace (local root span) without a test tag. - // And ensure all other spans have the origin tag. - - // Check if the trace has any span - if (trace.Count == 0) - { - // No trace to write - return; - } - - if (!_isPartialFlushEnabled) - { - // Check if the last span (the root) is a test, bechmark or build span - Span lastSpan = trace.Array[trace.Offset + trace.Count - 1]; - if (lastSpan.Context.Parent is null && - lastSpan.Type != SpanTypes.Test && - lastSpan.Type != SpanTypes.Benchmark && - lastSpan.Type != SpanTypes.Build) - { - CIVisibility.Log.Warning("Spans dropped because not having a test or benchmark root span: {Count}", trace.Count); - return; - } - } - - for (var i = trace.Offset; i < trace.Count + trace.Offset; i++) - { - // Sets the origin tag to any other spans to ensure the CI track. - trace.Array[i].Context.Origin = TestTags.CIAppTestOriginName; - } - _agentWriter.WriteTrace(trace); } } diff --git a/tracer/src/Datadog.Trace/Ci/Agent/CIAgentlessWriter.cs b/tracer/src/Datadog.Trace/Ci/Agent/CIAgentlessWriter.cs new file mode 100644 index 000000000..b2682bb19 --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/Agent/CIAgentlessWriter.cs @@ -0,0 +1,217 @@ +// +// 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. +// + +using System; +using System.Collections.Concurrent; +using System.Threading; +using System.Threading.Tasks; +using Datadog.Trace.Ci.Agent.Payloads; +using Datadog.Trace.Ci.EventModel; +using Datadog.Trace.Configuration; +using Datadog.Trace.Logging; +using Datadog.Trace.Sampling; + +namespace Datadog.Trace.Ci.Agent +{ + /// + /// CI Visibility Agentless Writer + /// + internal sealed class CIAgentlessWriter : IEventWriter + { + private const int BatchInterval = 1000; + private const int MaxItemsInQueue = 2500; + + private static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(); + + private readonly BlockingCollection _eventQueue; + private readonly TaskCompletionSource _flushTaskCompletionSource; + private readonly Task _periodicFlush; + private readonly AutoResetEvent _flushDelayEvent; + + private readonly EventsPayload _ciTestCycleBuffer; + + private readonly ICIAgentlessWriterSender _sender; + + public CIAgentlessWriter(ImmutableTracerSettings settings, ISampler sampler, ICIAgentlessWriterSender sender) + { + _eventQueue = new BlockingCollection(MaxItemsInQueue); + _flushTaskCompletionSource = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + _flushDelayEvent = new AutoResetEvent(false); + + _ciTestCycleBuffer = new CITestCyclePayload(); + + _sender = sender; + + _periodicFlush = Task.Factory.StartNew(InternalFlushEventsAsync, this, TaskCreationOptions.LongRunning); + _periodicFlush.ContinueWith(t => Log.Error(t.Exception, "Error in sending ciapp events"), TaskContinuationOptions.OnlyOnFaulted); + + Log.Information("CIAgentlessWriter Initialized."); + } + + public void WriteEvent(IEvent @event) + { + if (_eventQueue.IsAddingCompleted) + { + return; + } + + try + { + _eventQueue.Add(@event); + } + catch (Exception ex) + { + Log.Error(ex, "Error Writing event in a queue."); + } + } + + public Task FlushAndCloseAsync() + { + _eventQueue.CompleteAdding(); + _flushDelayEvent.Set(); + return _flushTaskCompletionSource.Task; + } + + public Task FlushTracesAsync() + { + var wme = new WatermarkEvent(); + if (_eventQueue.IsAddingCompleted) + { + return Task.CompletedTask; + } + + try + { + _eventQueue.Add(wme); + } + catch (Exception ex) + { + Log.Error(ex, "Error Writing event in a queue."); + return Task.FromException(ex); + } + + _flushDelayEvent.Set(); + return wme.CompletionSource.Task; + } + + public Task Ping() + { + return Task.FromResult(true); + } + + public void WriteTrace(ArraySegment trace) + { + // Transform spans to events + + for (var i = trace.Offset; i < trace.Count; i++) + { + if (trace.Array[i].Type == SpanTypes.Test) + { + WriteEvent(new TestEvent(trace.Array[i])); + } + else + { + WriteEvent(new SpanEvent(trace.Array[i])); + } + } + } + + private static async Task InternalFlushEventsAsync(object state) + { + var writer = (CIAgentlessWriter)state; + var eventQueue = writer._eventQueue; + var completionSource = writer._flushTaskCompletionSource; + var flushDelayEvent = writer._flushDelayEvent; + var ciTestCycleBuffer = writer._ciTestCycleBuffer; + + Log.Debug("CIAgentlessWriter:: InternalFlushEventsAsync/ Starting FlushEventsAsync loop"); + + while (!eventQueue.IsCompleted) + { + TaskCompletionSource watermarkCompletion = null; + + try + { + // Retrieve events from the queue and add them to the respective buffer. + while (eventQueue.TryTake(out var item)) + { + if (item is WatermarkEvent watermarkEvent) + { + // Flush operation. + // We get the completion source and exit this loop + // to flush buffers (in case there's any event) + watermarkCompletion = watermarkEvent.CompletionSource; + break; + } + else if (ciTestCycleBuffer.CanProcessEvent(item)) + { + // The CITestCycle endpoint can process this event, we try to add it to the buffer. + while (!ciTestCycleBuffer.TryProcessEvent(item) && ciTestCycleBuffer.HasEvents) + { + // If the item cannot be added to the buffer but the buffer has events + // we assume that is full and needs to be flushed. + await writer.SendPayloadAsync(ciTestCycleBuffer).ConfigureAwait(false); + ciTestCycleBuffer.Clear(); + } + } + } + + // After removing all items from the queue, we check if buffers needs to flushed. + if (ciTestCycleBuffer.HasEvents) + { + // flush is required + await writer.SendPayloadAsync(ciTestCycleBuffer).ConfigureAwait(false); + ciTestCycleBuffer.Clear(); + } + + // If there's a flush watermark we marked as resolved. + watermarkCompletion?.TrySetResult(true); + } + catch (ThreadAbortException ex) + { + completionSource?.TrySetException(ex); + watermarkCompletion?.TrySetException(ex); + throw; + } + catch (Exception ex) + { + watermarkCompletion?.TrySetException(ex); + } + finally + { + if (watermarkCompletion is null) + { + // In case there's no flush watermark, we wait before start procesing new events. + flushDelayEvent.WaitOne(BatchInterval, true); + } + else + { + // Because the flush interrupts the dequeueing process we don't wait + // and start processing events again. + watermarkCompletion = null; + } + } + } + + completionSource?.TrySetResult(true); + Log.Debug("CIAgentlessWriter:: InternalFlushEventsAsync/ Finishing FlushEventsAsync loop"); + } + + private Task SendPayloadAsync(EventsPayload payload) + { + return _sender.SendPayloadAsync(payload); + } + + internal class WatermarkEvent : IEvent + { + public WatermarkEvent() + { + CompletionSource = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + } + + public TaskCompletionSource CompletionSource { get; } + } + } +} diff --git a/tracer/src/Datadog.Trace/Ci/Agent/CIWriterFileSender.cs b/tracer/src/Datadog.Trace/Ci/Agent/CIWriterFileSender.cs new file mode 100644 index 000000000..236bf80d1 --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/Agent/CIWriterFileSender.cs @@ -0,0 +1,39 @@ +// +// 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. +// + +using System; +using System.IO; +using System.Threading.Tasks; +using Datadog.Trace.Ci.Agent.Payloads; +using Datadog.Trace.Logging; + +namespace Datadog.Trace.Ci.Agent +{ + /// + /// This class is for debugging purposes only. + /// + internal sealed class CIWriterFileSender : ICIAgentlessWriterSender + { + private static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(); + + public CIWriterFileSender() + { + Log.Information("CIWriterFileSender Initialized."); + } + + public Task SendPayloadAsync(EventsPayload payload) + { + var str = $"c:\\temp\\file-{Guid.NewGuid().ToString("n")}"; + + var msgPackBytes = payload.ToArray(); + File.WriteAllBytes(str + ".mpack", msgPackBytes); + + var json = Vendors.MessagePack.MessagePackSerializer.ToJson(msgPackBytes); + File.WriteAllText(str + ".json", json); + + return Task.CompletedTask; + } + } +} diff --git a/tracer/src/Datadog.Trace/Ci/Agent/CIWriterHttpSender.cs b/tracer/src/Datadog.Trace/Ci/Agent/CIWriterHttpSender.cs new file mode 100644 index 000000000..1cf810ea9 --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/Agent/CIWriterHttpSender.cs @@ -0,0 +1,171 @@ +// +// 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. +// + +using System; +using System.Net.Sockets; +using System.Threading.Tasks; +using Datadog.Trace.Agent; +using Datadog.Trace.Agent.Transports; +using Datadog.Trace.Ci.Agent.Payloads; +using Datadog.Trace.Configuration; +using Datadog.Trace.Logging; + +namespace Datadog.Trace.Ci.Agent +{ + internal sealed class CIWriterHttpSender : ICIAgentlessWriterSender + { + private const string ApiKeyHeader = "dd-api-key"; + private static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(); + + private readonly IApiRequestFactory _apiRequestFactory; + private readonly GlobalSettings _globalSettings; + + public CIWriterHttpSender(IApiRequestFactory apiRequestFactory) + { + _apiRequestFactory = apiRequestFactory; + _globalSettings = GlobalSettings.FromDefaultSources(); + Log.Information("CIWriterHttpSender Initialized."); + } + + public async Task SendPayloadAsync(EventsPayload payload) + { + var numberOfTraces = payload.Count; + var tracesEndpoint = payload.Url; + + // retry up to 5 times with exponential back-off + const int retryLimit = 5; + var retryCount = 1; + var sleepDuration = 100; // in milliseconds + + var payloadMimeType = MimeTypes.MsgPack; + var payloadBytes = payload.ToArray(); + + Log.Information($"Sending ({numberOfTraces} events) {payloadBytes.Length.ToString("N0")} bytes..."); + + while (true) + { + IApiRequest request; + + try + { + request = _apiRequestFactory.Create(tracesEndpoint); + request.AddHeader(ApiKeyHeader, CIVisibility.Settings.ApiKey); + } + catch (Exception ex) + { + Log.Error(ex, "An error occurred while generating http request to send events to {AgentEndpoint}", _apiRequestFactory.Info(tracesEndpoint)); + return; + } + + bool success = false; + Exception exception = null; + bool isFinalTry = retryCount >= retryLimit; + + try + { + success = await SendPayloadAsync(new ArraySegment(payloadBytes), payloadMimeType, request, isFinalTry).ConfigureAwait(false); + } + catch (Exception ex) + { + exception = ex; + + if (_globalSettings.DebugEnabled) + { + if (ex.InnerException is InvalidOperationException ioe) + { + Log.Error(ex, "An error occurred while sending {Count} events to {AgentEndpoint}", numberOfTraces, _apiRequestFactory.Info(tracesEndpoint)); + return; + } + } + } + + // Error handling block + if (!success) + { + if (isFinalTry) + { + // stop retrying + Log.Error(exception, "An error occurred while sending {Count} events to {AgentEndpoint}", numberOfTraces, _apiRequestFactory.Info(tracesEndpoint)); + return; + } + + // Before retry delay + bool isSocketException = false; + Exception innerException = exception; + + while (innerException != null) + { + if (innerException is SocketException) + { + isSocketException = true; + break; + } + + innerException = innerException.InnerException; + } + + if (isSocketException) + { + Log.Debug(exception, "Unable to communicate with {AgentEndpoint}", _apiRequestFactory.Info(tracesEndpoint)); + } + + // Execute retry delay + await Task.Delay(sleepDuration).ConfigureAwait(false); + retryCount++; + sleepDuration *= 2; + + continue; + } + + Log.Debug("Successfully sent {Count} events to {AgentEndpoint}", numberOfTraces, _apiRequestFactory.Info(tracesEndpoint)); + return; + } + } + + private async Task SendPayloadAsync(ArraySegment payload, string mimeType, IApiRequest request, bool finalTry) + { + IApiResponse response = null; + + try + { + try + { + response = await request.PostAsync(payload, mimeType).ConfigureAwait(false); + } + catch + { + // count only network/infrastructure errors, not valid responses with error status codes + // (which are handled below) + throw; + } + + // Attempt a retry if the status code is not SUCCESS + if (response.StatusCode < 200 || response.StatusCode >= 300) + { + if (finalTry) + { + try + { + string responseContent = await response.ReadAsStringAsync().ConfigureAwait(false); + Log.Error("Failed to submit events with status code {StatusCode} and message: {ResponseContent}", response.StatusCode, responseContent); + } + catch (Exception ex) + { + Log.Error(ex, "Unable to read response for failed request with status code {StatusCode}", response.StatusCode); + } + } + + return false; + } + } + finally + { + response?.Dispose(); + } + + return true; + } + } +} diff --git a/tracer/src/Datadog.Trace/Ci/Agent/ICIAgentlessWriterSender.cs b/tracer/src/Datadog.Trace/Ci/Agent/ICIAgentlessWriterSender.cs new file mode 100644 index 000000000..e5e71e477 --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/Agent/ICIAgentlessWriterSender.cs @@ -0,0 +1,15 @@ +// +// 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. +// + +using System.Threading.Tasks; +using Datadog.Trace.Ci.Agent.Payloads; + +namespace Datadog.Trace.Ci.Agent +{ + internal interface ICIAgentlessWriterSender + { + Task SendPayloadAsync(EventsPayload payload); + } +} diff --git a/tracer/src/Datadog.Trace/Ci/Agent/IEventWriter.cs b/tracer/src/Datadog.Trace/Ci/Agent/IEventWriter.cs new file mode 100644 index 000000000..ee50d5add --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/Agent/IEventWriter.cs @@ -0,0 +1,17 @@ +// +// 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. +// + +using Datadog.Trace.Agent; + +namespace Datadog.Trace.Ci.Agent +{ + /// + /// Event Writer interface + /// + internal interface IEventWriter : IAgentWriter + { + void WriteEvent(IEvent @event); + } +} diff --git a/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/CIEventMessagePackFormatter.cs b/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/CIEventMessagePackFormatter.cs new file mode 100644 index 000000000..64e13cac5 --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/CIEventMessagePackFormatter.cs @@ -0,0 +1,200 @@ +// +// 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. +// + +#nullable enable + +using System; +using Datadog.Trace.Ci.Agent.Payloads; +using Datadog.Trace.Ci.Tags; +using Datadog.Trace.Configuration; +using Datadog.Trace.PlatformHelpers; +using Datadog.Trace.Vendors.MessagePack; + +namespace Datadog.Trace.Ci.Agent.MessagePack +{ + internal class CIEventMessagePackFormatter : EventMessagePackFormatter + { + private readonly byte[] _metadataBytes = StringEncoding.UTF8.GetBytes("metadata"); + private readonly byte[] _containerIdBytes = StringEncoding.UTF8.GetBytes("container_id"); + private readonly byte[]? _containerIdValueBytes; + private readonly byte[] _runtimeIdBytes = StringEncoding.UTF8.GetBytes("runtime_id"); + private readonly byte[] _runtimeIdValueBytes = StringEncoding.UTF8.GetBytes(Tracer.RuntimeId); + private readonly byte[] _languageNameBytes = StringEncoding.UTF8.GetBytes("language"); + private readonly byte[] _languageNameValueBytes = StringEncoding.UTF8.GetBytes("dotnet"); + private readonly byte[] _languageInterpreterBytes = StringEncoding.UTF8.GetBytes(CommonTags.RuntimeName); + private readonly byte[] _languageInterpreterValueBytes = StringEncoding.UTF8.GetBytes(FrameworkDescription.Instance.Name); + private readonly byte[] _languageVersionBytes = StringEncoding.UTF8.GetBytes(CommonTags.RuntimeVersion); + private readonly byte[] _languageVersionValueBytes = StringEncoding.UTF8.GetBytes(FrameworkDescription.Instance.ProductVersion); + + private readonly byte[] _ciLibraryVersionBytes = StringEncoding.UTF8.GetBytes(CommonTags.LibraryVersion); + private readonly byte[] _ciLibraryVersionValueBytes = StringEncoding.UTF8.GetBytes(TracerConstants.AssemblyVersion); + + private readonly byte[] _environmentBytes = StringEncoding.UTF8.GetBytes("env"); + private readonly byte[]? _environmentValueBytes; + private readonly byte[] _serviceBytes = StringEncoding.UTF8.GetBytes("service"); + private readonly byte[]? _serviceValueBytes; + private readonly byte[] _appVersionBytes = StringEncoding.UTF8.GetBytes("app_version"); + private readonly byte[]? _appVersionValueBytes; + private readonly byte[] _hostnameBytes = StringEncoding.UTF8.GetBytes("hostname"); + private readonly byte[] _hostnameValueBytes = StringEncoding.UTF8.GetBytes(HostMetadata.Instance.Hostname); + + private readonly byte[] _eventsBytes = StringEncoding.UTF8.GetBytes("events"); + + private readonly ArraySegment _envelopBytes; + + public CIEventMessagePackFormatter(TracerSettings tracerSettings) + { + var containerId = ContainerMetadata.GetContainerId(); + if (containerId is not null) + { + _containerIdValueBytes = StringEncoding.UTF8.GetBytes(containerId); + } + else + { + _containerIdValueBytes = null; + } + + var environment = tracerSettings.Environment; + if (environment is not null) + { + _environmentValueBytes = StringEncoding.UTF8.GetBytes(environment); + } + else + { + _environmentValueBytes = null; + } + + var service = tracerSettings.ServiceName; + if (service is not null) + { + _serviceValueBytes = StringEncoding.UTF8.GetBytes(service); + } + else + { + _serviceValueBytes = null; + } + + var serviceVersion = tracerSettings.ServiceVersion; + if (serviceVersion is not null) + { + _appVersionValueBytes = StringEncoding.UTF8.GetBytes(serviceVersion); + } + else + { + _appVersionValueBytes = null; + } + + _envelopBytes = GetEnvelopeArraySegment(); + } + + public override int Serialize(ref byte[] bytes, int offset, EventsPayload? value, IFormatterResolver formatterResolver) + { + if (value is null) + { + return 0; + } + + var originalOffset = offset; + + // Write envelope + MessagePackBinary.EnsureCapacity(ref bytes, offset, _envelopBytes.Count); + Buffer.BlockCopy(_envelopBytes.Array!, _envelopBytes.Offset, bytes, offset, _envelopBytes.Count); + offset += _envelopBytes.Count; + + // Write events + if (value.Events.Lock()) + { + var data = value.Events.Data; + MessagePackBinary.EnsureCapacity(ref bytes, offset, data.Count); + Buffer.BlockCopy(data.Array!, data.Offset, bytes, offset, data.Count); + offset += data.Count; + } + else + { + Log.Error("Error while locking the events buffer with {count} events.", value.Events.Count); + offset += MessagePackBinary.WriteNil(ref bytes, offset); + } + + return offset - originalOffset; + } + + private ArraySegment GetEnvelopeArraySegment() + { + var offset = 0; + var bytes = new byte[1024]; + + offset += MessagePackBinary.WriteMapHeader(ref bytes, offset, 3); + + // . + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, VersionBytes); + offset += MessagePackBinary.WriteInt32(ref bytes, offset, 1); + + // . + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _metadataBytes); + + offset += MessagePackBinary.WriteMapHeader(ref bytes, offset, 10); + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _containerIdBytes); + if (_containerIdValueBytes is not null) + { + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _containerIdValueBytes); + } + else + { + offset += MessagePackBinary.WriteNil(ref bytes, offset); + } + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _runtimeIdBytes); + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _runtimeIdValueBytes); + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _languageNameBytes); + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _languageNameValueBytes); + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _languageInterpreterBytes); + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _languageInterpreterValueBytes); + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _languageVersionBytes); + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _languageVersionValueBytes); + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _ciLibraryVersionBytes); + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _ciLibraryVersionValueBytes); + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _environmentBytes); + if (_environmentValueBytes is not null) + { + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _environmentValueBytes); + } + else + { + offset += MessagePackBinary.WriteNil(ref bytes, offset); + } + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _serviceBytes); + if (_serviceValueBytes is not null) + { + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _serviceValueBytes); + } + else + { + offset += MessagePackBinary.WriteNil(ref bytes, offset); + } + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _appVersionBytes); + if (_appVersionValueBytes is not null) + { + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _appVersionValueBytes); + } + else + { + offset += MessagePackBinary.WriteNil(ref bytes, offset); + } + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _hostnameBytes); + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _hostnameValueBytes); + + // . + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _eventsBytes); + + return new ArraySegment(bytes, 0, offset); + } + } +} diff --git a/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/CIFormatterResolver.cs b/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/CIFormatterResolver.cs new file mode 100644 index 000000000..7f04f9dbf --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/CIFormatterResolver.cs @@ -0,0 +1,63 @@ +// +// 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. +// + +using Datadog.Trace.Ci.Agent.Payloads; +using Datadog.Trace.Ci.EventModel; +using Datadog.Trace.Vendors.MessagePack; +using Datadog.Trace.Vendors.MessagePack.Formatters; +using Datadog.Trace.Vendors.MessagePack.Resolvers; + +namespace Datadog.Trace.Ci.Agent.MessagePack +{ + internal class CIFormatterResolver : IFormatterResolver + { + public static readonly IFormatterResolver Instance = new CIFormatterResolver(); + + private readonly IMessagePackFormatter _spanFormatter; + private readonly IMessagePackFormatter _eventsPayloadFormatter; + private readonly IMessagePackFormatter _eventFormatter; + private readonly IMessagePackFormatter _testEventFormatter; + private readonly IMessagePackFormatter _spanEventFormatter; + + private CIFormatterResolver() + { + _spanFormatter = SpanMessagePackFormatter.Instance; + _eventsPayloadFormatter = new CIEventMessagePackFormatter(CIVisibility.Settings.TracerSettings); + _eventFormatter = new IEventMessagePackFormatter(); + _testEventFormatter = new TestEventMessagePackFormatter(); + _spanEventFormatter = new SpanEventMessagePackFormatter(); + } + + public IMessagePackFormatter GetFormatter() + { + if (typeof(T) == typeof(Span)) + { + return (IMessagePackFormatter)_spanFormatter; + } + + if (typeof(T) == typeof(EventsPayload)) + { + return (IMessagePackFormatter)_eventsPayloadFormatter; + } + + if (typeof(T) == typeof(IEvent)) + { + return (IMessagePackFormatter)_eventFormatter; + } + + if (typeof(T) == typeof(TestEvent)) + { + return (IMessagePackFormatter)_testEventFormatter; + } + + if (typeof(T) == typeof(SpanEvent)) + { + return (IMessagePackFormatter)_spanEventFormatter; + } + + return StandardResolver.Instance.GetFormatter(); + } + } +} diff --git a/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/EventMessagePackFormatter.cs b/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/EventMessagePackFormatter.cs new file mode 100644 index 000000000..1987c6b35 --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/EventMessagePackFormatter.cs @@ -0,0 +1,35 @@ +// +// 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. +// + +using System; +using Datadog.Trace.Logging; +using Datadog.Trace.Vendors.MessagePack; +using Datadog.Trace.Vendors.MessagePack.Formatters; + +namespace Datadog.Trace.Ci.Agent.MessagePack +{ + internal abstract class EventMessagePackFormatter : IMessagePackFormatter + { + private readonly IDatadogLogger _log; + + protected static readonly byte[] TypeBytes = StringEncoding.UTF8.GetBytes("type"); + protected static readonly byte[] VersionBytes = StringEncoding.UTF8.GetBytes("version"); + protected static readonly byte[] ContentBytes = StringEncoding.UTF8.GetBytes("content"); + + public EventMessagePackFormatter() + { + _log = DatadogLogging.GetLoggerFor(GetType()); + } + + protected IDatadogLogger Log => _log; + + public virtual T Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + throw new NotImplementedException(); + } + + public abstract int Serialize(ref byte[] bytes, int offset, T value, IFormatterResolver formatterResolver); + } +} diff --git a/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/IEventMessagePackFormatter.cs b/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/IEventMessagePackFormatter.cs new file mode 100644 index 000000000..fa41b7927 --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/IEventMessagePackFormatter.cs @@ -0,0 +1,35 @@ +// +// 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. +// + +using System; +using Datadog.Trace.Ci.EventModel; +using Datadog.Trace.Vendors.MessagePack; +using Datadog.Trace.Vendors.MessagePack.Formatters; + +namespace Datadog.Trace.Ci.Agent.MessagePack +{ + internal class IEventMessagePackFormatter : IMessagePackFormatter + { + public IEvent Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + throw new NotImplementedException(); + } + + public int Serialize(ref byte[] bytes, int offset, IEvent value, IFormatterResolver formatterResolver) + { + if (value is SpanEvent spanEvent) + { + return formatterResolver.GetFormatter().Serialize(ref bytes, offset, spanEvent, formatterResolver); + } + + if (value is TestEvent testEvent) + { + return formatterResolver.GetFormatter().Serialize(ref bytes, offset, testEvent, formatterResolver); + } + + return 0; + } + } +} diff --git a/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/SpanEventMessagePackFormatter.cs b/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/SpanEventMessagePackFormatter.cs new file mode 100644 index 000000000..277d1f686 --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/SpanEventMessagePackFormatter.cs @@ -0,0 +1,36 @@ +// +// 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. +// + +using Datadog.Trace.Ci.EventModel; +using Datadog.Trace.Vendors.MessagePack; + +namespace Datadog.Trace.Ci.Agent.MessagePack +{ + internal class SpanEventMessagePackFormatter : EventMessagePackFormatter + { + public override int Serialize(ref byte[] bytes, int offset, SpanEvent value, IFormatterResolver formatterResolver) + { + if (value is null) + { + return 0; + } + + var originalOffset = offset; + + offset += MessagePackBinary.WriteMapHeader(ref bytes, offset, 3); + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, TypeBytes); + offset += MessagePackBinary.WriteString(ref bytes, offset, value.Type); + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, VersionBytes); + offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.Version); + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, ContentBytes); + offset += formatterResolver.GetFormatter().Serialize(ref bytes, offset, value.Content, formatterResolver); + + return offset - originalOffset; + } + } +} diff --git a/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/SpanMessagePackFormatter.cs b/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/SpanMessagePackFormatter.cs new file mode 100644 index 000000000..1ba11218e --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/SpanMessagePackFormatter.cs @@ -0,0 +1,95 @@ +// +// 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. +// + +using System; +using Datadog.Trace.ExtensionMethods; +using Datadog.Trace.Processors; +using Datadog.Trace.Vendors.MessagePack; +using Datadog.Trace.Vendors.MessagePack.Formatters; + +namespace Datadog.Trace.Ci.Agent.MessagePack +{ + internal class SpanMessagePackFormatter : IMessagePackFormatter + { + public static readonly IMessagePackFormatter Instance = new SpanMessagePackFormatter(); + + private readonly byte[] _traceIdBytes = StringEncoding.UTF8.GetBytes("trace_id"); + private readonly byte[] _spanIdBytes = StringEncoding.UTF8.GetBytes("span_id"); + private readonly byte[] _nameBytes = StringEncoding.UTF8.GetBytes("name"); + private readonly byte[] _resourceBytes = StringEncoding.UTF8.GetBytes("resource"); + private readonly byte[] _serviceBytes = StringEncoding.UTF8.GetBytes("service"); + private readonly byte[] _typeBytes = StringEncoding.UTF8.GetBytes("type"); + private readonly byte[] _startBytes = StringEncoding.UTF8.GetBytes("start"); + private readonly byte[] _durationBytes = StringEncoding.UTF8.GetBytes("duration"); + private readonly byte[] _parentIdBytes = StringEncoding.UTF8.GetBytes("parent_id"); + private readonly byte[] _errorBytes = StringEncoding.UTF8.GetBytes("error"); + + private SpanMessagePackFormatter() + { + } + + public int Serialize(ref byte[] bytes, int offset, Span value, IFormatterResolver formatterResolver) + { + int originalOffset = offset; + + offset += MessagePackBinary.WriteMapHeader(ref bytes, offset, 12); + + var context = value.Context; + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _traceIdBytes); + offset += MessagePackBinary.WriteString(ref bytes, offset, context.TraceId.ToString()); + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _spanIdBytes); + offset += MessagePackBinary.WriteString(ref bytes, offset, context.SpanId.ToString()); + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _nameBytes); + offset += MessagePackBinary.WriteString(ref bytes, offset, value.OperationName); + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _resourceBytes); + offset += MessagePackBinary.WriteString(ref bytes, offset, value.ResourceName); + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _serviceBytes); + offset += MessagePackBinary.WriteString(ref bytes, offset, value.ServiceName); + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _typeBytes); + offset += MessagePackBinary.WriteString(ref bytes, offset, value.Type); + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _startBytes); + offset += MessagePackBinary.WriteInt64(ref bytes, offset, value.StartTime.ToUnixTimeNanoseconds()); + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _durationBytes); + offset += MessagePackBinary.WriteInt64(ref bytes, offset, value.Duration.ToNanoseconds()); + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _parentIdBytes); + var parentId = value.Context.ParentId; + if (parentId.HasValue) + { + offset += MessagePackBinary.WriteString(ref bytes, offset, parentId.Value.ToString()); + } + else + { + offset += MessagePackBinary.WriteNil(ref bytes, offset); + } + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, _errorBytes); + offset += MessagePackBinary.WriteByte(ref bytes, offset, (byte)(value.Error ? 1 : 0)); + + ITagProcessor[] tagProcessors = null; + if (value.Context.TraceContext?.Tracer is Tracer tracer) + { + tagProcessors = tracer.TracerManager?.TagProcessors; + } + + offset += value.Tags.SerializeTo(ref bytes, offset, value, tagProcessors); + + return offset - originalOffset; + } + + public Span Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) + { + throw new NotImplementedException(); + } + } +} diff --git a/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/TestEventMessagePackFormatter.cs b/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/TestEventMessagePackFormatter.cs new file mode 100644 index 000000000..fdb30bc45 --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/Agent/MessagePack/TestEventMessagePackFormatter.cs @@ -0,0 +1,36 @@ +// +// 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. +// + +using Datadog.Trace.Ci.EventModel; +using Datadog.Trace.Vendors.MessagePack; + +namespace Datadog.Trace.Ci.Agent.MessagePack +{ + internal class TestEventMessagePackFormatter : EventMessagePackFormatter + { + public override int Serialize(ref byte[] bytes, int offset, TestEvent value, IFormatterResolver formatterResolver) + { + if (value is null) + { + return 0; + } + + var originalOffset = offset; + + offset += MessagePackBinary.WriteMapHeader(ref bytes, offset, 3); + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, TypeBytes); + offset += MessagePackBinary.WriteString(ref bytes, offset, value.Type); + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, VersionBytes); + offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.Version); + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, ContentBytes); + offset += formatterResolver.GetFormatter().Serialize(ref bytes, offset, value.Content, formatterResolver); + + return offset - originalOffset; + } + } +} diff --git a/tracer/src/Datadog.Trace/Ci/Agent/Payloads/CITestCyclePayload.cs b/tracer/src/Datadog.Trace/Ci/Agent/Payloads/CITestCyclePayload.cs new file mode 100644 index 000000000..a142cf875 --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/Agent/Payloads/CITestCyclePayload.cs @@ -0,0 +1,33 @@ +// +// 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. +// + +using System; +using Datadog.Trace.Ci.EventModel; + +namespace Datadog.Trace.Ci.Agent.Payloads +{ + internal class CITestCyclePayload : EventsPayload + { + public CITestCyclePayload() + { + var builder = new UriBuilder("https://datadog.host.com/api/v2/citestcycle"); + builder.Host = "citestcycle-intake." + CIVisibility.Settings.Site; + Url = builder.Uri; + } + + public override Uri Url { get; } + + public override bool CanProcessEvent(IEvent @event) + { + // This intake accepts both Span and Test events + if (@event is SpanEvent or TestEvent) + { + return true; + } + + return false; + } + } +} diff --git a/tracer/src/Datadog.Trace/Ci/Agent/Payloads/EventsBuffer.cs b/tracer/src/Datadog.Trace/Ci/Agent/Payloads/EventsBuffer.cs new file mode 100644 index 000000000..688aa6e82 --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/Agent/Payloads/EventsBuffer.cs @@ -0,0 +1,162 @@ +// +// 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. +// + +using System; +using System.Threading; +using Datadog.Trace.Logging; +using Datadog.Trace.Util; +using Datadog.Trace.Vendors.MessagePack; +using Datadog.Trace.Vendors.MessagePack.Formatters; + +namespace Datadog.Trace.Ci.Agent.Payloads +{ + internal class EventsBuffer + { + protected static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor>(); + + internal const int HeaderSize = 5; + internal const int InitialBufferSize = 64 * 1024; + + private readonly IMessagePackFormatter _formatter; + private readonly IFormatterResolver _formatterResolver; + private readonly object _syncRoot = new object(); + private readonly int _maxBufferSize; + + private byte[] _buffer; + private bool _locked; + private int _offset; + + public EventsBuffer(int maxBufferSize, IFormatterResolver formatterResolver) + { + if (maxBufferSize < HeaderSize) + { + ThrowHelper.ThrowArgumentException($"Buffer size should be at least {HeaderSize}", nameof(maxBufferSize)); + } + + _maxBufferSize = maxBufferSize; + _offset = HeaderSize; + _buffer = new byte[Math.Min(InitialBufferSize, maxBufferSize)]; + _formatterResolver = formatterResolver; + _formatter = _formatterResolver.GetFormatter(); + + if (_formatter is null) + { + ThrowHelper.ThrowNullReferenceException($"Formatter for '{_formatter}' is null"); + } + } + + public ArraySegment Data + { + get + { + if (!_locked) + { + // Sanity check - headers are written when the buffer is locked + ThrowHelper.ThrowInvalidOperationException("Data was extracted from the buffer without locking"); + } + + return new ArraySegment(_buffer, 0, _offset); + } + } + + public int Count { get; private set; } + + public bool IsFull { get; private set; } + + // For tests only + internal bool IsLocked => _locked; + + // For tests only + internal bool IsEmpty => !_locked && !IsFull && Count == 0 && _offset == HeaderSize; + + public bool TryWrite(T item) + { + bool lockTaken = false; + + try + { + Monitor.TryEnter(_syncRoot, ref lockTaken); + + if (!lockTaken || _locked) + { + // A flush operation is in progress, consider this buffer full + return false; + } + + if (IsFull) + { + // Buffer is full + return false; + } + + try + { + // We serialize the item + // Note: By serializing an item near the buffer limit can make the buffer to grow + // and at the same time we will reject that item. Although we don't expect that happens + // too often. + var size = _formatter.Serialize(ref _buffer, _offset, item, _formatterResolver); + + // In case we overpass the max buffer size, we reject the last serialization. + if (_offset + size > _maxBufferSize) + { + IsFull = true; + return false; + } + + // Move the offset to accept the last serialization and increase the counter + _offset += size; + Count++; + } + catch (Exception ex) + { + Log.Error(ex, ex.Message); + } + + if (_offset >= _maxBufferSize) + { + IsFull = true; + } + + return true; + } + finally + { + if (lockTaken) + { + Monitor.Exit(_syncRoot); + } + } + } + + public bool Lock() + { + lock (_syncRoot) + { + if (_locked) + { + return false; + } + + // Use a fixed-size header + MessagePackBinary.WriteArrayHeaderForceArray32Block(ref _buffer, 0, (uint)Count); + _locked = true; + + return true; + } + } + + public void Clear() + { + lock (_syncRoot) + { + _offset = HeaderSize; + Count = 0; + IsFull = false; + _locked = false; + } + } + } +} diff --git a/tracer/src/Datadog.Trace/Ci/Agent/Payloads/EventsPayload.cs b/tracer/src/Datadog.Trace/Ci/Agent/Payloads/EventsPayload.cs new file mode 100644 index 000000000..a88026156 --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/Agent/Payloads/EventsPayload.cs @@ -0,0 +1,53 @@ +// +// 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. +// + +using System; +using Datadog.Trace.Ci.Agent.MessagePack; +using Datadog.Trace.Logging; +using Datadog.Trace.Vendors.MessagePack; + +namespace Datadog.Trace.Ci.Agent.Payloads +{ + internal abstract class EventsPayload + { + protected static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(); + + private readonly EventsBuffer _events; + private readonly IFormatterResolver _formatterResolver; + + public EventsPayload(IFormatterResolver formatterResolver = null) + { + _formatterResolver = formatterResolver ?? CIFormatterResolver.Instance; + + // Because we don't know the size of the events array envelope we left 500kb for that. + _events = new EventsBuffer(Ci.CIVisibility.Settings.MaximumAgentlessPayloadSize - (500 * 1024), _formatterResolver); + } + + public abstract Uri Url { get; } + + public bool HasEvents => _events.Count > 0; + + public int Count => _events.Count; + + internal EventsBuffer Events => _events; + + public abstract bool CanProcessEvent(IEvent @event); + + public bool TryProcessEvent(IEvent @event) + { + return _events.TryWrite(@event); + } + + public void Clear() + { + _events.Clear(); + } + + public byte[] ToArray() + { + return MessagePackSerializer.Serialize(this, _formatterResolver); + } + } +} diff --git a/tracer/src/Datadog.Trace/Ci/CITracerManager.cs b/tracer/src/Datadog.Trace/Ci/CITracerManager.cs index f608d604d..aaec3a2d2 100644 --- a/tracer/src/Datadog.Trace/Ci/CITracerManager.cs +++ b/tracer/src/Datadog.Trace/Ci/CITracerManager.cs @@ -5,9 +5,14 @@ // Modified by Splunk Inc. +using System; +using System.Runtime.CompilerServices; using Datadog.Trace.Agent; +using Datadog.Trace.Ci.Agent; +using Datadog.Trace.Ci.EventModel; using Datadog.Trace.Configuration; using Datadog.Trace.Conventions; +using Datadog.Trace.Logging; using Datadog.Trace.Logging.DirectSubmission; using Datadog.Trace.Propagation; using Datadog.Trace.RuntimeMetrics; @@ -19,9 +24,54 @@ namespace Datadog.Trace.Ci { internal class CITracerManager : TracerManager, ILockedTracer { + private static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(); + public CITracerManager(ImmutableTracerSettings settings, IAgentWriter agentWriter, ISampler sampler, IPropagator propagator, IScopeManager scopeManager, IDogStatsd statsd, RuntimeMetricsWriter runtimeMetricsWriter, ITraceIdConvention traceIdConvention, DirectLogSubmissionManager logSubmissionManager, ITelemetryController telemetry, string defaultServiceName) - : base(settings, agentWriter, sampler, propagator, scopeManager, statsd, runtimeMetricsWriter, traceIdConvention, logSubmissionManager, telemetry, defaultServiceName) + : base(settings, agentWriter, sampler, propagator, scopeManager, statsd, runtimeMetricsWriter, traceIdConvention, logSubmissionManager, telemetry, defaultServiceName, new Trace.Processors.ITraceProcessor[] + { + new Trace.Processors.NormalizerTraceProcessor(), + new Trace.Processors.TruncatorTraceProcessor(), + new Processors.OriginTagTraceProcessor(settings.ExporterSettings.PartialFlushEnabled, agentWriter is CIAgentlessWriter), + }) { } + + private Span ProcessSpan(Span span) + { + if (span is not null) + { + foreach (var processor in TraceProcessors) + { + if (processor is not null) + { + try + { + span = processor.Process(span); + } + catch (Exception e) + { + Log.Error(e, e.Message); + } + } + } + } + + return span; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void WriteEvent(IEvent @event) + { + if (@event is TestEvent testEvent) + { + testEvent.Content = ProcessSpan(testEvent.Content); + } + else if (@event is SpanEvent spanEvent) + { + spanEvent.Content = ProcessSpan(spanEvent.Content); + } + + ((IEventWriter)AgentWriter).WriteEvent(@event); + } } } diff --git a/tracer/src/Datadog.Trace/Ci/CITracerManagerFactory.cs b/tracer/src/Datadog.Trace/Ci/CITracerManagerFactory.cs index 199857ecb..1973cd18e 100644 --- a/tracer/src/Datadog.Trace/Ci/CITracerManagerFactory.cs +++ b/tracer/src/Datadog.Trace/Ci/CITracerManagerFactory.cs @@ -5,11 +5,16 @@ // Modified by Splunk Inc. +using System; +using System.Net; using Datadog.Trace.Agent; +using Datadog.Trace.Agent.Transports; using Datadog.Trace.Ci.Agent; +using Datadog.Trace.Ci.Configuration; using Datadog.Trace.Ci.Sampling; using Datadog.Trace.Configuration; using Datadog.Trace.Conventions; +using Datadog.Trace.Logging; using Datadog.Trace.Logging.DirectSubmission; using Datadog.Trace.Propagation; using Datadog.Trace.RuntimeMetrics; @@ -21,6 +26,14 @@ namespace Datadog.Trace.Ci { internal class CITracerManagerFactory : TracerManagerFactory { + private static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(); + private CIVisibilitySettings _settings; + + public CITracerManagerFactory(CIVisibilitySettings settings) + { + _settings = settings; + } + protected override TracerManager CreateTracerManagerFrom( ImmutableTracerSettings settings, IAgentWriter agentWriter, @@ -44,7 +57,68 @@ protected override ISampler GetSampler(ImmutableTracerSettings settings) protected override IAgentWriter GetAgentWriter(ImmutableTracerSettings settings, IDogStatsd statsd, ISampler sampler) { - return new CIAgentWriter(settings, sampler); + // Check for agentless scenario + if (_settings.Agentless) + { + if (!string.IsNullOrEmpty(_settings.ApiKey)) + { + return new CIAgentlessWriter(settings, sampler, new CIWriterHttpSender(GetRequestFactory())); + } + else + { + Environment.FailFast("An API key is required in Agentless mode."); + return null; + } + } + else + { + // With agent scenario: + + // Set the tracer buffer size to the max + var traceBufferSize = 1024 * 1024 * 45; // slightly lower than the 50mb payload agent limit. + return new CIAgentWriter(settings, sampler, traceBufferSize); + } + } + + private IApiRequestFactory GetRequestFactory() + { + IApiRequestFactory factory = null; +#if NETCOREAPP + Log.Information("Using {FactoryType} for trace transport.", nameof(HttpClientRequestFactory)); + factory = new HttpClientRequestFactory(AgentHttpHeaderNames.DefaultHeaders); +#else + Log.Information("Using {FactoryType} for trace transport.", nameof(ApiWebRequestFactory)); + factory = new ApiWebRequestFactory(AgentHttpHeaderNames.DefaultHeaders); +#endif + + if (!string.IsNullOrWhiteSpace(_settings.ProxyHttps)) + { + var proxyHttpsUriBuilder = new UriBuilder(_settings.ProxyHttps); + + var userName = proxyHttpsUriBuilder.UserName; + var password = proxyHttpsUriBuilder.Password; + + proxyHttpsUriBuilder.UserName = string.Empty; + proxyHttpsUriBuilder.Password = string.Empty; + + if (proxyHttpsUriBuilder.Scheme == "https") + { + // HTTPS proxy is not supported by .NET BCL + Log.Error($"HTTPS proxy is not supported. ({proxyHttpsUriBuilder})"); + return factory; + } + + NetworkCredential credential = null; + if (!string.IsNullOrWhiteSpace(userName)) + { + credential = new NetworkCredential(userName, password); + } + + Log.Information("Setting proxy to: {ProxyHttps}", proxyHttpsUriBuilder.Uri.ToString()); + factory.SetProxy(new WebProxy(proxyHttpsUriBuilder.Uri, true, _settings.ProxyNoProxy, credential), credential); + } + + return factory; } } } diff --git a/tracer/src/Datadog.Trace/Ci/CIVisibility.cs b/tracer/src/Datadog.Trace/Ci/CIVisibility.cs index dbc7d6aab..54bcb7d15 100644 --- a/tracer/src/Datadog.Trace/Ci/CIVisibility.cs +++ b/tracer/src/Datadog.Trace/Ci/CIVisibility.cs @@ -27,6 +27,21 @@ internal class CIVisibility public static bool IsRunning => Interlocked.CompareExchange(ref _firstInitialization, 0, 0) == 0; + public static CIVisibilitySettings Settings => _settings; + + public static CITracerManager Manager + { + get + { + if (Tracer.Instance.TracerManager is CITracerManager cITracerManager) + { + return cITracerManager; + } + + return null; + } + } + public static void Initialize() { if (Interlocked.Exchange(ref _firstInitialization, 0) != 1) @@ -39,10 +54,7 @@ public static void Initialize() LifetimeManager.Instance.AddShutdownTask(FlushSpans); - TracerSettings tracerSettings = _settings.TracerSettings ?? TracerSettings.FromDefaultSources(); - - // Set the tracer buffer size to the max - tracerSettings.TraceBufferSize = 1024 * 1024 * 45; // slightly lower than the 50mb payload agent limit. + TracerSettings tracerSettings = _settings.TracerSettings; // Set the service name if empty Log.Information("Setting up the service name"); @@ -54,7 +66,7 @@ public static void Initialize() // Initialize Tracer Log.Information("Initialize Test Tracer instance"); - TracerManager.ReplaceGlobalManager(tracerSettings.Build(), new CITracerManagerFactory()); + TracerManager.ReplaceGlobalManager(tracerSettings.Build(), new CITracerManagerFactory(_settings)); } internal static void FlushSpans() @@ -141,7 +153,7 @@ private static bool InternalEnabled() try { // Set the configuration key to propagate the configuration to child processes. - Environment.SetEnvironmentVariable(ConfigurationKeys.CIVisibilityEnabled, "1", EnvironmentVariableTarget.Process); + Environment.SetEnvironmentVariable(ConfigurationKeys.CIVisibility.Enabled, "1", EnvironmentVariableTarget.Process); } catch { @@ -159,7 +171,7 @@ private static bool InternalEnabled() try { // Set the configuration key to propagate the configuration to child processes. - Environment.SetEnvironmentVariable(ConfigurationKeys.CIVisibilityEnabled, "1", EnvironmentVariableTarget.Process); + Environment.SetEnvironmentVariable(ConfigurationKeys.CIVisibility.Enabled, "1", EnvironmentVariableTarget.Process); } catch { diff --git a/tracer/src/Datadog.Trace/Ci/Configuration/CIVisibilitySettings.cs b/tracer/src/Datadog.Trace/Ci/Configuration/CIVisibilitySettings.cs index c10ac2eba..e61213b4a 100644 --- a/tracer/src/Datadog.Trace/Ci/Configuration/CIVisibilitySettings.cs +++ b/tracer/src/Datadog.Trace/Ci/Configuration/CIVisibilitySettings.cs @@ -3,6 +3,7 @@ // This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc. // +using System; using Datadog.Trace.Configuration; namespace Datadog.Trace.Ci.Configuration @@ -11,15 +12,59 @@ internal class CIVisibilitySettings { public CIVisibilitySettings(IConfigurationSource source) { - Enabled = source?.GetBool(ConfigurationKeys.CIVisibilityEnabled) ?? false; - if (Enabled) - { - TracerSettings = new TracerSettings(source); - } + Enabled = source?.GetBool(ConfigurationKeys.CIVisibility.Enabled) ?? false; + Agentless = source?.GetBool(ConfigurationKeys.CIVisibility.AgentlessEnabled) ?? false; + ApiKey = source?.GetString(ConfigurationKeys.ApiKey); + Site = source?.GetString(ConfigurationKeys.Site) ?? "datadoghq.com"; + + // By default intake payloads has a 5MB limit + MaximumAgentlessPayloadSize = 5 * 1024 * 1024; + + ProxyHttps = source?.GetString(ConfigurationKeys.Proxy.ProxyHttps); + var proxyNoProxy = source?.GetString(ConfigurationKeys.Proxy.ProxyNoProxy) ?? string.Empty; + ProxyNoProxy = proxyNoProxy.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); + + TracerSettings = new TracerSettings(source); } + /// + /// Gets a value indicating whether the CI Visibility mode was enabled by configuration + /// public bool Enabled { get; } + /// + /// Gets a value indicating whether the Agentless writer is going to be used. + /// + public bool Agentless { get; } + + /// + /// Gets the Api Key to use in Agentless mode + /// + public string ApiKey { get; } + + /// + /// Gets the Datadog site + /// + public string Site { get; } + + /// + /// Gets the maximum agentless payload size + /// + public int MaximumAgentlessPayloadSize { get; } + + /// + /// Gets the https proxy + /// + public string ProxyHttps { get; } + + /// + /// Gets the no proxy list + /// + public string[] ProxyNoProxy { get; } + + /// + /// Gets the tracer settings + /// public TracerSettings TracerSettings { get; } public static CIVisibilitySettings FromDefaultSources() diff --git a/tracer/src/Datadog.Trace/Ci/EventModel/CIVisibilityEvent.cs b/tracer/src/Datadog.Trace/Ci/EventModel/CIVisibilityEvent.cs new file mode 100644 index 000000000..79c794d51 --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/EventModel/CIVisibilityEvent.cs @@ -0,0 +1,23 @@ +// +// 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. +// + +namespace Datadog.Trace.Ci.EventModel +{ + internal class CIVisibilityEvent : IEvent + { + internal CIVisibilityEvent(string type, int version, T content) + { + Type = type; + Version = version; + Content = content; + } + + public string Type { get; set; } + + public int Version { get; } + + public T Content { get; set; } + } +} diff --git a/tracer/src/Datadog.Trace/Ci/EventModel/SpanEvent.cs b/tracer/src/Datadog.Trace/Ci/EventModel/SpanEvent.cs new file mode 100644 index 000000000..7df57ec97 --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/EventModel/SpanEvent.cs @@ -0,0 +1,17 @@ +// +// 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. +// + +using System; + +namespace Datadog.Trace.Ci.EventModel +{ + internal class SpanEvent : CIVisibilityEvent + { + public SpanEvent(Span span) + : base("span", 1, span) + { + } + } +} diff --git a/tracer/src/Datadog.Trace/Ci/EventModel/TestEvent.cs b/tracer/src/Datadog.Trace/Ci/EventModel/TestEvent.cs new file mode 100644 index 000000000..65386990b --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/EventModel/TestEvent.cs @@ -0,0 +1,15 @@ +// +// 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. +// + +namespace Datadog.Trace.Ci.EventModel +{ + internal class TestEvent : CIVisibilityEvent + { + public TestEvent(Span span) + : base("test", 1, span) + { + } + } +} diff --git a/tracer/src/Datadog.Trace/Ci/IEvent.cs b/tracer/src/Datadog.Trace/Ci/IEvent.cs new file mode 100644 index 000000000..48560fb4d --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/IEvent.cs @@ -0,0 +1,11 @@ +// +// 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. +// + +namespace Datadog.Trace.Ci +{ + internal interface IEvent + { + } +} diff --git a/tracer/src/Datadog.Trace/Ci/Processors/OriginTagTraceProcessor.cs b/tracer/src/Datadog.Trace/Ci/Processors/OriginTagTraceProcessor.cs new file mode 100644 index 000000000..1cf00be7e --- /dev/null +++ b/tracer/src/Datadog.Trace/Ci/Processors/OriginTagTraceProcessor.cs @@ -0,0 +1,80 @@ +// +// 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. +// + +using System; +using Datadog.Trace.Ci.Tags; +using Datadog.Trace.Logging; +using Datadog.Trace.Processors; + +namespace Datadog.Trace.Ci.Processors +{ + internal class OriginTagTraceProcessor : ITraceProcessor + { + private static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(); + + private readonly bool _isPartialFlushEnabled = false; + private readonly bool _isAgentlessEnabled = false; + + public OriginTagTraceProcessor(bool isPartialFlushEnabled, bool isAgentlessEnabled) + { + _isPartialFlushEnabled = isPartialFlushEnabled; + _isAgentlessEnabled = isAgentlessEnabled; + + Log.Information("OriginTraceProcessor initialized."); + } + + public ArraySegment Process(ArraySegment trace) + { + // We ensure there's no trace (local root span) without a test tag. + // And ensure all other spans have the origin tag. + + // Check if the trace has any span + if (trace.Count == 0) + { + // No trace to write + return trace; + } + + if (!_isPartialFlushEnabled) + { + // Check if the root span is a test, benchmark or build span + for (var i = trace.Offset + trace.Count - 1; i >= trace.Offset; i--) + { + var span = trace.Array![i]; + if (span.Context.Parent is null && + span.Type != SpanTypes.Test && + span.Type != SpanTypes.Benchmark && + span.Type != SpanTypes.Build) + { + Log.Warning("Spans dropped because not having a test or benchmark root span: {Count}", trace.Count); + return default; + } + } + } + + if (!_isAgentlessEnabled) + { + for (var i = trace.Offset; i < trace.Count + trace.Offset; i++) + { + trace.Array[i] = Process(trace.Array[i]); + } + } + + return trace; + } + + public Span Process(Span span) + { + // Sets the origin tag to any other spans to ensure the CI track. + span.Context.Origin = TestTags.CIAppTestOriginName; + return span; + } + + public ITagProcessor GetTagProcessor() + { + return null; + } + } +} diff --git a/tracer/src/Datadog.Trace/Ci/Sampling/CISampler.cs b/tracer/src/Datadog.Trace/Ci/Sampling/CISampler.cs index 5608acd7f..181aaf59c 100644 --- a/tracer/src/Datadog.Trace/Ci/Sampling/CISampler.cs +++ b/tracer/src/Datadog.Trace/Ci/Sampling/CISampler.cs @@ -4,7 +4,6 @@ // using System.Collections.Generic; -using Datadog.Trace.Configuration; using Datadog.Trace.Sampling; namespace Datadog.Trace.Ci.Sampling diff --git a/tracer/src/Datadog.Trace/Ci/Tags/CommonTags.cs b/tracer/src/Datadog.Trace/Ci/Tags/CommonTags.cs index ad9c1698c..16074fde5 100644 --- a/tracer/src/Datadog.Trace/Ci/Tags/CommonTags.cs +++ b/tracer/src/Datadog.Trace/Ci/Tags/CommonTags.cs @@ -144,5 +144,10 @@ internal static class CommonTags /// Runtime version /// public const string RuntimeVersion = "runtime.version"; + + /// + /// Library Version + /// + public const string LibraryVersion = "library_version"; } } diff --git a/tracer/src/Datadog.Trace/Ci/Tags/TestTags.cs b/tracer/src/Datadog.Trace/Ci/Tags/TestTags.cs index 17ba0452b..815dfacdf 100644 --- a/tracer/src/Datadog.Trace/Ci/Tags/TestTags.cs +++ b/tracer/src/Datadog.Trace/Ci/Tags/TestTags.cs @@ -94,15 +94,5 @@ internal static class TestTags /// Origin value for CIApp Test /// public const string CIAppTestOriginName = "ciapp-test"; - - /// - /// Library Language - /// - public const string Language = "language"; - - /// - /// CI Visibility Library Version - /// - public const string CILibraryVersion = "ci_library.version"; } } diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/Testing/MsTestV2/MsTestIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/Testing/MsTestV2/MsTestIntegration.cs index 881aefed5..dcb070713 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/Testing/MsTestV2/MsTestIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/Testing/MsTestV2/MsTestIntegration.cs @@ -43,13 +43,13 @@ internal static Scope OnMethodBegin(TTestMethod testMethodInfo, Typ span.SetTraceSamplingPriority(SamplingPriorityValues.AutoKeep); span.ResourceName = $"{testSuite}.{testName}"; span.SetTag(Tags.Origin, TestTags.CIAppTestOriginName); + span.SetTag(Tags.Language, TracerConstants.Language); span.SetTag(TestTags.Suite, testSuite); span.SetTag(TestTags.Name, testName); span.SetTag(TestTags.Framework, testFramework); span.SetTag(TestTags.FrameworkVersion, type.Assembly?.GetName().Version.ToString()); span.SetTag(TestTags.Type, TestTags.TypeTest); - span.SetTag(TestTags.Language, TracerConstants.Language); - span.SetTag(TestTags.CILibraryVersion, TracerConstants.AssemblyVersion); + span.SetTag(CommonTags.LibraryVersion, TracerConstants.AssemblyVersion); CIEnvironmentValues.Instance.DecorateSpan(span); var framework = FrameworkDescription.Instance; diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/Testing/NUnit/NUnitIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/Testing/NUnit/NUnitIntegration.cs index e3cc2b776..46fe5da08 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/Testing/NUnit/NUnitIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/Testing/NUnit/NUnitIntegration.cs @@ -56,13 +56,13 @@ internal static Scope CreateScope(ITest currentTest, Type targetType) span.SetTraceSamplingPriority(SamplingPriorityValues.AutoKeep); span.ResourceName = $"{testSuite}.{testName}"; span.SetTag(Tags.Origin, TestTags.CIAppTestOriginName); + span.SetTag(Tags.Language, TracerConstants.Language); span.SetTag(TestTags.Suite, testSuite); span.SetTag(TestTags.Name, testName); span.SetTag(TestTags.Framework, testFramework); span.SetTag(TestTags.FrameworkVersion, targetType.Assembly?.GetName().Version.ToString()); span.SetTag(TestTags.Type, TestTags.TypeTest); - span.SetTag(TestTags.Language, TracerConstants.Language); - span.SetTag(TestTags.CILibraryVersion, TracerConstants.AssemblyVersion); + span.SetTag(CommonTags.LibraryVersion, TracerConstants.AssemblyVersion); CIEnvironmentValues.Instance.DecorateSpan(span); var framework = FrameworkDescription.Instance; diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/Testing/XUnit/XUnitIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/Testing/XUnit/XUnitIntegration.cs index 71605cb34..eac42bc9e 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/Testing/XUnit/XUnitIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/Testing/XUnit/XUnitIntegration.cs @@ -34,13 +34,13 @@ internal static Scope CreateScope(ref TestRunnerStruct runnerInstance, Type targ span.SetTraceSamplingPriority(SamplingPriorityValues.AutoKeep); span.ResourceName = $"{testSuite}.{testName}"; span.SetTag(Tags.Origin, TestTags.CIAppTestOriginName); + span.SetTag(Tags.Language, TracerConstants.Language); span.SetTag(TestTags.Suite, testSuite); span.SetTag(TestTags.Name, testName); span.SetTag(TestTags.Framework, testFramework); span.SetTag(TestTags.FrameworkVersion, targetType.Assembly?.GetName().Version.ToString()); span.SetTag(TestTags.Type, TestTags.TypeTest); - span.SetTag(TestTags.Language, TracerConstants.Language); - span.SetTag(TestTags.CILibraryVersion, TracerConstants.AssemblyVersion); + span.SetTag(CommonTags.LibraryVersion, TracerConstants.AssemblyVersion); CIEnvironmentValues.Instance.DecorateSpan(span); var framework = FrameworkDescription.Instance; diff --git a/tracer/src/Datadog.Trace/Configuration/ConfigurationKeys.cs b/tracer/src/Datadog.Trace/Configuration/ConfigurationKeys.cs index 6837a9b18..702d839dd 100644 --- a/tracer/src/Datadog.Trace/Configuration/ConfigurationKeys.cs +++ b/tracer/src/Datadog.Trace/Configuration/ConfigurationKeys.cs @@ -267,7 +267,6 @@ internal static partial class ConfigurationKeys /// /// Configuration key for setting the API key, used by the Agent. - /// This key is here for troubleshooting purposes. /// public const string ApiKey = "SIGNALFX_API_KEY"; @@ -354,12 +353,6 @@ internal static partial class ConfigurationKeys /// public const string RecordedValueMaxLength = "SIGNALFX_RECORDED_VALUE_MAX_LENGTH"; - /// - /// Configuration key for enabling or disabling CI Visibility. - /// Default is value is false (disabled). - /// - public const string CIVisibilityEnabled = "SIGNALFX_CIVISIBILITY_ENABLED"; - /// /// Configuration key for enabling or disabling the tagging of /// a Mongo command BsonDocument as db.statement. @@ -383,6 +376,41 @@ internal static partial class ConfigurationKeys /// public const string ExpandRouteTemplatesEnabled = "SIGNALFX_TRACE_EXPAND_ROUTE_TEMPLATES_ENABLED"; + /// + /// String constants for CI Visibility configuration keys. + /// + public static class CIVisibility + { + /// + /// Configuration key for enabling or disabling CI Visibility. + /// Default is value is false (disabled). + /// + public const string Enabled = "SIGNALFX_CIVISIBILITY_ENABLED"; + + /// + /// Configuration key for enabling or disabling Agentless in CI Visibility. + /// Default is value is false (disabled). + /// + public const string AgentlessEnabled = "SIGNALFX_CIVISIBILITY_AGENTLESS_ENABLED"; + } + + /// + /// String constants for proxy configuration keys. + /// + public static class Proxy + { + /// + /// Configuration key to set a proxy server for https requests. + /// + public const string ProxyHttps = "SIGNALFX_PROXY_HTTPS"; + + /// + /// Configuration key to set a list of hosts that should bypass the proxy. + /// The list is space-separated. + /// + public const string ProxyNoProxy = "SIGNALFX_PROXY_NO_PROXY"; + } + /// /// String format patterns used to match integration-specific configuration keys. /// diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AerospikeTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AerospikeTags.g.cs index 1071b1dc5..bbab3e479 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AerospikeTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AerospikeTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AerospikeTags @@ -66,52 +68,52 @@ public override void SetTag(string key, string value) return AerospikeTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (Key != null) { count++; - WriteTag(ref bytes, ref offset, KeyBytes, Key); + WriteTag(ref bytes, ref offset, KeyBytes, Key, tagProcessors); } if (Namespace != null) { count++; - WriteTag(ref bytes, ref offset, NamespaceBytes, Namespace); + WriteTag(ref bytes, ref offset, NamespaceBytes, Namespace, tagProcessors); } if (SetName != null) { count++; - WriteTag(ref bytes, ref offset, SetNameBytes, SetName); + WriteTag(ref bytes, ref offset, SetNameBytes, SetName, tagProcessors); } if (UserKey != null) { count++; - WriteTag(ref bytes, ref offset, UserKeyBytes, UserKey); + WriteTag(ref bytes, ref offset, UserKeyBytes, UserKey, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreEndpointTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreEndpointTags.g.cs index d9d6a2a60..61ec90ba6 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreEndpointTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreEndpointTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AspNetCoreEndpointTags @@ -39,16 +41,16 @@ public override void SetTag(string key, string value) return AspNetCoreEndpointTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (AspNetCoreEndpoint != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCoreEndpointBytes, AspNetCoreEndpoint); + WriteTag(ref bytes, ref offset, AspNetCoreEndpointBytes, AspNetCoreEndpoint, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreMvcTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreMvcTags.g.cs index 636f92131..afc9db842 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreMvcTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreMvcTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AspNetCoreMvcTags @@ -57,34 +59,34 @@ public override void SetTag(string key, string value) return AspNetCoreMvcTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (AspNetCoreController != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCoreControllerBytes, AspNetCoreController); + WriteTag(ref bytes, ref offset, AspNetCoreControllerBytes, AspNetCoreController, tagProcessors); } if (AspNetCoreAction != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCoreActionBytes, AspNetCoreAction); + WriteTag(ref bytes, ref offset, AspNetCoreActionBytes, AspNetCoreAction, tagProcessors); } if (AspNetCoreArea != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCoreAreaBytes, AspNetCoreArea); + WriteTag(ref bytes, ref offset, AspNetCoreAreaBytes, AspNetCoreArea, tagProcessors); } if (AspNetCorePage != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCorePageBytes, AspNetCorePage); + WriteTag(ref bytes, ref offset, AspNetCorePageBytes, AspNetCorePage, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreTags.g.cs index 85f259d15..7076cd3db 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AspNetCoreTags @@ -42,22 +44,22 @@ public override void SetTag(string key, string value) return AspNetCoreTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (AspNetCoreRoute != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCoreRouteBytes, AspNetCoreRoute); + WriteTag(ref bytes, ref offset, AspNetCoreRouteBytes, AspNetCoreRoute, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetTags.g.cs index ce5fc25e5..582b937ec 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AspNetTags @@ -57,34 +59,34 @@ public override void SetTag(string key, string value) return AspNetTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (AspNetRoute != null) { count++; - WriteTag(ref bytes, ref offset, AspNetRouteBytes, AspNetRoute); + WriteTag(ref bytes, ref offset, AspNetRouteBytes, AspNetRoute, tagProcessors); } if (AspNetController != null) { count++; - WriteTag(ref bytes, ref offset, AspNetControllerBytes, AspNetController); + WriteTag(ref bytes, ref offset, AspNetControllerBytes, AspNetController, tagProcessors); } if (AspNetAction != null) { count++; - WriteTag(ref bytes, ref offset, AspNetActionBytes, AspNetAction); + WriteTag(ref bytes, ref offset, AspNetActionBytes, AspNetAction, tagProcessors); } if (AspNetArea != null) { count++; - WriteTag(ref bytes, ref offset, AspNetAreaBytes, AspNetArea); + WriteTag(ref bytes, ref offset, AspNetAreaBytes, AspNetArea, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSdkTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSdkTags.g.cs index 8e412854a..b05fb4c59 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSdkTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSdkTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AwsSdkTags @@ -81,64 +83,64 @@ public override void SetTag(string key, string value) return AwsSdkTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (AgentName != null) { count++; - WriteTag(ref bytes, ref offset, AgentNameBytes, AgentName); + WriteTag(ref bytes, ref offset, AgentNameBytes, AgentName, tagProcessors); } if (Operation != null) { count++; - WriteTag(ref bytes, ref offset, OperationBytes, Operation); + WriteTag(ref bytes, ref offset, OperationBytes, Operation, tagProcessors); } if (Region != null) { count++; - WriteTag(ref bytes, ref offset, RegionBytes, Region); + WriteTag(ref bytes, ref offset, RegionBytes, Region, tagProcessors); } if (RequestId != null) { count++; - WriteTag(ref bytes, ref offset, RequestIdBytes, RequestId); + WriteTag(ref bytes, ref offset, RequestIdBytes, RequestId, tagProcessors); } if (Service != null) { count++; - WriteTag(ref bytes, ref offset, ServiceBytes, Service); + WriteTag(ref bytes, ref offset, ServiceBytes, Service, tagProcessors); } if (HttpMethod != null) { count++; - WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod); + WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod, tagProcessors); } if (HttpUrl != null) { count++; - WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl); + WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl, tagProcessors); } if (HttpStatusCode != null) { count++; - WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode); + WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSqsTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSqsTags.g.cs index 94743603b..728869a20 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSqsTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSqsTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AwsSqsTags @@ -48,28 +50,28 @@ public override void SetTag(string key, string value) return AwsSqsTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (QueueName != null) { count++; - WriteTag(ref bytes, ref offset, QueueNameBytes, QueueName); + WriteTag(ref bytes, ref offset, QueueNameBytes, QueueName, tagProcessors); } if (QueueUrl != null) { count++; - WriteTag(ref bytes, ref offset, QueueUrlBytes, QueueUrl); + WriteTag(ref bytes, ref offset, QueueUrlBytes, QueueUrl, tagProcessors); } if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AzureFunctionsTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AzureFunctionsTags.g.cs index 07480f05a..e3d7bd6ff 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AzureFunctionsTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AzureFunctionsTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AzureFunctionsTags @@ -66,52 +68,52 @@ public override void SetTag(string key, string value) return AzureFunctionsTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (Language != null) { count++; - WriteTag(ref bytes, ref offset, LanguageBytes, Language); + WriteTag(ref bytes, ref offset, LanguageBytes, Language, tagProcessors); } if (ShortName != null) { count++; - WriteTag(ref bytes, ref offset, ShortNameBytes, ShortName); + WriteTag(ref bytes, ref offset, ShortNameBytes, ShortName, tagProcessors); } if (FullName != null) { count++; - WriteTag(ref bytes, ref offset, FullNameBytes, FullName); + WriteTag(ref bytes, ref offset, FullNameBytes, FullName, tagProcessors); } if (BindingSource != null) { count++; - WriteTag(ref bytes, ref offset, BindingSourceBytes, BindingSource); + WriteTag(ref bytes, ref offset, BindingSourceBytes, BindingSource, tagProcessors); } if (TriggerType != null) { count++; - WriteTag(ref bytes, ref offset, TriggerTypeBytes, TriggerType); + WriteTag(ref bytes, ref offset, TriggerTypeBytes, TriggerType, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CommonTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CommonTags.g.cs index aa1637073..24d2e7fe0 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CommonTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CommonTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class CommonTags @@ -60,34 +62,34 @@ public override void SetTag(string key, string value) return CommonTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (Environment != null) { count++; - WriteTag(ref bytes, ref offset, EnvironmentBytes, Environment); + WriteTag(ref bytes, ref offset, EnvironmentBytes, Environment, tagProcessors); } if (Version != null) { count++; - WriteTag(ref bytes, ref offset, VersionBytes, Version); + WriteTag(ref bytes, ref offset, VersionBytes, Version, tagProcessors); } if (SignalFxVersion != null) { count++; - WriteTag(ref bytes, ref offset, SignalFxVersionBytes, SignalFxVersion); + WriteTag(ref bytes, ref offset, SignalFxVersionBytes, SignalFxVersion, tagProcessors); } if (SignalFxLibrary != null) { count++; - WriteTag(ref bytes, ref offset, SignalFxLibraryBytes, SignalFxLibrary); + WriteTag(ref bytes, ref offset, SignalFxLibraryBytes, SignalFxLibrary, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) @@ -152,28 +154,28 @@ public override void SetMetric(string key, double? value) } } - protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SamplingPriority != null) { count++; - WriteMetric(ref bytes, ref offset, SamplingPriorityBytes, SamplingPriority.Value); + WriteMetric(ref bytes, ref offset, SamplingPriorityBytes, SamplingPriority.Value, tagProcessors); } if (SamplingLimitDecision != null) { count++; - WriteMetric(ref bytes, ref offset, SamplingLimitDecisionBytes, SamplingLimitDecision.Value); + WriteMetric(ref bytes, ref offset, SamplingLimitDecisionBytes, SamplingLimitDecision.Value, tagProcessors); } if (TracesKeepRate != null) { count++; - WriteMetric(ref bytes, ref offset, TracesKeepRateBytes, TracesKeepRate.Value); + WriteMetric(ref bytes, ref offset, TracesKeepRateBytes, TracesKeepRate.Value, tagProcessors); } - return count + base.WriteAdditionalMetrics(ref bytes, ref offset); + return count + base.WriteAdditionalMetrics(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalMetrics(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CosmosDbTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CosmosDbTags.g.cs index 26836aa2a..95a52c81d 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CosmosDbTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CosmosDbTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class CosmosDbTags @@ -63,46 +65,46 @@ public override void SetTag(string key, string value) return CosmosDbTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (ContainerId != null) { count++; - WriteTag(ref bytes, ref offset, ContainerIdBytes, ContainerId); + WriteTag(ref bytes, ref offset, ContainerIdBytes, ContainerId, tagProcessors); } if (DatabaseId != null) { count++; - WriteTag(ref bytes, ref offset, DatabaseIdBytes, DatabaseId); + WriteTag(ref bytes, ref offset, DatabaseIdBytes, DatabaseId, tagProcessors); } if (Host != null) { count++; - WriteTag(ref bytes, ref offset, HostBytes, Host); + WriteTag(ref bytes, ref offset, HostBytes, Host, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CouchbaseTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CouchbaseTags.g.cs index 1eb9f215b..e2a314697 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CouchbaseTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CouchbaseTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class CouchbaseTags @@ -69,52 +71,52 @@ public override void SetTag(string key, string value) return CouchbaseTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (OperationCode != null) { count++; - WriteTag(ref bytes, ref offset, OperationCodeBytes, OperationCode); + WriteTag(ref bytes, ref offset, OperationCodeBytes, OperationCode, tagProcessors); } if (Bucket != null) { count++; - WriteTag(ref bytes, ref offset, BucketBytes, Bucket); + WriteTag(ref bytes, ref offset, BucketBytes, Bucket, tagProcessors); } if (Key != null) { count++; - WriteTag(ref bytes, ref offset, KeyBytes, Key); + WriteTag(ref bytes, ref offset, KeyBytes, Key, tagProcessors); } if (Host != null) { count++; - WriteTag(ref bytes, ref offset, HostBytes, Host); + WriteTag(ref bytes, ref offset, HostBytes, Host, tagProcessors); } if (Port != null) { count++; - WriteTag(ref bytes, ref offset, PortBytes, Port); + WriteTag(ref bytes, ref offset, PortBytes, Port, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ElasticsearchTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ElasticsearchTags.g.cs index 7a49904f3..bf41a1978 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ElasticsearchTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ElasticsearchTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Elasticsearch { partial class ElasticsearchTags @@ -66,52 +68,52 @@ public override void SetTag(string key, string value) return ElasticsearchTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (Action != null) { count++; - WriteTag(ref bytes, ref offset, ActionBytes, Action); + WriteTag(ref bytes, ref offset, ActionBytes, Action, tagProcessors); } if (Method != null) { count++; - WriteTag(ref bytes, ref offset, MethodBytes, Method); + WriteTag(ref bytes, ref offset, MethodBytes, Method, tagProcessors); } if (Url != null) { count++; - WriteTag(ref bytes, ref offset, UrlBytes, Url); + WriteTag(ref bytes, ref offset, UrlBytes, Url, tagProcessors); } if (DbStatement != null) { count++; - WriteTag(ref bytes, ref offset, DbStatementBytes, DbStatement); + WriteTag(ref bytes, ref offset, DbStatementBytes, DbStatement, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/GraphQLTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/GraphQLTags.g.cs index 2bba67761..6557d1aa3 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/GraphQLTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/GraphQLTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL { partial class GraphQLTags @@ -60,46 +62,46 @@ public override void SetTag(string key, string value) return GraphQLTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (Language != null) { count++; - WriteTag(ref bytes, ref offset, LanguageBytes, Language); + WriteTag(ref bytes, ref offset, LanguageBytes, Language, tagProcessors); } if (Source != null) { count++; - WriteTag(ref bytes, ref offset, SourceBytes, Source); + WriteTag(ref bytes, ref offset, SourceBytes, Source, tagProcessors); } if (OperationName != null) { count++; - WriteTag(ref bytes, ref offset, OperationNameBytes, OperationName); + WriteTag(ref bytes, ref offset, OperationNameBytes, OperationName, tagProcessors); } if (OperationType != null) { count++; - WriteTag(ref bytes, ref offset, OperationTypeBytes, OperationType); + WriteTag(ref bytes, ref offset, OperationTypeBytes, OperationType, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/HttpTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/HttpTags.g.cs index 005e107d3..65dff3342 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/HttpTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/HttpTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class HttpTags @@ -66,46 +68,46 @@ public override void SetTag(string key, string value) return HttpTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (HttpMethod != null) { count++; - WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod); + WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod, tagProcessors); } if (HttpUrl != null) { count++; - WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl); + WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl, tagProcessors); } if (HttpClientHandlerType != null) { count++; - WriteTag(ref bytes, ref offset, HttpClientHandlerTypeBytes, HttpClientHandlerType); + WriteTag(ref bytes, ref offset, HttpClientHandlerTypeBytes, HttpClientHandlerType, tagProcessors); } if (HttpStatusCode != null) { count++; - WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode); + WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/InstrumentationTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/InstrumentationTags.g.cs index 4738878d8..6a1dc04ba 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/InstrumentationTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/InstrumentationTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class InstrumentationTags @@ -36,16 +38,16 @@ public override void SetMetric(string key, double? value) } } - protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (AnalyticsSampleRate != null) { count++; - WriteMetric(ref bytes, ref offset, AnalyticsSampleRateBytes, AnalyticsSampleRate.Value); + WriteMetric(ref bytes, ref offset, AnalyticsSampleRateBytes, AnalyticsSampleRate.Value, tagProcessors); } - return count + base.WriteAdditionalMetrics(ref bytes, ref offset); + return count + base.WriteAdditionalMetrics(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalMetrics(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/KafkaTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/KafkaTags.g.cs index 6683497d7..0f1ce8f0e 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/KafkaTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/KafkaTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class KafkaTags @@ -58,40 +60,40 @@ public override void SetTag(string key, string value) return KafkaTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (Partition != null) { count++; - WriteTag(ref bytes, ref offset, PartitionBytes, Partition); + WriteTag(ref bytes, ref offset, PartitionBytes, Partition, tagProcessors); } if (Offset != null) { count++; - WriteTag(ref bytes, ref offset, OffsetBytes, Offset); + WriteTag(ref bytes, ref offset, OffsetBytes, Offset, tagProcessors); } if (Tombstone != null) { count++; - WriteTag(ref bytes, ref offset, TombstoneBytes, Tombstone); + WriteTag(ref bytes, ref offset, TombstoneBytes, Tombstone, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) @@ -155,16 +157,16 @@ public override void SetMetric(string key, double? value) } } - protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (MessageQueueTimeMs != null) { count++; - WriteMetric(ref bytes, ref offset, MessageQueueTimeMsBytes, MessageQueueTimeMs.Value); + WriteMetric(ref bytes, ref offset, MessageQueueTimeMsBytes, MessageQueueTimeMs.Value, tagProcessors); } - return count + base.WriteAdditionalMetrics(ref bytes, ref offset); + return count + base.WriteAdditionalMetrics(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalMetrics(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MessagingTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MessagingTags.g.cs index b8c8ed475..fc81e87b6 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MessagingTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MessagingTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class MessagingTags @@ -111,88 +113,88 @@ public override void SetTag(string key, string value) return MessagingTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (System != null) { count++; - WriteTag(ref bytes, ref offset, SystemBytes, System); + WriteTag(ref bytes, ref offset, SystemBytes, System, tagProcessors); } if (Destination != null) { count++; - WriteTag(ref bytes, ref offset, DestinationBytes, Destination); + WriteTag(ref bytes, ref offset, DestinationBytes, Destination, tagProcessors); } if (DestinationKind != null) { count++; - WriteTag(ref bytes, ref offset, DestinationKindBytes, DestinationKind); + WriteTag(ref bytes, ref offset, DestinationKindBytes, DestinationKind, tagProcessors); } if (TempDestination != null) { count++; - WriteTag(ref bytes, ref offset, TempDestinationBytes, TempDestination); + WriteTag(ref bytes, ref offset, TempDestinationBytes, TempDestination, tagProcessors); } if (Protocol != null) { count++; - WriteTag(ref bytes, ref offset, ProtocolBytes, Protocol); + WriteTag(ref bytes, ref offset, ProtocolBytes, Protocol, tagProcessors); } if (ProtocolVersion != null) { count++; - WriteTag(ref bytes, ref offset, ProtocolVersionBytes, ProtocolVersion); + WriteTag(ref bytes, ref offset, ProtocolVersionBytes, ProtocolVersion, tagProcessors); } if (Url != null) { count++; - WriteTag(ref bytes, ref offset, UrlBytes, Url); + WriteTag(ref bytes, ref offset, UrlBytes, Url, tagProcessors); } if (Operation != null) { count++; - WriteTag(ref bytes, ref offset, OperationBytes, Operation); + WriteTag(ref bytes, ref offset, OperationBytes, Operation, tagProcessors); } if (MessageId != null) { count++; - WriteTag(ref bytes, ref offset, MessageIdBytes, MessageId); + WriteTag(ref bytes, ref offset, MessageIdBytes, MessageId, tagProcessors); } if (ConversationId != null) { count++; - WriteTag(ref bytes, ref offset, ConversationIdBytes, ConversationId); + WriteTag(ref bytes, ref offset, ConversationIdBytes, ConversationId, tagProcessors); } if (ConsumerId != null) { count++; - WriteTag(ref bytes, ref offset, ConsumerIdBytes, ConsumerId); + WriteTag(ref bytes, ref offset, ConsumerIdBytes, ConsumerId, tagProcessors); } if (MessageSize != null) { count++; - WriteTag(ref bytes, ref offset, MessageSizeBytes, MessageSize); + WriteTag(ref bytes, ref offset, MessageSizeBytes, MessageSize, tagProcessors); } if (MessageSizeCompressed != null) { count++; - WriteTag(ref bytes, ref offset, MessageSizeCompressedBytes, MessageSizeCompressed); + WriteTag(ref bytes, ref offset, MessageSizeCompressedBytes, MessageSizeCompressed, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MongoDbTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MongoDbTags.g.cs index b89fa38f2..2ccee59fa 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MongoDbTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MongoDbTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb { partial class MongoDbTags @@ -81,64 +83,64 @@ public override void SetTag(string key, string value) return MongoDbTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (DbStatement != null) { count++; - WriteTag(ref bytes, ref offset, DbStatementBytes, DbStatement); + WriteTag(ref bytes, ref offset, DbStatementBytes, DbStatement, tagProcessors); } if (DbName != null) { count++; - WriteTag(ref bytes, ref offset, DbNameBytes, DbName); + WriteTag(ref bytes, ref offset, DbNameBytes, DbName, tagProcessors); } if (Query != null) { count++; - WriteTag(ref bytes, ref offset, QueryBytes, Query); + WriteTag(ref bytes, ref offset, QueryBytes, Query, tagProcessors); } if (Collection != null) { count++; - WriteTag(ref bytes, ref offset, CollectionBytes, Collection); + WriteTag(ref bytes, ref offset, CollectionBytes, Collection, tagProcessors); } if (Host != null) { count++; - WriteTag(ref bytes, ref offset, HostBytes, Host); + WriteTag(ref bytes, ref offset, HostBytes, Host, tagProcessors); } if (Port != null) { count++; - WriteTag(ref bytes, ref offset, PortBytes, Port); + WriteTag(ref bytes, ref offset, PortBytes, Port, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MsmqTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MsmqTags.g.cs index 481737cd7..c0bc0f2c4 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MsmqTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MsmqTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class MsmqTags @@ -63,46 +65,46 @@ public override void SetTag(string key, string value) return MsmqTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (Command != null) { count++; - WriteTag(ref bytes, ref offset, CommandBytes, Command); + WriteTag(ref bytes, ref offset, CommandBytes, Command, tagProcessors); } if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (Path != null) { count++; - WriteTag(ref bytes, ref offset, PathBytes, Path); + WriteTag(ref bytes, ref offset, PathBytes, Path, tagProcessors); } if (MessageWithTransaction != null) { count++; - WriteTag(ref bytes, ref offset, MessageWithTransactionBytes, MessageWithTransaction); + WriteTag(ref bytes, ref offset, MessageWithTransactionBytes, MessageWithTransaction, tagProcessors); } if (IsTransactionalQueue != null) { count++; - WriteTag(ref bytes, ref offset, IsTransactionalQueueBytes, IsTransactionalQueue); + WriteTag(ref bytes, ref offset, IsTransactionalQueueBytes, IsTransactionalQueue, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RabbitMQTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RabbitMQTags.g.cs index 4a48393bc..340993c79 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RabbitMQTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RabbitMQTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class RabbitMQTags @@ -72,52 +74,52 @@ public override void SetTag(string key, string value) return RabbitMQTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (Command != null) { count++; - WriteTag(ref bytes, ref offset, CommandBytes, Command); + WriteTag(ref bytes, ref offset, CommandBytes, Command, tagProcessors); } if (DeliveryMode != null) { count++; - WriteTag(ref bytes, ref offset, DeliveryModeBytes, DeliveryMode); + WriteTag(ref bytes, ref offset, DeliveryModeBytes, DeliveryMode, tagProcessors); } if (Exchange != null) { count++; - WriteTag(ref bytes, ref offset, ExchangeBytes, Exchange); + WriteTag(ref bytes, ref offset, ExchangeBytes, Exchange, tagProcessors); } if (RoutingKey != null) { count++; - WriteTag(ref bytes, ref offset, RoutingKeyBytes, RoutingKey); + WriteTag(ref bytes, ref offset, RoutingKeyBytes, RoutingKey, tagProcessors); } if (Queue != null) { count++; - WriteTag(ref bytes, ref offset, QueueBytes, Queue); + WriteTag(ref bytes, ref offset, QueueBytes, Queue, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RedisTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RedisTags.g.cs index 770c27698..838714c68 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RedisTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RedisTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis { partial class RedisTags @@ -60,46 +62,46 @@ public override void SetTag(string key, string value) return RedisTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (RawCommand != null) { count++; - WriteTag(ref bytes, ref offset, RawCommandBytes, RawCommand); + WriteTag(ref bytes, ref offset, RawCommandBytes, RawCommand, tagProcessors); } if (Host != null) { count++; - WriteTag(ref bytes, ref offset, HostBytes, Host); + WriteTag(ref bytes, ref offset, HostBytes, Host, tagProcessors); } if (Port != null) { count++; - WriteTag(ref bytes, ref offset, PortBytes, Port); + WriteTag(ref bytes, ref offset, PortBytes, Port, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ServiceRemotingTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ServiceRemotingTags.g.cs index 42f86150e..27dc383f5 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ServiceRemotingTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ServiceRemotingTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.ServiceFabric { partial class ServiceRemotingTags @@ -102,82 +104,82 @@ public override void SetTag(string key, string value) return ServiceRemotingTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (ApplicationId != null) { count++; - WriteTag(ref bytes, ref offset, ApplicationIdBytes, ApplicationId); + WriteTag(ref bytes, ref offset, ApplicationIdBytes, ApplicationId, tagProcessors); } if (ApplicationName != null) { count++; - WriteTag(ref bytes, ref offset, ApplicationNameBytes, ApplicationName); + WriteTag(ref bytes, ref offset, ApplicationNameBytes, ApplicationName, tagProcessors); } if (PartitionId != null) { count++; - WriteTag(ref bytes, ref offset, PartitionIdBytes, PartitionId); + WriteTag(ref bytes, ref offset, PartitionIdBytes, PartitionId, tagProcessors); } if (NodeId != null) { count++; - WriteTag(ref bytes, ref offset, NodeIdBytes, NodeId); + WriteTag(ref bytes, ref offset, NodeIdBytes, NodeId, tagProcessors); } if (NodeName != null) { count++; - WriteTag(ref bytes, ref offset, NodeNameBytes, NodeName); + WriteTag(ref bytes, ref offset, NodeNameBytes, NodeName, tagProcessors); } if (ServiceName != null) { count++; - WriteTag(ref bytes, ref offset, ServiceNameBytes, ServiceName); + WriteTag(ref bytes, ref offset, ServiceNameBytes, ServiceName, tagProcessors); } if (RemotingUri != null) { count++; - WriteTag(ref bytes, ref offset, RemotingUriBytes, RemotingUri); + WriteTag(ref bytes, ref offset, RemotingUriBytes, RemotingUri, tagProcessors); } if (RemotingMethodName != null) { count++; - WriteTag(ref bytes, ref offset, RemotingMethodNameBytes, RemotingMethodName); + WriteTag(ref bytes, ref offset, RemotingMethodNameBytes, RemotingMethodName, tagProcessors); } if (RemotingMethodId != null) { count++; - WriteTag(ref bytes, ref offset, RemotingMethodIdBytes, RemotingMethodId); + WriteTag(ref bytes, ref offset, RemotingMethodIdBytes, RemotingMethodId, tagProcessors); } if (RemotingInterfaceId != null) { count++; - WriteTag(ref bytes, ref offset, RemotingInterfaceIdBytes, RemotingInterfaceId); + WriteTag(ref bytes, ref offset, RemotingInterfaceIdBytes, RemotingInterfaceId, tagProcessors); } if (RemotingInvocationId != null) { count++; - WriteTag(ref bytes, ref offset, RemotingInvocationIdBytes, RemotingInvocationId); + WriteTag(ref bytes, ref offset, RemotingInvocationIdBytes, RemotingInvocationId, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/SqlTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/SqlTags.g.cs index 89436fa58..a99d61b2d 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/SqlTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/SqlTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class SqlTags @@ -66,46 +68,46 @@ public override void SetTag(string key, string value) return SqlTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbName != null) { count++; - WriteTag(ref bytes, ref offset, DbNameBytes, DbName); + WriteTag(ref bytes, ref offset, DbNameBytes, DbName, tagProcessors); } if (DbUser != null) { count++; - WriteTag(ref bytes, ref offset, DbUserBytes, DbUser); + WriteTag(ref bytes, ref offset, DbUserBytes, DbUser, tagProcessors); } if (OutHost != null) { count++; - WriteTag(ref bytes, ref offset, OutHostBytes, OutHost); + WriteTag(ref bytes, ref offset, OutHostBytes, OutHost, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WcfTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WcfTags.g.cs index 9ebcc0078..a11ae9af4 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WcfTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WcfTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class WcfTags @@ -36,16 +38,16 @@ public override void SetTag(string key, string value) return WcfTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WebTags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WebTags.g.cs index 4230e6d0f..d87697b06 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WebTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WebTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class WebTags @@ -69,52 +71,52 @@ public override void SetTag(string key, string value) return WebTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (HttpMethod != null) { count++; - WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod); + WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod, tagProcessors); } if (HttpRequestHeadersHost != null) { count++; - WriteTag(ref bytes, ref offset, HttpRequestHeadersHostBytes, HttpRequestHeadersHost); + WriteTag(ref bytes, ref offset, HttpRequestHeadersHostBytes, HttpRequestHeadersHost, tagProcessors); } if (HttpUrl != null) { count++; - WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl); + WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl, tagProcessors); } if (PeerIp != null) { count++; - WriteTag(ref bytes, ref offset, PeerIpBytes, PeerIp); + WriteTag(ref bytes, ref offset, PeerIpBytes, PeerIp, tagProcessors); } if (Language != null) { count++; - WriteTag(ref bytes, ref offset, LanguageBytes, Language); + WriteTag(ref bytes, ref offset, LanguageBytes, Language, tagProcessors); } if (HttpStatusCode != null) { count++; - WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode); + WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AerospikeTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AerospikeTags.g.cs index 1071b1dc5..bbab3e479 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AerospikeTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AerospikeTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AerospikeTags @@ -66,52 +68,52 @@ public override void SetTag(string key, string value) return AerospikeTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (Key != null) { count++; - WriteTag(ref bytes, ref offset, KeyBytes, Key); + WriteTag(ref bytes, ref offset, KeyBytes, Key, tagProcessors); } if (Namespace != null) { count++; - WriteTag(ref bytes, ref offset, NamespaceBytes, Namespace); + WriteTag(ref bytes, ref offset, NamespaceBytes, Namespace, tagProcessors); } if (SetName != null) { count++; - WriteTag(ref bytes, ref offset, SetNameBytes, SetName); + WriteTag(ref bytes, ref offset, SetNameBytes, SetName, tagProcessors); } if (UserKey != null) { count++; - WriteTag(ref bytes, ref offset, UserKeyBytes, UserKey); + WriteTag(ref bytes, ref offset, UserKeyBytes, UserKey, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreEndpointTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreEndpointTags.g.cs index d9d6a2a60..61ec90ba6 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreEndpointTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreEndpointTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AspNetCoreEndpointTags @@ -39,16 +41,16 @@ public override void SetTag(string key, string value) return AspNetCoreEndpointTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (AspNetCoreEndpoint != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCoreEndpointBytes, AspNetCoreEndpoint); + WriteTag(ref bytes, ref offset, AspNetCoreEndpointBytes, AspNetCoreEndpoint, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreMvcTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreMvcTags.g.cs index 636f92131..afc9db842 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreMvcTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreMvcTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AspNetCoreMvcTags @@ -57,34 +59,34 @@ public override void SetTag(string key, string value) return AspNetCoreMvcTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (AspNetCoreController != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCoreControllerBytes, AspNetCoreController); + WriteTag(ref bytes, ref offset, AspNetCoreControllerBytes, AspNetCoreController, tagProcessors); } if (AspNetCoreAction != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCoreActionBytes, AspNetCoreAction); + WriteTag(ref bytes, ref offset, AspNetCoreActionBytes, AspNetCoreAction, tagProcessors); } if (AspNetCoreArea != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCoreAreaBytes, AspNetCoreArea); + WriteTag(ref bytes, ref offset, AspNetCoreAreaBytes, AspNetCoreArea, tagProcessors); } if (AspNetCorePage != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCorePageBytes, AspNetCorePage); + WriteTag(ref bytes, ref offset, AspNetCorePageBytes, AspNetCorePage, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreTags.g.cs index 85f259d15..7076cd3db 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AspNetCoreTags @@ -42,22 +44,22 @@ public override void SetTag(string key, string value) return AspNetCoreTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (AspNetCoreRoute != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCoreRouteBytes, AspNetCoreRoute); + WriteTag(ref bytes, ref offset, AspNetCoreRouteBytes, AspNetCoreRoute, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetTags.g.cs index ce5fc25e5..582b937ec 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AspNetTags @@ -57,34 +59,34 @@ public override void SetTag(string key, string value) return AspNetTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (AspNetRoute != null) { count++; - WriteTag(ref bytes, ref offset, AspNetRouteBytes, AspNetRoute); + WriteTag(ref bytes, ref offset, AspNetRouteBytes, AspNetRoute, tagProcessors); } if (AspNetController != null) { count++; - WriteTag(ref bytes, ref offset, AspNetControllerBytes, AspNetController); + WriteTag(ref bytes, ref offset, AspNetControllerBytes, AspNetController, tagProcessors); } if (AspNetAction != null) { count++; - WriteTag(ref bytes, ref offset, AspNetActionBytes, AspNetAction); + WriteTag(ref bytes, ref offset, AspNetActionBytes, AspNetAction, tagProcessors); } if (AspNetArea != null) { count++; - WriteTag(ref bytes, ref offset, AspNetAreaBytes, AspNetArea); + WriteTag(ref bytes, ref offset, AspNetAreaBytes, AspNetArea, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSdkTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSdkTags.g.cs index 8e412854a..b05fb4c59 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSdkTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSdkTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AwsSdkTags @@ -81,64 +83,64 @@ public override void SetTag(string key, string value) return AwsSdkTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (AgentName != null) { count++; - WriteTag(ref bytes, ref offset, AgentNameBytes, AgentName); + WriteTag(ref bytes, ref offset, AgentNameBytes, AgentName, tagProcessors); } if (Operation != null) { count++; - WriteTag(ref bytes, ref offset, OperationBytes, Operation); + WriteTag(ref bytes, ref offset, OperationBytes, Operation, tagProcessors); } if (Region != null) { count++; - WriteTag(ref bytes, ref offset, RegionBytes, Region); + WriteTag(ref bytes, ref offset, RegionBytes, Region, tagProcessors); } if (RequestId != null) { count++; - WriteTag(ref bytes, ref offset, RequestIdBytes, RequestId); + WriteTag(ref bytes, ref offset, RequestIdBytes, RequestId, tagProcessors); } if (Service != null) { count++; - WriteTag(ref bytes, ref offset, ServiceBytes, Service); + WriteTag(ref bytes, ref offset, ServiceBytes, Service, tagProcessors); } if (HttpMethod != null) { count++; - WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod); + WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod, tagProcessors); } if (HttpUrl != null) { count++; - WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl); + WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl, tagProcessors); } if (HttpStatusCode != null) { count++; - WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode); + WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSqsTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSqsTags.g.cs index 94743603b..728869a20 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSqsTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSqsTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AwsSqsTags @@ -48,28 +50,28 @@ public override void SetTag(string key, string value) return AwsSqsTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (QueueName != null) { count++; - WriteTag(ref bytes, ref offset, QueueNameBytes, QueueName); + WriteTag(ref bytes, ref offset, QueueNameBytes, QueueName, tagProcessors); } if (QueueUrl != null) { count++; - WriteTag(ref bytes, ref offset, QueueUrlBytes, QueueUrl); + WriteTag(ref bytes, ref offset, QueueUrlBytes, QueueUrl, tagProcessors); } if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AzureFunctionsTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AzureFunctionsTags.g.cs index 07480f05a..e3d7bd6ff 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AzureFunctionsTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AzureFunctionsTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AzureFunctionsTags @@ -66,52 +68,52 @@ public override void SetTag(string key, string value) return AzureFunctionsTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (Language != null) { count++; - WriteTag(ref bytes, ref offset, LanguageBytes, Language); + WriteTag(ref bytes, ref offset, LanguageBytes, Language, tagProcessors); } if (ShortName != null) { count++; - WriteTag(ref bytes, ref offset, ShortNameBytes, ShortName); + WriteTag(ref bytes, ref offset, ShortNameBytes, ShortName, tagProcessors); } if (FullName != null) { count++; - WriteTag(ref bytes, ref offset, FullNameBytes, FullName); + WriteTag(ref bytes, ref offset, FullNameBytes, FullName, tagProcessors); } if (BindingSource != null) { count++; - WriteTag(ref bytes, ref offset, BindingSourceBytes, BindingSource); + WriteTag(ref bytes, ref offset, BindingSourceBytes, BindingSource, tagProcessors); } if (TriggerType != null) { count++; - WriteTag(ref bytes, ref offset, TriggerTypeBytes, TriggerType); + WriteTag(ref bytes, ref offset, TriggerTypeBytes, TriggerType, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CommonTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CommonTags.g.cs index aa1637073..24d2e7fe0 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CommonTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CommonTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class CommonTags @@ -60,34 +62,34 @@ public override void SetTag(string key, string value) return CommonTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (Environment != null) { count++; - WriteTag(ref bytes, ref offset, EnvironmentBytes, Environment); + WriteTag(ref bytes, ref offset, EnvironmentBytes, Environment, tagProcessors); } if (Version != null) { count++; - WriteTag(ref bytes, ref offset, VersionBytes, Version); + WriteTag(ref bytes, ref offset, VersionBytes, Version, tagProcessors); } if (SignalFxVersion != null) { count++; - WriteTag(ref bytes, ref offset, SignalFxVersionBytes, SignalFxVersion); + WriteTag(ref bytes, ref offset, SignalFxVersionBytes, SignalFxVersion, tagProcessors); } if (SignalFxLibrary != null) { count++; - WriteTag(ref bytes, ref offset, SignalFxLibraryBytes, SignalFxLibrary); + WriteTag(ref bytes, ref offset, SignalFxLibraryBytes, SignalFxLibrary, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) @@ -152,28 +154,28 @@ public override void SetMetric(string key, double? value) } } - protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SamplingPriority != null) { count++; - WriteMetric(ref bytes, ref offset, SamplingPriorityBytes, SamplingPriority.Value); + WriteMetric(ref bytes, ref offset, SamplingPriorityBytes, SamplingPriority.Value, tagProcessors); } if (SamplingLimitDecision != null) { count++; - WriteMetric(ref bytes, ref offset, SamplingLimitDecisionBytes, SamplingLimitDecision.Value); + WriteMetric(ref bytes, ref offset, SamplingLimitDecisionBytes, SamplingLimitDecision.Value, tagProcessors); } if (TracesKeepRate != null) { count++; - WriteMetric(ref bytes, ref offset, TracesKeepRateBytes, TracesKeepRate.Value); + WriteMetric(ref bytes, ref offset, TracesKeepRateBytes, TracesKeepRate.Value, tagProcessors); } - return count + base.WriteAdditionalMetrics(ref bytes, ref offset); + return count + base.WriteAdditionalMetrics(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalMetrics(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CosmosDbTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CosmosDbTags.g.cs index 26836aa2a..95a52c81d 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CosmosDbTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CosmosDbTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class CosmosDbTags @@ -63,46 +65,46 @@ public override void SetTag(string key, string value) return CosmosDbTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (ContainerId != null) { count++; - WriteTag(ref bytes, ref offset, ContainerIdBytes, ContainerId); + WriteTag(ref bytes, ref offset, ContainerIdBytes, ContainerId, tagProcessors); } if (DatabaseId != null) { count++; - WriteTag(ref bytes, ref offset, DatabaseIdBytes, DatabaseId); + WriteTag(ref bytes, ref offset, DatabaseIdBytes, DatabaseId, tagProcessors); } if (Host != null) { count++; - WriteTag(ref bytes, ref offset, HostBytes, Host); + WriteTag(ref bytes, ref offset, HostBytes, Host, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CouchbaseTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CouchbaseTags.g.cs index 1eb9f215b..e2a314697 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CouchbaseTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CouchbaseTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class CouchbaseTags @@ -69,52 +71,52 @@ public override void SetTag(string key, string value) return CouchbaseTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (OperationCode != null) { count++; - WriteTag(ref bytes, ref offset, OperationCodeBytes, OperationCode); + WriteTag(ref bytes, ref offset, OperationCodeBytes, OperationCode, tagProcessors); } if (Bucket != null) { count++; - WriteTag(ref bytes, ref offset, BucketBytes, Bucket); + WriteTag(ref bytes, ref offset, BucketBytes, Bucket, tagProcessors); } if (Key != null) { count++; - WriteTag(ref bytes, ref offset, KeyBytes, Key); + WriteTag(ref bytes, ref offset, KeyBytes, Key, tagProcessors); } if (Host != null) { count++; - WriteTag(ref bytes, ref offset, HostBytes, Host); + WriteTag(ref bytes, ref offset, HostBytes, Host, tagProcessors); } if (Port != null) { count++; - WriteTag(ref bytes, ref offset, PortBytes, Port); + WriteTag(ref bytes, ref offset, PortBytes, Port, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ElasticsearchTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ElasticsearchTags.g.cs index 7a49904f3..bf41a1978 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ElasticsearchTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ElasticsearchTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Elasticsearch { partial class ElasticsearchTags @@ -66,52 +68,52 @@ public override void SetTag(string key, string value) return ElasticsearchTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (Action != null) { count++; - WriteTag(ref bytes, ref offset, ActionBytes, Action); + WriteTag(ref bytes, ref offset, ActionBytes, Action, tagProcessors); } if (Method != null) { count++; - WriteTag(ref bytes, ref offset, MethodBytes, Method); + WriteTag(ref bytes, ref offset, MethodBytes, Method, tagProcessors); } if (Url != null) { count++; - WriteTag(ref bytes, ref offset, UrlBytes, Url); + WriteTag(ref bytes, ref offset, UrlBytes, Url, tagProcessors); } if (DbStatement != null) { count++; - WriteTag(ref bytes, ref offset, DbStatementBytes, DbStatement); + WriteTag(ref bytes, ref offset, DbStatementBytes, DbStatement, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/GraphQLTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/GraphQLTags.g.cs index 2bba67761..6557d1aa3 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/GraphQLTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/GraphQLTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL { partial class GraphQLTags @@ -60,46 +62,46 @@ public override void SetTag(string key, string value) return GraphQLTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (Language != null) { count++; - WriteTag(ref bytes, ref offset, LanguageBytes, Language); + WriteTag(ref bytes, ref offset, LanguageBytes, Language, tagProcessors); } if (Source != null) { count++; - WriteTag(ref bytes, ref offset, SourceBytes, Source); + WriteTag(ref bytes, ref offset, SourceBytes, Source, tagProcessors); } if (OperationName != null) { count++; - WriteTag(ref bytes, ref offset, OperationNameBytes, OperationName); + WriteTag(ref bytes, ref offset, OperationNameBytes, OperationName, tagProcessors); } if (OperationType != null) { count++; - WriteTag(ref bytes, ref offset, OperationTypeBytes, OperationType); + WriteTag(ref bytes, ref offset, OperationTypeBytes, OperationType, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/HttpTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/HttpTags.g.cs index 005e107d3..65dff3342 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/HttpTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/HttpTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class HttpTags @@ -66,46 +68,46 @@ public override void SetTag(string key, string value) return HttpTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (HttpMethod != null) { count++; - WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod); + WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod, tagProcessors); } if (HttpUrl != null) { count++; - WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl); + WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl, tagProcessors); } if (HttpClientHandlerType != null) { count++; - WriteTag(ref bytes, ref offset, HttpClientHandlerTypeBytes, HttpClientHandlerType); + WriteTag(ref bytes, ref offset, HttpClientHandlerTypeBytes, HttpClientHandlerType, tagProcessors); } if (HttpStatusCode != null) { count++; - WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode); + WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/InstrumentationTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/InstrumentationTags.g.cs index 4738878d8..6a1dc04ba 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/InstrumentationTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/InstrumentationTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class InstrumentationTags @@ -36,16 +38,16 @@ public override void SetMetric(string key, double? value) } } - protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (AnalyticsSampleRate != null) { count++; - WriteMetric(ref bytes, ref offset, AnalyticsSampleRateBytes, AnalyticsSampleRate.Value); + WriteMetric(ref bytes, ref offset, AnalyticsSampleRateBytes, AnalyticsSampleRate.Value, tagProcessors); } - return count + base.WriteAdditionalMetrics(ref bytes, ref offset); + return count + base.WriteAdditionalMetrics(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalMetrics(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/KafkaTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/KafkaTags.g.cs index 6683497d7..0f1ce8f0e 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/KafkaTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/KafkaTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class KafkaTags @@ -58,40 +60,40 @@ public override void SetTag(string key, string value) return KafkaTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (Partition != null) { count++; - WriteTag(ref bytes, ref offset, PartitionBytes, Partition); + WriteTag(ref bytes, ref offset, PartitionBytes, Partition, tagProcessors); } if (Offset != null) { count++; - WriteTag(ref bytes, ref offset, OffsetBytes, Offset); + WriteTag(ref bytes, ref offset, OffsetBytes, Offset, tagProcessors); } if (Tombstone != null) { count++; - WriteTag(ref bytes, ref offset, TombstoneBytes, Tombstone); + WriteTag(ref bytes, ref offset, TombstoneBytes, Tombstone, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) @@ -155,16 +157,16 @@ public override void SetMetric(string key, double? value) } } - protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (MessageQueueTimeMs != null) { count++; - WriteMetric(ref bytes, ref offset, MessageQueueTimeMsBytes, MessageQueueTimeMs.Value); + WriteMetric(ref bytes, ref offset, MessageQueueTimeMsBytes, MessageQueueTimeMs.Value, tagProcessors); } - return count + base.WriteAdditionalMetrics(ref bytes, ref offset); + return count + base.WriteAdditionalMetrics(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalMetrics(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MessagingTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MessagingTags.g.cs index b8c8ed475..fc81e87b6 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MessagingTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MessagingTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class MessagingTags @@ -111,88 +113,88 @@ public override void SetTag(string key, string value) return MessagingTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (System != null) { count++; - WriteTag(ref bytes, ref offset, SystemBytes, System); + WriteTag(ref bytes, ref offset, SystemBytes, System, tagProcessors); } if (Destination != null) { count++; - WriteTag(ref bytes, ref offset, DestinationBytes, Destination); + WriteTag(ref bytes, ref offset, DestinationBytes, Destination, tagProcessors); } if (DestinationKind != null) { count++; - WriteTag(ref bytes, ref offset, DestinationKindBytes, DestinationKind); + WriteTag(ref bytes, ref offset, DestinationKindBytes, DestinationKind, tagProcessors); } if (TempDestination != null) { count++; - WriteTag(ref bytes, ref offset, TempDestinationBytes, TempDestination); + WriteTag(ref bytes, ref offset, TempDestinationBytes, TempDestination, tagProcessors); } if (Protocol != null) { count++; - WriteTag(ref bytes, ref offset, ProtocolBytes, Protocol); + WriteTag(ref bytes, ref offset, ProtocolBytes, Protocol, tagProcessors); } if (ProtocolVersion != null) { count++; - WriteTag(ref bytes, ref offset, ProtocolVersionBytes, ProtocolVersion); + WriteTag(ref bytes, ref offset, ProtocolVersionBytes, ProtocolVersion, tagProcessors); } if (Url != null) { count++; - WriteTag(ref bytes, ref offset, UrlBytes, Url); + WriteTag(ref bytes, ref offset, UrlBytes, Url, tagProcessors); } if (Operation != null) { count++; - WriteTag(ref bytes, ref offset, OperationBytes, Operation); + WriteTag(ref bytes, ref offset, OperationBytes, Operation, tagProcessors); } if (MessageId != null) { count++; - WriteTag(ref bytes, ref offset, MessageIdBytes, MessageId); + WriteTag(ref bytes, ref offset, MessageIdBytes, MessageId, tagProcessors); } if (ConversationId != null) { count++; - WriteTag(ref bytes, ref offset, ConversationIdBytes, ConversationId); + WriteTag(ref bytes, ref offset, ConversationIdBytes, ConversationId, tagProcessors); } if (ConsumerId != null) { count++; - WriteTag(ref bytes, ref offset, ConsumerIdBytes, ConsumerId); + WriteTag(ref bytes, ref offset, ConsumerIdBytes, ConsumerId, tagProcessors); } if (MessageSize != null) { count++; - WriteTag(ref bytes, ref offset, MessageSizeBytes, MessageSize); + WriteTag(ref bytes, ref offset, MessageSizeBytes, MessageSize, tagProcessors); } if (MessageSizeCompressed != null) { count++; - WriteTag(ref bytes, ref offset, MessageSizeCompressedBytes, MessageSizeCompressed); + WriteTag(ref bytes, ref offset, MessageSizeCompressedBytes, MessageSizeCompressed, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MongoDbTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MongoDbTags.g.cs index b89fa38f2..2ccee59fa 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MongoDbTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MongoDbTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb { partial class MongoDbTags @@ -81,64 +83,64 @@ public override void SetTag(string key, string value) return MongoDbTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (DbStatement != null) { count++; - WriteTag(ref bytes, ref offset, DbStatementBytes, DbStatement); + WriteTag(ref bytes, ref offset, DbStatementBytes, DbStatement, tagProcessors); } if (DbName != null) { count++; - WriteTag(ref bytes, ref offset, DbNameBytes, DbName); + WriteTag(ref bytes, ref offset, DbNameBytes, DbName, tagProcessors); } if (Query != null) { count++; - WriteTag(ref bytes, ref offset, QueryBytes, Query); + WriteTag(ref bytes, ref offset, QueryBytes, Query, tagProcessors); } if (Collection != null) { count++; - WriteTag(ref bytes, ref offset, CollectionBytes, Collection); + WriteTag(ref bytes, ref offset, CollectionBytes, Collection, tagProcessors); } if (Host != null) { count++; - WriteTag(ref bytes, ref offset, HostBytes, Host); + WriteTag(ref bytes, ref offset, HostBytes, Host, tagProcessors); } if (Port != null) { count++; - WriteTag(ref bytes, ref offset, PortBytes, Port); + WriteTag(ref bytes, ref offset, PortBytes, Port, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MsmqTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MsmqTags.g.cs index 481737cd7..c0bc0f2c4 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MsmqTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MsmqTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class MsmqTags @@ -63,46 +65,46 @@ public override void SetTag(string key, string value) return MsmqTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (Command != null) { count++; - WriteTag(ref bytes, ref offset, CommandBytes, Command); + WriteTag(ref bytes, ref offset, CommandBytes, Command, tagProcessors); } if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (Path != null) { count++; - WriteTag(ref bytes, ref offset, PathBytes, Path); + WriteTag(ref bytes, ref offset, PathBytes, Path, tagProcessors); } if (MessageWithTransaction != null) { count++; - WriteTag(ref bytes, ref offset, MessageWithTransactionBytes, MessageWithTransaction); + WriteTag(ref bytes, ref offset, MessageWithTransactionBytes, MessageWithTransaction, tagProcessors); } if (IsTransactionalQueue != null) { count++; - WriteTag(ref bytes, ref offset, IsTransactionalQueueBytes, IsTransactionalQueue); + WriteTag(ref bytes, ref offset, IsTransactionalQueueBytes, IsTransactionalQueue, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RabbitMQTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RabbitMQTags.g.cs index 4a48393bc..340993c79 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RabbitMQTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RabbitMQTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class RabbitMQTags @@ -72,52 +74,52 @@ public override void SetTag(string key, string value) return RabbitMQTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (Command != null) { count++; - WriteTag(ref bytes, ref offset, CommandBytes, Command); + WriteTag(ref bytes, ref offset, CommandBytes, Command, tagProcessors); } if (DeliveryMode != null) { count++; - WriteTag(ref bytes, ref offset, DeliveryModeBytes, DeliveryMode); + WriteTag(ref bytes, ref offset, DeliveryModeBytes, DeliveryMode, tagProcessors); } if (Exchange != null) { count++; - WriteTag(ref bytes, ref offset, ExchangeBytes, Exchange); + WriteTag(ref bytes, ref offset, ExchangeBytes, Exchange, tagProcessors); } if (RoutingKey != null) { count++; - WriteTag(ref bytes, ref offset, RoutingKeyBytes, RoutingKey); + WriteTag(ref bytes, ref offset, RoutingKeyBytes, RoutingKey, tagProcessors); } if (Queue != null) { count++; - WriteTag(ref bytes, ref offset, QueueBytes, Queue); + WriteTag(ref bytes, ref offset, QueueBytes, Queue, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RedisTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RedisTags.g.cs index 770c27698..838714c68 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RedisTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RedisTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis { partial class RedisTags @@ -60,46 +62,46 @@ public override void SetTag(string key, string value) return RedisTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (RawCommand != null) { count++; - WriteTag(ref bytes, ref offset, RawCommandBytes, RawCommand); + WriteTag(ref bytes, ref offset, RawCommandBytes, RawCommand, tagProcessors); } if (Host != null) { count++; - WriteTag(ref bytes, ref offset, HostBytes, Host); + WriteTag(ref bytes, ref offset, HostBytes, Host, tagProcessors); } if (Port != null) { count++; - WriteTag(ref bytes, ref offset, PortBytes, Port); + WriteTag(ref bytes, ref offset, PortBytes, Port, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ServiceRemotingTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ServiceRemotingTags.g.cs index 42f86150e..27dc383f5 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ServiceRemotingTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ServiceRemotingTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.ServiceFabric { partial class ServiceRemotingTags @@ -102,82 +104,82 @@ public override void SetTag(string key, string value) return ServiceRemotingTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (ApplicationId != null) { count++; - WriteTag(ref bytes, ref offset, ApplicationIdBytes, ApplicationId); + WriteTag(ref bytes, ref offset, ApplicationIdBytes, ApplicationId, tagProcessors); } if (ApplicationName != null) { count++; - WriteTag(ref bytes, ref offset, ApplicationNameBytes, ApplicationName); + WriteTag(ref bytes, ref offset, ApplicationNameBytes, ApplicationName, tagProcessors); } if (PartitionId != null) { count++; - WriteTag(ref bytes, ref offset, PartitionIdBytes, PartitionId); + WriteTag(ref bytes, ref offset, PartitionIdBytes, PartitionId, tagProcessors); } if (NodeId != null) { count++; - WriteTag(ref bytes, ref offset, NodeIdBytes, NodeId); + WriteTag(ref bytes, ref offset, NodeIdBytes, NodeId, tagProcessors); } if (NodeName != null) { count++; - WriteTag(ref bytes, ref offset, NodeNameBytes, NodeName); + WriteTag(ref bytes, ref offset, NodeNameBytes, NodeName, tagProcessors); } if (ServiceName != null) { count++; - WriteTag(ref bytes, ref offset, ServiceNameBytes, ServiceName); + WriteTag(ref bytes, ref offset, ServiceNameBytes, ServiceName, tagProcessors); } if (RemotingUri != null) { count++; - WriteTag(ref bytes, ref offset, RemotingUriBytes, RemotingUri); + WriteTag(ref bytes, ref offset, RemotingUriBytes, RemotingUri, tagProcessors); } if (RemotingMethodName != null) { count++; - WriteTag(ref bytes, ref offset, RemotingMethodNameBytes, RemotingMethodName); + WriteTag(ref bytes, ref offset, RemotingMethodNameBytes, RemotingMethodName, tagProcessors); } if (RemotingMethodId != null) { count++; - WriteTag(ref bytes, ref offset, RemotingMethodIdBytes, RemotingMethodId); + WriteTag(ref bytes, ref offset, RemotingMethodIdBytes, RemotingMethodId, tagProcessors); } if (RemotingInterfaceId != null) { count++; - WriteTag(ref bytes, ref offset, RemotingInterfaceIdBytes, RemotingInterfaceId); + WriteTag(ref bytes, ref offset, RemotingInterfaceIdBytes, RemotingInterfaceId, tagProcessors); } if (RemotingInvocationId != null) { count++; - WriteTag(ref bytes, ref offset, RemotingInvocationIdBytes, RemotingInvocationId); + WriteTag(ref bytes, ref offset, RemotingInvocationIdBytes, RemotingInvocationId, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/SqlTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/SqlTags.g.cs index 89436fa58..a99d61b2d 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/SqlTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/SqlTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class SqlTags @@ -66,46 +68,46 @@ public override void SetTag(string key, string value) return SqlTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbName != null) { count++; - WriteTag(ref bytes, ref offset, DbNameBytes, DbName); + WriteTag(ref bytes, ref offset, DbNameBytes, DbName, tagProcessors); } if (DbUser != null) { count++; - WriteTag(ref bytes, ref offset, DbUserBytes, DbUser); + WriteTag(ref bytes, ref offset, DbUserBytes, DbUser, tagProcessors); } if (OutHost != null) { count++; - WriteTag(ref bytes, ref offset, OutHostBytes, OutHost); + WriteTag(ref bytes, ref offset, OutHostBytes, OutHost, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WcfTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WcfTags.g.cs index 9ebcc0078..a11ae9af4 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WcfTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WcfTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class WcfTags @@ -36,16 +38,16 @@ public override void SetTag(string key, string value) return WcfTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WebTags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WebTags.g.cs index 4230e6d0f..d87697b06 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WebTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WebTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class WebTags @@ -69,52 +71,52 @@ public override void SetTag(string key, string value) return WebTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (HttpMethod != null) { count++; - WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod); + WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod, tagProcessors); } if (HttpRequestHeadersHost != null) { count++; - WriteTag(ref bytes, ref offset, HttpRequestHeadersHostBytes, HttpRequestHeadersHost); + WriteTag(ref bytes, ref offset, HttpRequestHeadersHostBytes, HttpRequestHeadersHost, tagProcessors); } if (HttpUrl != null) { count++; - WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl); + WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl, tagProcessors); } if (PeerIp != null) { count++; - WriteTag(ref bytes, ref offset, PeerIpBytes, PeerIp); + WriteTag(ref bytes, ref offset, PeerIpBytes, PeerIp, tagProcessors); } if (Language != null) { count++; - WriteTag(ref bytes, ref offset, LanguageBytes, Language); + WriteTag(ref bytes, ref offset, LanguageBytes, Language, tagProcessors); } if (HttpStatusCode != null) { count++; - WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode); + WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AerospikeTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AerospikeTags.g.cs index 1071b1dc5..bbab3e479 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AerospikeTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AerospikeTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AerospikeTags @@ -66,52 +68,52 @@ public override void SetTag(string key, string value) return AerospikeTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (Key != null) { count++; - WriteTag(ref bytes, ref offset, KeyBytes, Key); + WriteTag(ref bytes, ref offset, KeyBytes, Key, tagProcessors); } if (Namespace != null) { count++; - WriteTag(ref bytes, ref offset, NamespaceBytes, Namespace); + WriteTag(ref bytes, ref offset, NamespaceBytes, Namespace, tagProcessors); } if (SetName != null) { count++; - WriteTag(ref bytes, ref offset, SetNameBytes, SetName); + WriteTag(ref bytes, ref offset, SetNameBytes, SetName, tagProcessors); } if (UserKey != null) { count++; - WriteTag(ref bytes, ref offset, UserKeyBytes, UserKey); + WriteTag(ref bytes, ref offset, UserKeyBytes, UserKey, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreEndpointTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreEndpointTags.g.cs index d9d6a2a60..61ec90ba6 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreEndpointTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreEndpointTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AspNetCoreEndpointTags @@ -39,16 +41,16 @@ public override void SetTag(string key, string value) return AspNetCoreEndpointTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (AspNetCoreEndpoint != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCoreEndpointBytes, AspNetCoreEndpoint); + WriteTag(ref bytes, ref offset, AspNetCoreEndpointBytes, AspNetCoreEndpoint, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreMvcTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreMvcTags.g.cs index 636f92131..afc9db842 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreMvcTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreMvcTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AspNetCoreMvcTags @@ -57,34 +59,34 @@ public override void SetTag(string key, string value) return AspNetCoreMvcTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (AspNetCoreController != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCoreControllerBytes, AspNetCoreController); + WriteTag(ref bytes, ref offset, AspNetCoreControllerBytes, AspNetCoreController, tagProcessors); } if (AspNetCoreAction != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCoreActionBytes, AspNetCoreAction); + WriteTag(ref bytes, ref offset, AspNetCoreActionBytes, AspNetCoreAction, tagProcessors); } if (AspNetCoreArea != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCoreAreaBytes, AspNetCoreArea); + WriteTag(ref bytes, ref offset, AspNetCoreAreaBytes, AspNetCoreArea, tagProcessors); } if (AspNetCorePage != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCorePageBytes, AspNetCorePage); + WriteTag(ref bytes, ref offset, AspNetCorePageBytes, AspNetCorePage, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreTags.g.cs index 85f259d15..7076cd3db 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetCoreTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AspNetCoreTags @@ -42,22 +44,22 @@ public override void SetTag(string key, string value) return AspNetCoreTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (AspNetCoreRoute != null) { count++; - WriteTag(ref bytes, ref offset, AspNetCoreRouteBytes, AspNetCoreRoute); + WriteTag(ref bytes, ref offset, AspNetCoreRouteBytes, AspNetCoreRoute, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetTags.g.cs index ce5fc25e5..582b937ec 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AspNetTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AspNetTags @@ -57,34 +59,34 @@ public override void SetTag(string key, string value) return AspNetTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (AspNetRoute != null) { count++; - WriteTag(ref bytes, ref offset, AspNetRouteBytes, AspNetRoute); + WriteTag(ref bytes, ref offset, AspNetRouteBytes, AspNetRoute, tagProcessors); } if (AspNetController != null) { count++; - WriteTag(ref bytes, ref offset, AspNetControllerBytes, AspNetController); + WriteTag(ref bytes, ref offset, AspNetControllerBytes, AspNetController, tagProcessors); } if (AspNetAction != null) { count++; - WriteTag(ref bytes, ref offset, AspNetActionBytes, AspNetAction); + WriteTag(ref bytes, ref offset, AspNetActionBytes, AspNetAction, tagProcessors); } if (AspNetArea != null) { count++; - WriteTag(ref bytes, ref offset, AspNetAreaBytes, AspNetArea); + WriteTag(ref bytes, ref offset, AspNetAreaBytes, AspNetArea, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSdkTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSdkTags.g.cs index 8e412854a..b05fb4c59 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSdkTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSdkTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AwsSdkTags @@ -81,64 +83,64 @@ public override void SetTag(string key, string value) return AwsSdkTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (AgentName != null) { count++; - WriteTag(ref bytes, ref offset, AgentNameBytes, AgentName); + WriteTag(ref bytes, ref offset, AgentNameBytes, AgentName, tagProcessors); } if (Operation != null) { count++; - WriteTag(ref bytes, ref offset, OperationBytes, Operation); + WriteTag(ref bytes, ref offset, OperationBytes, Operation, tagProcessors); } if (Region != null) { count++; - WriteTag(ref bytes, ref offset, RegionBytes, Region); + WriteTag(ref bytes, ref offset, RegionBytes, Region, tagProcessors); } if (RequestId != null) { count++; - WriteTag(ref bytes, ref offset, RequestIdBytes, RequestId); + WriteTag(ref bytes, ref offset, RequestIdBytes, RequestId, tagProcessors); } if (Service != null) { count++; - WriteTag(ref bytes, ref offset, ServiceBytes, Service); + WriteTag(ref bytes, ref offset, ServiceBytes, Service, tagProcessors); } if (HttpMethod != null) { count++; - WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod); + WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod, tagProcessors); } if (HttpUrl != null) { count++; - WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl); + WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl, tagProcessors); } if (HttpStatusCode != null) { count++; - WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode); + WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSqsTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSqsTags.g.cs index 94743603b..728869a20 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSqsTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AwsSqsTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AwsSqsTags @@ -48,28 +50,28 @@ public override void SetTag(string key, string value) return AwsSqsTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (QueueName != null) { count++; - WriteTag(ref bytes, ref offset, QueueNameBytes, QueueName); + WriteTag(ref bytes, ref offset, QueueNameBytes, QueueName, tagProcessors); } if (QueueUrl != null) { count++; - WriteTag(ref bytes, ref offset, QueueUrlBytes, QueueUrl); + WriteTag(ref bytes, ref offset, QueueUrlBytes, QueueUrl, tagProcessors); } if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AzureFunctionsTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AzureFunctionsTags.g.cs index 07480f05a..e3d7bd6ff 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AzureFunctionsTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/AzureFunctionsTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class AzureFunctionsTags @@ -66,52 +68,52 @@ public override void SetTag(string key, string value) return AzureFunctionsTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (Language != null) { count++; - WriteTag(ref bytes, ref offset, LanguageBytes, Language); + WriteTag(ref bytes, ref offset, LanguageBytes, Language, tagProcessors); } if (ShortName != null) { count++; - WriteTag(ref bytes, ref offset, ShortNameBytes, ShortName); + WriteTag(ref bytes, ref offset, ShortNameBytes, ShortName, tagProcessors); } if (FullName != null) { count++; - WriteTag(ref bytes, ref offset, FullNameBytes, FullName); + WriteTag(ref bytes, ref offset, FullNameBytes, FullName, tagProcessors); } if (BindingSource != null) { count++; - WriteTag(ref bytes, ref offset, BindingSourceBytes, BindingSource); + WriteTag(ref bytes, ref offset, BindingSourceBytes, BindingSource, tagProcessors); } if (TriggerType != null) { count++; - WriteTag(ref bytes, ref offset, TriggerTypeBytes, TriggerType); + WriteTag(ref bytes, ref offset, TriggerTypeBytes, TriggerType, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CommonTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CommonTags.g.cs index aa1637073..24d2e7fe0 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CommonTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CommonTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class CommonTags @@ -60,34 +62,34 @@ public override void SetTag(string key, string value) return CommonTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (Environment != null) { count++; - WriteTag(ref bytes, ref offset, EnvironmentBytes, Environment); + WriteTag(ref bytes, ref offset, EnvironmentBytes, Environment, tagProcessors); } if (Version != null) { count++; - WriteTag(ref bytes, ref offset, VersionBytes, Version); + WriteTag(ref bytes, ref offset, VersionBytes, Version, tagProcessors); } if (SignalFxVersion != null) { count++; - WriteTag(ref bytes, ref offset, SignalFxVersionBytes, SignalFxVersion); + WriteTag(ref bytes, ref offset, SignalFxVersionBytes, SignalFxVersion, tagProcessors); } if (SignalFxLibrary != null) { count++; - WriteTag(ref bytes, ref offset, SignalFxLibraryBytes, SignalFxLibrary); + WriteTag(ref bytes, ref offset, SignalFxLibraryBytes, SignalFxLibrary, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) @@ -152,28 +154,28 @@ public override void SetMetric(string key, double? value) } } - protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SamplingPriority != null) { count++; - WriteMetric(ref bytes, ref offset, SamplingPriorityBytes, SamplingPriority.Value); + WriteMetric(ref bytes, ref offset, SamplingPriorityBytes, SamplingPriority.Value, tagProcessors); } if (SamplingLimitDecision != null) { count++; - WriteMetric(ref bytes, ref offset, SamplingLimitDecisionBytes, SamplingLimitDecision.Value); + WriteMetric(ref bytes, ref offset, SamplingLimitDecisionBytes, SamplingLimitDecision.Value, tagProcessors); } if (TracesKeepRate != null) { count++; - WriteMetric(ref bytes, ref offset, TracesKeepRateBytes, TracesKeepRate.Value); + WriteMetric(ref bytes, ref offset, TracesKeepRateBytes, TracesKeepRate.Value, tagProcessors); } - return count + base.WriteAdditionalMetrics(ref bytes, ref offset); + return count + base.WriteAdditionalMetrics(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalMetrics(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CosmosDbTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CosmosDbTags.g.cs index 26836aa2a..95a52c81d 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CosmosDbTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CosmosDbTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class CosmosDbTags @@ -63,46 +65,46 @@ public override void SetTag(string key, string value) return CosmosDbTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (ContainerId != null) { count++; - WriteTag(ref bytes, ref offset, ContainerIdBytes, ContainerId); + WriteTag(ref bytes, ref offset, ContainerIdBytes, ContainerId, tagProcessors); } if (DatabaseId != null) { count++; - WriteTag(ref bytes, ref offset, DatabaseIdBytes, DatabaseId); + WriteTag(ref bytes, ref offset, DatabaseIdBytes, DatabaseId, tagProcessors); } if (Host != null) { count++; - WriteTag(ref bytes, ref offset, HostBytes, Host); + WriteTag(ref bytes, ref offset, HostBytes, Host, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CouchbaseTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CouchbaseTags.g.cs index 1eb9f215b..e2a314697 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CouchbaseTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/CouchbaseTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class CouchbaseTags @@ -69,52 +71,52 @@ public override void SetTag(string key, string value) return CouchbaseTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (OperationCode != null) { count++; - WriteTag(ref bytes, ref offset, OperationCodeBytes, OperationCode); + WriteTag(ref bytes, ref offset, OperationCodeBytes, OperationCode, tagProcessors); } if (Bucket != null) { count++; - WriteTag(ref bytes, ref offset, BucketBytes, Bucket); + WriteTag(ref bytes, ref offset, BucketBytes, Bucket, tagProcessors); } if (Key != null) { count++; - WriteTag(ref bytes, ref offset, KeyBytes, Key); + WriteTag(ref bytes, ref offset, KeyBytes, Key, tagProcessors); } if (Host != null) { count++; - WriteTag(ref bytes, ref offset, HostBytes, Host); + WriteTag(ref bytes, ref offset, HostBytes, Host, tagProcessors); } if (Port != null) { count++; - WriteTag(ref bytes, ref offset, PortBytes, Port); + WriteTag(ref bytes, ref offset, PortBytes, Port, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ElasticsearchTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ElasticsearchTags.g.cs index 7a49904f3..bf41a1978 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ElasticsearchTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ElasticsearchTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Elasticsearch { partial class ElasticsearchTags @@ -66,52 +68,52 @@ public override void SetTag(string key, string value) return ElasticsearchTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (Action != null) { count++; - WriteTag(ref bytes, ref offset, ActionBytes, Action); + WriteTag(ref bytes, ref offset, ActionBytes, Action, tagProcessors); } if (Method != null) { count++; - WriteTag(ref bytes, ref offset, MethodBytes, Method); + WriteTag(ref bytes, ref offset, MethodBytes, Method, tagProcessors); } if (Url != null) { count++; - WriteTag(ref bytes, ref offset, UrlBytes, Url); + WriteTag(ref bytes, ref offset, UrlBytes, Url, tagProcessors); } if (DbStatement != null) { count++; - WriteTag(ref bytes, ref offset, DbStatementBytes, DbStatement); + WriteTag(ref bytes, ref offset, DbStatementBytes, DbStatement, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/GraphQLTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/GraphQLTags.g.cs index 2bba67761..6557d1aa3 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/GraphQLTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/GraphQLTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL { partial class GraphQLTags @@ -60,46 +62,46 @@ public override void SetTag(string key, string value) return GraphQLTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (Language != null) { count++; - WriteTag(ref bytes, ref offset, LanguageBytes, Language); + WriteTag(ref bytes, ref offset, LanguageBytes, Language, tagProcessors); } if (Source != null) { count++; - WriteTag(ref bytes, ref offset, SourceBytes, Source); + WriteTag(ref bytes, ref offset, SourceBytes, Source, tagProcessors); } if (OperationName != null) { count++; - WriteTag(ref bytes, ref offset, OperationNameBytes, OperationName); + WriteTag(ref bytes, ref offset, OperationNameBytes, OperationName, tagProcessors); } if (OperationType != null) { count++; - WriteTag(ref bytes, ref offset, OperationTypeBytes, OperationType); + WriteTag(ref bytes, ref offset, OperationTypeBytes, OperationType, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/HttpTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/HttpTags.g.cs index 005e107d3..65dff3342 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/HttpTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/HttpTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class HttpTags @@ -66,46 +68,46 @@ public override void SetTag(string key, string value) return HttpTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (HttpMethod != null) { count++; - WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod); + WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod, tagProcessors); } if (HttpUrl != null) { count++; - WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl); + WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl, tagProcessors); } if (HttpClientHandlerType != null) { count++; - WriteTag(ref bytes, ref offset, HttpClientHandlerTypeBytes, HttpClientHandlerType); + WriteTag(ref bytes, ref offset, HttpClientHandlerTypeBytes, HttpClientHandlerType, tagProcessors); } if (HttpStatusCode != null) { count++; - WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode); + WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/InstrumentationTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/InstrumentationTags.g.cs index 4738878d8..6a1dc04ba 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/InstrumentationTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/InstrumentationTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class InstrumentationTags @@ -36,16 +38,16 @@ public override void SetMetric(string key, double? value) } } - protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (AnalyticsSampleRate != null) { count++; - WriteMetric(ref bytes, ref offset, AnalyticsSampleRateBytes, AnalyticsSampleRate.Value); + WriteMetric(ref bytes, ref offset, AnalyticsSampleRateBytes, AnalyticsSampleRate.Value, tagProcessors); } - return count + base.WriteAdditionalMetrics(ref bytes, ref offset); + return count + base.WriteAdditionalMetrics(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalMetrics(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/KafkaTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/KafkaTags.g.cs index 6683497d7..0f1ce8f0e 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/KafkaTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/KafkaTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class KafkaTags @@ -58,40 +60,40 @@ public override void SetTag(string key, string value) return KafkaTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (Partition != null) { count++; - WriteTag(ref bytes, ref offset, PartitionBytes, Partition); + WriteTag(ref bytes, ref offset, PartitionBytes, Partition, tagProcessors); } if (Offset != null) { count++; - WriteTag(ref bytes, ref offset, OffsetBytes, Offset); + WriteTag(ref bytes, ref offset, OffsetBytes, Offset, tagProcessors); } if (Tombstone != null) { count++; - WriteTag(ref bytes, ref offset, TombstoneBytes, Tombstone); + WriteTag(ref bytes, ref offset, TombstoneBytes, Tombstone, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) @@ -155,16 +157,16 @@ public override void SetMetric(string key, double? value) } } - protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (MessageQueueTimeMs != null) { count++; - WriteMetric(ref bytes, ref offset, MessageQueueTimeMsBytes, MessageQueueTimeMs.Value); + WriteMetric(ref bytes, ref offset, MessageQueueTimeMsBytes, MessageQueueTimeMs.Value, tagProcessors); } - return count + base.WriteAdditionalMetrics(ref bytes, ref offset); + return count + base.WriteAdditionalMetrics(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalMetrics(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MessagingTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MessagingTags.g.cs index b8c8ed475..fc81e87b6 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MessagingTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MessagingTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class MessagingTags @@ -111,88 +113,88 @@ public override void SetTag(string key, string value) return MessagingTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (System != null) { count++; - WriteTag(ref bytes, ref offset, SystemBytes, System); + WriteTag(ref bytes, ref offset, SystemBytes, System, tagProcessors); } if (Destination != null) { count++; - WriteTag(ref bytes, ref offset, DestinationBytes, Destination); + WriteTag(ref bytes, ref offset, DestinationBytes, Destination, tagProcessors); } if (DestinationKind != null) { count++; - WriteTag(ref bytes, ref offset, DestinationKindBytes, DestinationKind); + WriteTag(ref bytes, ref offset, DestinationKindBytes, DestinationKind, tagProcessors); } if (TempDestination != null) { count++; - WriteTag(ref bytes, ref offset, TempDestinationBytes, TempDestination); + WriteTag(ref bytes, ref offset, TempDestinationBytes, TempDestination, tagProcessors); } if (Protocol != null) { count++; - WriteTag(ref bytes, ref offset, ProtocolBytes, Protocol); + WriteTag(ref bytes, ref offset, ProtocolBytes, Protocol, tagProcessors); } if (ProtocolVersion != null) { count++; - WriteTag(ref bytes, ref offset, ProtocolVersionBytes, ProtocolVersion); + WriteTag(ref bytes, ref offset, ProtocolVersionBytes, ProtocolVersion, tagProcessors); } if (Url != null) { count++; - WriteTag(ref bytes, ref offset, UrlBytes, Url); + WriteTag(ref bytes, ref offset, UrlBytes, Url, tagProcessors); } if (Operation != null) { count++; - WriteTag(ref bytes, ref offset, OperationBytes, Operation); + WriteTag(ref bytes, ref offset, OperationBytes, Operation, tagProcessors); } if (MessageId != null) { count++; - WriteTag(ref bytes, ref offset, MessageIdBytes, MessageId); + WriteTag(ref bytes, ref offset, MessageIdBytes, MessageId, tagProcessors); } if (ConversationId != null) { count++; - WriteTag(ref bytes, ref offset, ConversationIdBytes, ConversationId); + WriteTag(ref bytes, ref offset, ConversationIdBytes, ConversationId, tagProcessors); } if (ConsumerId != null) { count++; - WriteTag(ref bytes, ref offset, ConsumerIdBytes, ConsumerId); + WriteTag(ref bytes, ref offset, ConsumerIdBytes, ConsumerId, tagProcessors); } if (MessageSize != null) { count++; - WriteTag(ref bytes, ref offset, MessageSizeBytes, MessageSize); + WriteTag(ref bytes, ref offset, MessageSizeBytes, MessageSize, tagProcessors); } if (MessageSizeCompressed != null) { count++; - WriteTag(ref bytes, ref offset, MessageSizeCompressedBytes, MessageSizeCompressed); + WriteTag(ref bytes, ref offset, MessageSizeCompressedBytes, MessageSizeCompressed, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MongoDbTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MongoDbTags.g.cs index b89fa38f2..2ccee59fa 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MongoDbTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MongoDbTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb { partial class MongoDbTags @@ -81,64 +83,64 @@ public override void SetTag(string key, string value) return MongoDbTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (DbStatement != null) { count++; - WriteTag(ref bytes, ref offset, DbStatementBytes, DbStatement); + WriteTag(ref bytes, ref offset, DbStatementBytes, DbStatement, tagProcessors); } if (DbName != null) { count++; - WriteTag(ref bytes, ref offset, DbNameBytes, DbName); + WriteTag(ref bytes, ref offset, DbNameBytes, DbName, tagProcessors); } if (Query != null) { count++; - WriteTag(ref bytes, ref offset, QueryBytes, Query); + WriteTag(ref bytes, ref offset, QueryBytes, Query, tagProcessors); } if (Collection != null) { count++; - WriteTag(ref bytes, ref offset, CollectionBytes, Collection); + WriteTag(ref bytes, ref offset, CollectionBytes, Collection, tagProcessors); } if (Host != null) { count++; - WriteTag(ref bytes, ref offset, HostBytes, Host); + WriteTag(ref bytes, ref offset, HostBytes, Host, tagProcessors); } if (Port != null) { count++; - WriteTag(ref bytes, ref offset, PortBytes, Port); + WriteTag(ref bytes, ref offset, PortBytes, Port, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MsmqTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MsmqTags.g.cs index 481737cd7..c0bc0f2c4 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MsmqTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/MsmqTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class MsmqTags @@ -63,46 +65,46 @@ public override void SetTag(string key, string value) return MsmqTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (Command != null) { count++; - WriteTag(ref bytes, ref offset, CommandBytes, Command); + WriteTag(ref bytes, ref offset, CommandBytes, Command, tagProcessors); } if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (Path != null) { count++; - WriteTag(ref bytes, ref offset, PathBytes, Path); + WriteTag(ref bytes, ref offset, PathBytes, Path, tagProcessors); } if (MessageWithTransaction != null) { count++; - WriteTag(ref bytes, ref offset, MessageWithTransactionBytes, MessageWithTransaction); + WriteTag(ref bytes, ref offset, MessageWithTransactionBytes, MessageWithTransaction, tagProcessors); } if (IsTransactionalQueue != null) { count++; - WriteTag(ref bytes, ref offset, IsTransactionalQueueBytes, IsTransactionalQueue); + WriteTag(ref bytes, ref offset, IsTransactionalQueueBytes, IsTransactionalQueue, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RabbitMQTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RabbitMQTags.g.cs index 4a48393bc..340993c79 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RabbitMQTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RabbitMQTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class RabbitMQTags @@ -72,52 +74,52 @@ public override void SetTag(string key, string value) return RabbitMQTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (Command != null) { count++; - WriteTag(ref bytes, ref offset, CommandBytes, Command); + WriteTag(ref bytes, ref offset, CommandBytes, Command, tagProcessors); } if (DeliveryMode != null) { count++; - WriteTag(ref bytes, ref offset, DeliveryModeBytes, DeliveryMode); + WriteTag(ref bytes, ref offset, DeliveryModeBytes, DeliveryMode, tagProcessors); } if (Exchange != null) { count++; - WriteTag(ref bytes, ref offset, ExchangeBytes, Exchange); + WriteTag(ref bytes, ref offset, ExchangeBytes, Exchange, tagProcessors); } if (RoutingKey != null) { count++; - WriteTag(ref bytes, ref offset, RoutingKeyBytes, RoutingKey); + WriteTag(ref bytes, ref offset, RoutingKeyBytes, RoutingKey, tagProcessors); } if (Queue != null) { count++; - WriteTag(ref bytes, ref offset, QueueBytes, Queue); + WriteTag(ref bytes, ref offset, QueueBytes, Queue, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RedisTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RedisTags.g.cs index 770c27698..838714c68 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RedisTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/RedisTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis { partial class RedisTags @@ -60,46 +62,46 @@ public override void SetTag(string key, string value) return RedisTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (RawCommand != null) { count++; - WriteTag(ref bytes, ref offset, RawCommandBytes, RawCommand); + WriteTag(ref bytes, ref offset, RawCommandBytes, RawCommand, tagProcessors); } if (Host != null) { count++; - WriteTag(ref bytes, ref offset, HostBytes, Host); + WriteTag(ref bytes, ref offset, HostBytes, Host, tagProcessors); } if (Port != null) { count++; - WriteTag(ref bytes, ref offset, PortBytes, Port); + WriteTag(ref bytes, ref offset, PortBytes, Port, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ServiceRemotingTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ServiceRemotingTags.g.cs index 42f86150e..27dc383f5 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ServiceRemotingTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/ServiceRemotingTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.ServiceFabric { partial class ServiceRemotingTags @@ -102,82 +104,82 @@ public override void SetTag(string key, string value) return ServiceRemotingTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (ApplicationId != null) { count++; - WriteTag(ref bytes, ref offset, ApplicationIdBytes, ApplicationId); + WriteTag(ref bytes, ref offset, ApplicationIdBytes, ApplicationId, tagProcessors); } if (ApplicationName != null) { count++; - WriteTag(ref bytes, ref offset, ApplicationNameBytes, ApplicationName); + WriteTag(ref bytes, ref offset, ApplicationNameBytes, ApplicationName, tagProcessors); } if (PartitionId != null) { count++; - WriteTag(ref bytes, ref offset, PartitionIdBytes, PartitionId); + WriteTag(ref bytes, ref offset, PartitionIdBytes, PartitionId, tagProcessors); } if (NodeId != null) { count++; - WriteTag(ref bytes, ref offset, NodeIdBytes, NodeId); + WriteTag(ref bytes, ref offset, NodeIdBytes, NodeId, tagProcessors); } if (NodeName != null) { count++; - WriteTag(ref bytes, ref offset, NodeNameBytes, NodeName); + WriteTag(ref bytes, ref offset, NodeNameBytes, NodeName, tagProcessors); } if (ServiceName != null) { count++; - WriteTag(ref bytes, ref offset, ServiceNameBytes, ServiceName); + WriteTag(ref bytes, ref offset, ServiceNameBytes, ServiceName, tagProcessors); } if (RemotingUri != null) { count++; - WriteTag(ref bytes, ref offset, RemotingUriBytes, RemotingUri); + WriteTag(ref bytes, ref offset, RemotingUriBytes, RemotingUri, tagProcessors); } if (RemotingMethodName != null) { count++; - WriteTag(ref bytes, ref offset, RemotingMethodNameBytes, RemotingMethodName); + WriteTag(ref bytes, ref offset, RemotingMethodNameBytes, RemotingMethodName, tagProcessors); } if (RemotingMethodId != null) { count++; - WriteTag(ref bytes, ref offset, RemotingMethodIdBytes, RemotingMethodId); + WriteTag(ref bytes, ref offset, RemotingMethodIdBytes, RemotingMethodId, tagProcessors); } if (RemotingInterfaceId != null) { count++; - WriteTag(ref bytes, ref offset, RemotingInterfaceIdBytes, RemotingInterfaceId); + WriteTag(ref bytes, ref offset, RemotingInterfaceIdBytes, RemotingInterfaceId, tagProcessors); } if (RemotingInvocationId != null) { count++; - WriteTag(ref bytes, ref offset, RemotingInvocationIdBytes, RemotingInvocationId); + WriteTag(ref bytes, ref offset, RemotingInvocationIdBytes, RemotingInvocationId, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/SqlTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/SqlTags.g.cs index 89436fa58..a99d61b2d 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/SqlTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/SqlTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class SqlTags @@ -66,46 +68,46 @@ public override void SetTag(string key, string value) return SqlTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (DbType != null) { count++; - WriteTag(ref bytes, ref offset, DbTypeBytes, DbType); + WriteTag(ref bytes, ref offset, DbTypeBytes, DbType, tagProcessors); } if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } if (DbName != null) { count++; - WriteTag(ref bytes, ref offset, DbNameBytes, DbName); + WriteTag(ref bytes, ref offset, DbNameBytes, DbName, tagProcessors); } if (DbUser != null) { count++; - WriteTag(ref bytes, ref offset, DbUserBytes, DbUser); + WriteTag(ref bytes, ref offset, DbUserBytes, DbUser, tagProcessors); } if (OutHost != null) { count++; - WriteTag(ref bytes, ref offset, OutHostBytes, OutHost); + WriteTag(ref bytes, ref offset, OutHostBytes, OutHost, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WcfTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WcfTags.g.cs index 9ebcc0078..a11ae9af4 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WcfTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WcfTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class WcfTags @@ -36,16 +38,16 @@ public override void SetTag(string key, string value) return WcfTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (InstrumentationName != null) { count++; - WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName); + WriteTag(ref bytes, ref offset, InstrumentationNameBytes, InstrumentationName, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WebTags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WebTags.g.cs index 4230e6d0f..d87697b06 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WebTags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/Datadog.Trace.SourceGenerators.TagsListGenerator.TagListGenerator/WebTags.g.cs @@ -1,6 +1,8 @@ // #nullable enable +using Datadog.Trace.Processors; + namespace Datadog.Trace.Tagging { partial class WebTags @@ -69,52 +71,52 @@ public override void SetTag(string key, string value) return WebTagsProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (SpanKind != null) { count++; - WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind); + WriteTag(ref bytes, ref offset, SpanKindBytes, SpanKind, tagProcessors); } if (HttpMethod != null) { count++; - WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod); + WriteTag(ref bytes, ref offset, HttpMethodBytes, HttpMethod, tagProcessors); } if (HttpRequestHeadersHost != null) { count++; - WriteTag(ref bytes, ref offset, HttpRequestHeadersHostBytes, HttpRequestHeadersHost); + WriteTag(ref bytes, ref offset, HttpRequestHeadersHostBytes, HttpRequestHeadersHost, tagProcessors); } if (HttpUrl != null) { count++; - WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl); + WriteTag(ref bytes, ref offset, HttpUrlBytes, HttpUrl, tagProcessors); } if (PeerIp != null) { count++; - WriteTag(ref bytes, ref offset, PeerIpBytes, PeerIp); + WriteTag(ref bytes, ref offset, PeerIpBytes, PeerIp, tagProcessors); } if (Language != null) { count++; - WriteTag(ref bytes, ref offset, LanguageBytes, Language); + WriteTag(ref bytes, ref offset, LanguageBytes, Language, tagProcessors); } if (HttpStatusCode != null) { count++; - WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode); + WriteTag(ref bytes, ref offset, HttpStatusCodeBytes, HttpStatusCode, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) diff --git a/tracer/src/Datadog.Trace/ITraceContext.cs b/tracer/src/Datadog.Trace/ITraceContext.cs index 9bf489919..1541f6411 100644 --- a/tracer/src/Datadog.Trace/ITraceContext.cs +++ b/tracer/src/Datadog.Trace/ITraceContext.cs @@ -18,6 +18,8 @@ internal interface ITraceContext TraceTagCollection Tags { get; } + public IDatadogTracer Tracer { get; } + void AddSpan(Span span); void CloseSpan(Span span); diff --git a/tracer/src/Datadog.Trace/Processors/ITagProcessor.cs b/tracer/src/Datadog.Trace/Processors/ITagProcessor.cs new file mode 100644 index 000000000..23d5e9840 --- /dev/null +++ b/tracer/src/Datadog.Trace/Processors/ITagProcessor.cs @@ -0,0 +1,14 @@ +// +// 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. +// + +namespace Datadog.Trace.Processors +{ + internal interface ITagProcessor + { + void ProcessMeta(ref string key, ref string value); + + void ProcessMetric(ref string key, ref double value); + } +} diff --git a/tracer/src/Datadog.Trace/Processors/ITraceProcessor.cs b/tracer/src/Datadog.Trace/Processors/ITraceProcessor.cs new file mode 100644 index 000000000..02db033a3 --- /dev/null +++ b/tracer/src/Datadog.Trace/Processors/ITraceProcessor.cs @@ -0,0 +1,18 @@ +// +// 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. +// + +using System; + +namespace Datadog.Trace.Processors +{ + internal interface ITraceProcessor + { + ArraySegment Process(ArraySegment trace); + + Span Process(Span span); + + ITagProcessor GetTagProcessor(); + } +} diff --git a/tracer/src/Datadog.Trace/Processors/NormalizerTraceProcessor.cs b/tracer/src/Datadog.Trace/Processors/NormalizerTraceProcessor.cs new file mode 100644 index 000000000..2a9b066ac --- /dev/null +++ b/tracer/src/Datadog.Trace/Processors/NormalizerTraceProcessor.cs @@ -0,0 +1,201 @@ +// +// 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. +// + +using System; +using Datadog.Trace.ExtensionMethods; +using Datadog.Trace.Logging; +using Datadog.Trace.Tagging; + +namespace Datadog.Trace.Processors +{ + internal class NormalizerTraceProcessor : ITraceProcessor + { + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize.go + + // DefaultSpanName is the default name we assign a span if it's missing and we have no reasonable fallback + internal const string DefaultSpanName = "unnamed_operation"; + // DefaultServiceName is the default name we assign a service if it's missing and we have no reasonable fallback + internal const string DefaultServiceName = "unnamed-service"; + // MaxNameLen the maximum length a name can have + internal const int MaxNameLen = 100; + // MaxServiceLen the maximum length a service can have + internal const int MaxServiceLen = 100; + // MaxTypeLen the maximum length a span type can have + internal const int MaxTypeLen = 100; + + private static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(); + private static readonly DateTime Year2000Time = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc); + + public NormalizerTraceProcessor() + { + Log.Information("NormalizerTraceProcessor initialized."); + } + + public ArraySegment Process(ArraySegment trace) + { + /* + +----------+--------------------------------------------------------------------------------------------------------+ + | Property | Action | + +----------+--------------------------------------------------------------------------------------------------------+ + | Service | If empty, it gets set to a default. | + | Service | If too long, truncated at 100 characters. | + | Name | If empty, set it to “unnamed_operation”. | + | Name | If too long, truncated to 100 characters. | + | Resource | If empty, set to the same value as Name. | + | Duration | If smaller than 0, it is set to 0. | + | Duration | If larger than math.MaxInt64 - Start, it is set to 0. | + | Start | If smaller than Y2K, set to now - Duration or 0 if the result is negative. | + | Type | If too long, truncated to 100. | + | Meta | “http.status_code” key is deleted if it’s an invalid numeric value smaller than 100 or bigger than 600 | + +----------+--------------------------------------------------------------------------------------------------------+ + */ + + for (var i = trace.Offset; i < trace.Count + trace.Offset; i++) + { + trace.Array[i] = Process(trace.Array[i]); + } + + return trace; + } + + public Span Process(Span span) + { + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/agent/normalizer.go#L51-L63 + span.ServiceName = NormalizeService(span.ServiceName); + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/agent/normalizer.go#L76-L87 + span.OperationName = NormalizeName(span.OperationName); + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/agent/normalizer.go#L89-L93 + if (string.IsNullOrEmpty(span.ResourceName)) + { + Log.Debug("Fixing malformed trace. Resource is empty (reason:resource_empty), setting span.resource={name}: {span}", span.OperationName, span); + span.ResourceName = span.OperationName; + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/agent/normalizer.go#L95-L99 + // The validation for ParentID == TraceID == SpanID is not required + // This is done by the agent for zipkin support. + // This scenario is very unlikely to happen in an official tracer implementation. + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/agent/normalizer.go#L108-L112 + if (span.Duration < TimeSpan.Zero) + { + Log.Debug("Fixing malformed trace. Duration is invalid (reason:invalid_duration), setting span.duration=0: {span}", span.OperationName, span); + span.SetDuration(TimeSpan.Zero); + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/agent/normalizer.go#L113-L117 + if (span.Duration.ToNanoseconds() > long.MaxValue - span.StartTime.ToUnixTimeNanoseconds()) + { + Log.Debug("Fixing malformed trace. Duration is too large and causes overflow (reason:invalid_duration), setting span.duration=0: {span}", span.OperationName, span); + span.SetDuration(TimeSpan.Zero); + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/agent/normalizer.go#L118-L126 + if (span.StartTime < Year2000Time) + { + Log.Debug("Fixing malformed trace. Start date is invalid (reason:invalid_start_date), setting span.start=time.now(): {span}", span); + var now = span.Context.TraceContext.UtcNow; + var start = now - span.Duration; + if (start.ToUnixTimeNanoseconds() < 0) + { + start = now; + } + + span.SetStartTime(start); + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/agent/normalizer.go#L128-L132 + var type = span.Type; + if (TraceUtil.TruncateUTF8(ref type, MaxTypeLen)) + { + span.Type = type; + Log.Debug("Fixing malformed trace. Type is too long (reason:type_truncate), truncating span.type to length={maxServiceLen}: {span}", MaxTypeLen, span); + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/agent/normalizer.go#L133-L135 + if (span.Tags is CommonTags commonTags) + { + commonTags.Environment = TraceUtil.NormalizeTag(commonTags.Environment); + } + else + { + string env = span.GetTag("env"); + if (!string.IsNullOrEmpty(env)) + { + span.SetTag("env", TraceUtil.NormalizeTag(env)); + } + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/agent/normalizer.go#L136-L142 + if (span.Tags is IHasStatusCode statusCodeTags) + { + if (!TraceUtil.IsValidStatusCode(statusCodeTags.HttpStatusCode)) + { + Log.Debug("Fixing malformed trace. HTTP status code is invalid (reason:invalid_http_status_code), dropping invalid http.status_code={invalidStatusCode}: {span}", statusCodeTags.HttpStatusCode, span); + statusCodeTags.HttpStatusCode = string.Empty; + } + } + else + { + string httpStatusCode = span.GetTag(Tags.HttpStatusCode); + if (!string.IsNullOrEmpty(httpStatusCode) && !TraceUtil.IsValidStatusCode(httpStatusCode)) + { + Log.Debug("Fixing malformed trace. HTTP status code is invalid (reason:invalid_http_status_code), dropping invalid http.status_code={invalidStatusCode}: {span}", httpStatusCode, span); + span.SetTag(Tags.HttpStatusCode, null); + } + } + + return span; + } + + public ITagProcessor GetTagProcessor() + { + return null; + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize.go#L57-L73 + internal static string NormalizeService(string svc) + { + if (string.IsNullOrEmpty(svc)) + { + Log.Debug("Fixing malformed trace. Service is empty (reason:service_empty), setting span.service={serviceName}.", svc); + return DefaultServiceName; + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize.go#L59-L73 + if (TraceUtil.TruncateUTF8(ref svc, MaxServiceLen)) + { + Log.Debug("Fixing malformed trace. Service is too long (reason:service_truncate), truncating span.service to length={maxServiceLen}.", MaxServiceLen); + } + + return TraceUtil.NormalizeTag(svc); + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize.go#L39-L55 + internal static string NormalizeName(string name) + { + if (string.IsNullOrEmpty(name)) + { + Log.Debug("Fixing malformed trace. Name is empty (reason:span_name_empty), setting span.name={name}.", name); + return DefaultSpanName; + } + + if (TraceUtil.TruncateUTF8(ref name, MaxNameLen)) + { + Log.Debug("Fixing malformed trace. Name is too long (reason:span_name_truncate), truncating span.name to length={maxServiceLen}.", MaxNameLen); + } + + name = TraceUtil.NormalizeMetricName(name, MaxNameLen); + if (name is null) + { + name = DefaultSpanName; + } + + return name; + } + } +} diff --git a/tracer/src/Datadog.Trace/Processors/TraceUtil.cs b/tracer/src/Datadog.Trace/Processors/TraceUtil.cs new file mode 100644 index 000000000..1cd0689bf --- /dev/null +++ b/tracer/src/Datadog.Trace/Processors/TraceUtil.cs @@ -0,0 +1,288 @@ +// +// 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. +// + +using System.Collections.Generic; +using System.Runtime.CompilerServices; +using System.Text; +using Datadog.Trace.Util; + +namespace Datadog.Trace.Processors +{ + internal class TraceUtil + { + // MaxTagLength the maximum length a tag can have + private const int MaxTagLength = 200; + + private static readonly UTF8Encoding Encoding = new UTF8Encoding(false); + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/truncate.go#L36-L51 + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool TruncateUTF8(ref string value, int limit) + { + if (string.IsNullOrEmpty(value) || Encoding.GetByteCount(value) <= limit) + { + return false; + } + + var charArray = new char[1]; + var length = 0; + for (var i = 0; i < value.Length - 1; i++) + { + charArray[0] = value[i]; + length += Encoding.GetByteCount(charArray, 0, 1); + if (length > limit) + { + value = value.Substring(0, i); + return true; + } + } + + return false; + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/agent/normalizer.go#L214-L219 + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool IsValidStatusCode(string statusCode) + { + if (int.TryParse(statusCode, out int code)) + { + return 100 <= code && code < 600; + } + + return false; + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize.go#L98-L209 + public static string NormalizeTag(string value) + { + if (string.IsNullOrEmpty(value) || Encoding.GetByteCount(value) == 0) + { + return string.Empty; + } + + char[] charArray = null; + char[] upArray = null; + char[] lowArray = null; + int trim = 0; + List cuts = null; + int chars = 0; + int jump = 0; + int i = 0; + + for (; i < value.Length; i++) + { + var c = value[i]; + jump = 1; + + if ((c >= 'a' && c <= 'z') || c == ':') + { + chars++; + goto end; + } + + if (c >= 'A' && c <= 'Z') + { + if (charArray is null) + { + charArray = value.ToCharArray(); + } + + charArray[i] = (char)(((int)value[i]) + ((int)'a' - (int)'A')); + chars++; + goto end; + } + + if (char.IsUpper(c)) + { + if (upArray is null) + { + upArray = new char[1]; + } + + if (lowArray is null) + { + lowArray = new char[1]; + } + + upArray[0] = c; + lowArray[0] = char.ToLowerInvariant(c); + if (Encoding.GetByteCount(upArray) == Encoding.GetByteCount(lowArray)) + { + if (charArray is null) + { + charArray = value.ToCharArray(); + } + + charArray[i] = lowArray[0]; + c = lowArray[0]; + } + } + + if (char.IsLetter(c)) + { + chars++; + } + else if (chars == 0) + { + trim = i + jump; + goto end; + } + else if (char.IsDigit(c) || c == '.' || c == '/' || c == '-') + { + chars++; + } + else + { + if (cuts is null) + { + cuts = new List(); + } + + var n = cuts.Count; + if (n > 0 && cuts[n - 1][1] >= i) + { + cuts[n - 1][1] += jump; + } + else + { + cuts.Add(new int[] { i, i + jump }); + } + } + + end: + if (i + jump >= 2 * MaxTagLength) + { + i++; + break; + } + + if (chars >= MaxTagLength) + { + i++; + break; + } + } + + i--; + + if (cuts is null || cuts.Count == 0) + { + if (charArray is null) + { + return value.Substring(trim, i + jump - trim); + } + + return new string(charArray, trim, i + jump - trim); + } + + charArray ??= value.ToCharArray(); + var segment = new ArraySlice(charArray, trim, i + jump - trim); + int delta = trim; + foreach (var cut in cuts) + { + int start = cut[0] - delta; + int end = cut[1] - delta; + + if (end >= segment.Count) + { + segment = segment.Slice(0, start); + break; + } + + segment[start] = '_'; + if (end - start == 1) + { + continue; + } + + segment.Slice(end).CopyTo(segment.Slice(start + 1)); + segment = segment.Slice(0, segment.Count - (end - start) + 1); + delta += cut[1] - cut[0] - 1; + } + + return new string(segment.Array, segment.Offset, segment.Count); + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize.go#L213-L216 + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool IsAlpha(char c) + { + return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize.go#L218-L221 + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool IsAlphaNumeric(char c) + { + return IsAlpha(c) || (c >= '0' && c <= '9'); + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize.go#L223-L274 + public static string NormalizeMetricName(string name, int limit) + { + if (name == string.Empty || Encoding.GetByteCount(name) > limit) + { + return null; + } + + var sb = StringBuilderCache.Acquire(name.Length); + int i = 0; + + // skip non-alphabetic characters + for (; i < name.Length && !IsAlpha(name[i]); i++) { } + + // if there were no alphabetic characters it wasn't valid + if (i == name.Length) + { + return null; + } + + for (; i < name.Length; i++) + { + char c = name[i]; + + if (IsAlphaNumeric(c)) + { + sb.Append(c); + } + else if (c == '.') + { + // we skipped all non-alpha chars up front so we have seen at least one + + // overwrite underscores that happen before periods + if (sb[sb.Length - 1] == '_') + { + sb[sb.Length - 1] = '.'; + } + else + { + sb.Append('.'); + } + } + else + { + // we skipped all non-alpha chars up front so we have seen at least one + + // no double underscores, no underscores after periods + switch (sb[sb.Length - 1]) + { + case '.': + case '_': + default: + sb.Append('_'); + break; + } + } + } + + if (sb[sb.Length - 1] == '_') + { + sb.Remove(sb.Length - 1, 1); + } + + return StringBuilderCache.GetStringAndRelease(sb); + } + } +} diff --git a/tracer/src/Datadog.Trace/Processors/TruncatorTagsProcessor.cs b/tracer/src/Datadog.Trace/Processors/TruncatorTagsProcessor.cs new file mode 100644 index 000000000..108d8b43a --- /dev/null +++ b/tracer/src/Datadog.Trace/Processors/TruncatorTagsProcessor.cs @@ -0,0 +1,49 @@ +// +// 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. +// + +using Datadog.Trace.Logging; + +namespace Datadog.Trace.Processors +{ + internal class TruncatorTagsProcessor : ITagProcessor + { + // MaxMetaKeyLen the maximum length of metadata key + internal const int MaxMetaKeyLen = 200; + + // MaxMetaValLen the maximum length of metadata value + internal const int MaxMetaValLen = 25000; + + // MaxMetricsKeyLen the maximum length of a metric name key + internal const int MaxMetricsKeyLen = MaxMetaKeyLen; + + private static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(); + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/agent/truncator.go#L26-L44 + public void ProcessMeta(ref string key, ref string value) + { + if (TraceUtil.TruncateUTF8(ref key, MaxMetaKeyLen)) + { + key += "..."; + Log.Debug("span.truncate: truncating `Meta` key (max {maxMetaKeyLen} chars): {key}", MaxMetaKeyLen, key); + } + + if (TraceUtil.TruncateUTF8(ref value, MaxMetaValLen)) + { + value += "..."; + Log.Debug("span.truncate: truncating `Meta` value (max {maxMetaValLen} chars): {value}", MaxMetaValLen, value); + } + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/agent/truncator.go#L45-L53 + public void ProcessMetric(ref string key, ref double value) + { + if (TraceUtil.TruncateUTF8(ref key, MaxMetricsKeyLen)) + { + key += "..."; + Log.Debug("span.truncate: truncating `Metrics` key (max {maxMetricsKeyLen} chars): {key}", MaxMetricsKeyLen, key); + } + } + } +} diff --git a/tracer/src/Datadog.Trace/Processors/TruncatorTraceProcessor.cs b/tracer/src/Datadog.Trace/Processors/TruncatorTraceProcessor.cs new file mode 100644 index 000000000..33278871d --- /dev/null +++ b/tracer/src/Datadog.Trace/Processors/TruncatorTraceProcessor.cs @@ -0,0 +1,61 @@ +// +// 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. +// + +using System; +using Datadog.Trace.Logging; + +namespace Datadog.Trace.Processors +{ + internal class TruncatorTraceProcessor : ITraceProcessor + { + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/agent/truncator.go + + // Values from: https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/truncate.go#L21-L28 + // MaxResourceLen the maximum length a span resource can have + internal const int MaxResourceLen = 5000; + + private static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(); + private readonly TruncatorTagsProcessor truncatorTagsProcessor = new(); + + public TruncatorTraceProcessor() + { + Log.Information("TruncatorTraceProcessor initialized."); + } + + public ArraySegment Process(ArraySegment trace) + { + for (var i = trace.Offset; i < trace.Count + trace.Offset; i++) + { + trace.Array[i] = Process(trace.Array[i]); + } + + return trace; + } + + public Span Process(Span span) + { + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/agent/truncator.go#L17-L21 + span.ResourceName = TruncateResource(span.ResourceName); + + return span; + } + + public ITagProcessor GetTagProcessor() + { + return truncatorTagsProcessor; + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/truncate.go#L30-L34 + internal static string TruncateResource(string r) + { + if (TraceUtil.TruncateUTF8(ref r, MaxResourceLen)) + { + Log.Debug("span.truncate: truncated `Resource` (max {maxResourceLen} chars): {resource}", MaxResourceLen, r); + } + + return r; + } + } +} diff --git a/tracer/src/Datadog.Trace/Span.cs b/tracer/src/Datadog.Trace/Span.cs index f46f870d6..b974e673b 100644 --- a/tracer/src/Datadog.Trace/Span.cs +++ b/tracer/src/Datadog.Trace/Span.cs @@ -402,5 +402,15 @@ internal void ResetStartTime() { StartTime = Context.TraceContext.UtcNow; } + + internal void SetStartTime(DateTimeOffset startTime) + { + StartTime = startTime; + } + + internal void SetDuration(TimeSpan duration) + { + Duration = duration; + } } } diff --git a/tracer/src/Datadog.Trace/Tagging/ITags.cs b/tracer/src/Datadog.Trace/Tagging/ITags.cs index e6c6d2dea..a4d84b853 100644 --- a/tracer/src/Datadog.Trace/Tagging/ITags.cs +++ b/tracer/src/Datadog.Trace/Tagging/ITags.cs @@ -6,6 +6,7 @@ // Modified by Splunk Inc. using System.Collections.Generic; +using Datadog.Trace.Processors; namespace Datadog.Trace.Tagging { @@ -23,6 +24,6 @@ internal interface ITags void SetMetric(string key, double? value); - int SerializeTo(ref byte[] buffer, int offset, Span span); + int SerializeTo(ref byte[] buffer, int offset, Span span, ITagProcessor[] tagProcessors); } } diff --git a/tracer/src/Datadog.Trace/Tagging/TagsList.cs b/tracer/src/Datadog.Trace/Tagging/TagsList.cs index b77c3e81a..27e9e4c47 100644 --- a/tracer/src/Datadog.Trace/Tagging/TagsList.cs +++ b/tracer/src/Datadog.Trace/Tagging/TagsList.cs @@ -10,6 +10,7 @@ using System.Runtime.CompilerServices; using System.Text; using System.Threading; +using Datadog.Trace.Processors; using Datadog.Trace.Util; using Datadog.Trace.Vendors.MessagePack; @@ -30,7 +31,7 @@ internal abstract class TagsList : ITags public List> Metrics => Volatile.Read(ref _metrics); - protected virtual IList> GetCustomTags() => Volatile.Read(ref _tags); + protected virtual List> GetCustomTags() => Volatile.Read(ref _tags); public List> GetAllTags() { @@ -69,20 +70,24 @@ public List> GetAllTags() protected virtual IProperty[] GetAdditionalTags() => TagsListProperties; - public virtual string GetTag(string key) => GetTagFromDictionary(key); + // . - public virtual double? GetMetric(string key) => GetMetricFromDictionary(key); + public virtual string GetTag(string key) => GetTagFromDictionary(key); public virtual void SetTag(string key, string value) => SetTagInDictionary(key, value); + public virtual double? GetMetric(string key) => GetMetricFromDictionary(key); + public virtual void SetMetric(string key, double? value) => SetMetricInDictionary(key, value); - public int SerializeTo(ref byte[] bytes, int offset, Span span) + // . + + public int SerializeTo(ref byte[] bytes, int offset, Span span, ITagProcessor[] tagProcessors) { int originalOffset = offset; - offset += WriteTags(ref bytes, offset, span); - offset += WriteMetrics(ref bytes, offset, span); + offset += WriteTags(ref bytes, offset, span, tagProcessors); + offset += WriteMetrics(ref bytes, offset, span, tagProcessors); return offset - originalOffset; } @@ -123,35 +128,40 @@ public override string ToString() return StringBuilderCache.GetStringAndRelease(sb); } + // Tags + [MethodImpl(MethodImplOptions.AggressiveInlining)] - protected static void WriteTag(ref byte[] bytes, ref int offset, string key, string value) + protected void WriteTag(ref byte[] bytes, ref int offset, string key, string value, ITagProcessor[] tagProcessors) { + if (tagProcessors is not null) + { + for (var i = 0; i < tagProcessors.Length; i++) + { + tagProcessors[i]?.ProcessMeta(ref key, ref value); + } + } + offset += MessagePackBinary.WriteString(ref bytes, offset, key); offset += MessagePackBinary.WriteString(ref bytes, offset, value); } [MethodImpl(MethodImplOptions.AggressiveInlining)] - protected static void WriteMetric(ref byte[] bytes, ref int offset, string key, double value) + protected void WriteTag(ref byte[] bytes, ref int offset, byte[] keyBytes, string value, ITagProcessor[] tagProcessors) { - offset += MessagePackBinary.WriteString(ref bytes, offset, key); - offset += MessagePackBinary.WriteDouble(ref bytes, offset, value); - } + if (tagProcessors is not null) + { + string key = null; + for (var i = 0; i < tagProcessors.Length; i++) + { + tagProcessors[i]?.ProcessMeta(ref key, ref value); + } + } - [MethodImpl(MethodImplOptions.AggressiveInlining)] - protected static void WriteTag(ref byte[] bytes, ref int offset, byte[] keyBytes, string value) - { offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, keyBytes); offset += MessagePackBinary.WriteString(ref bytes, offset, value); } - [MethodImpl(MethodImplOptions.AggressiveInlining)] - protected static void WriteMetric(ref byte[] bytes, ref int offset, byte[] keyBytes, double value) - { - offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, keyBytes); - offset += MessagePackBinary.WriteDouble(ref bytes, offset, value); - } - - private int WriteTags(ref byte[] bytes, int offset, Span span) + private int WriteTags(ref byte[] bytes, int offset, Span span, ITagProcessor[] tagProcessors) { int originalOffset = offset; @@ -164,16 +174,16 @@ private int WriteTags(ref byte[] bytes, int offset, Span span) offset += MessagePackBinary.WriteMapHeaderForceMap32Block(ref bytes, offset, 0); // write "custom" span-level tags (from list of KVPs) - count += WriteSpanTags(ref bytes, ref offset, GetCustomTags()); + count += WriteSpanTags(ref bytes, ref offset, GetCustomTags(), tagProcessors); // write "well-known" span-level tags (from properties) - count += WriteAdditionalTags(ref bytes, ref offset); + count += WriteAdditionalTags(ref bytes, ref offset, tagProcessors); if (span.IsRootSpan) { // write trace-level tags var traceTags = span.Context.TraceContext?.Tags; - count += WriteTraceTags(ref bytes, ref offset, traceTags); + count += WriteTraceTags(ref bytes, ref offset, traceTags, tagProcessors); } if (span.IsTopLevel) @@ -200,7 +210,7 @@ private int WriteTags(ref byte[] bytes, int offset, Span span) return offset - originalOffset; } - private int WriteSpanTags(ref byte[] bytes, ref int offset, IList> tags) + private int WriteSpanTags(ref byte[] bytes, ref int offset, List> tags, ITagProcessor[] tagProcessors) { int count = 0; @@ -209,10 +219,10 @@ private int WriteSpanTags(ref byte[] bytes, ref int offset, IList foreach (var tag in tags) { - WriteTag(ref bytes, ref offset, tag.Key, tag.Value); + WriteTag(ref bytes, ref offset, tag.Key, tag.Value, tagProcessors); } } } @@ -241,19 +251,39 @@ private int WriteTraceTags(ref byte[] bytes, ref int offset, TraceTagCollection return count; } - protected virtual int WriteAdditionalTags(ref byte[] bytes, ref int offset) => 0; - - protected virtual int WriteAdditionalMetrics(ref byte[] bytes, ref int offset) => 0; - - protected virtual void WriteAdditionalTags(StringBuilder builder) + // Metrics + [MethodImpl(MethodImplOptions.AggressiveInlining)] + protected void WriteMetric(ref byte[] bytes, ref int offset, string key, double value, ITagProcessor[] tagProcessors) { + if (tagProcessors is not null) + { + for (var i = 0; i < tagProcessors.Length; i++) + { + tagProcessors[i]?.ProcessMetric(ref key, ref value); + } + } + + offset += MessagePackBinary.WriteString(ref bytes, offset, key); + offset += MessagePackBinary.WriteDouble(ref bytes, offset, value); } - protected virtual void WriteAdditionalMetrics(StringBuilder builder) + [MethodImpl(MethodImplOptions.AggressiveInlining)] + protected void WriteMetric(ref byte[] bytes, ref int offset, byte[] keyBytes, double value, ITagProcessor[] tagProcessors) { + if (tagProcessors is not null) + { + string key = null; + for (var i = 0; i < tagProcessors.Length; i++) + { + tagProcessors[i]?.ProcessMetric(ref key, ref value); + } + } + + offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, keyBytes); + offset += MessagePackBinary.WriteDouble(ref bytes, offset, value); } - private int WriteMetrics(ref byte[] bytes, int offset, Span span) + private int WriteMetrics(ref byte[] bytes, int offset, Span span, ITagProcessor[] tagProcessors) { int originalOffset = offset; @@ -266,26 +296,25 @@ private int WriteMetrics(ref byte[] bytes, int offset, Span span) offset += MessagePackBinary.WriteMapHeaderForceMap32Block(ref bytes, offset, 0); var metrics = Metrics; - if (metrics != null) { lock (metrics) { count += metrics.Count; - - foreach (var pair in metrics) + for (var i = 0; i < metrics.Count; i++) { - WriteMetric(ref bytes, ref offset, pair.Key, pair.Value); + var metric = metrics[i]; + WriteMetric(ref bytes, ref offset, metric.Key, metric.Value, tagProcessors); } } } - count += WriteAdditionalMetrics(ref bytes, ref offset); + count += WriteAdditionalMetrics(ref bytes, ref offset, tagProcessors); if (span.IsTopLevel) { count++; - WriteMetric(ref bytes, ref offset, Trace.Metrics.TopLevelSpan, 1.0); + WriteMetric(ref bytes, ref offset, Trace.Metrics.TopLevelSpan, 1.0, tagProcessors); } if (count > 0) @@ -297,6 +326,20 @@ private int WriteMetrics(ref byte[] bytes, int offset, Span span) return offset - originalOffset; } + // . + + protected virtual int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) => 0; + + protected virtual int WriteAdditionalMetrics(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) => 0; + + protected virtual void WriteAdditionalTags(StringBuilder builder) + { + } + + protected virtual void WriteAdditionalMetrics(StringBuilder builder) + { + } + private string GetTagFromDictionary(string key) { var tags = GetCustomTags(); diff --git a/tracer/src/Datadog.Trace/Tracer.cs b/tracer/src/Datadog.Trace/Tracer.cs index 3774a8399..b720728ab 100644 --- a/tracer/src/Datadog.Trace/Tracer.cs +++ b/tracer/src/Datadog.Trace/Tracer.cs @@ -40,7 +40,7 @@ public class Tracer : ITracer, IDatadogTracer, IDatadogOpenTracingTracer private static int _liveTracerCount; private static Tracer _instance; - private static bool _globalInstanceInitialized; + private static volatile bool _globalInstanceInitialized; private readonly TracerManager _tracerManager; @@ -339,7 +339,7 @@ void IDatadogTracer.Write(ArraySegment trace) { if (Settings.TraceEnabled || AzureAppServices.Metadata.CustomTracingEnabled) { - TracerManager.AgentWriter.WriteTrace(trace); + TracerManager.WriteTrace(trace); } } diff --git a/tracer/src/Datadog.Trace/TracerManager.cs b/tracer/src/Datadog.Trace/TracerManager.cs index ea42157ba..540320baa 100644 --- a/tracer/src/Datadog.Trace/TracerManager.cs +++ b/tracer/src/Datadog.Trace/TracerManager.cs @@ -8,6 +8,7 @@ using System; using System.Collections.Generic; using System.IO; +using System.Runtime.CompilerServices; using System.Threading; using System.Threading.Tasks; using Datadog.Trace.Agent; @@ -17,6 +18,7 @@ using Datadog.Trace.Logging; using Datadog.Trace.Logging.DirectSubmission; using Datadog.Trace.PlatformHelpers; +using Datadog.Trace.Processors; using Datadog.Trace.Propagation; using Datadog.Trace.RuntimeMetrics; using Datadog.Trace.Sampling; @@ -56,7 +58,8 @@ public TracerManager( ITraceIdConvention traceIdConvention, DirectLogSubmissionManager directLogSubmission, ITelemetryController telemetry, - string defaultServiceName) + string defaultServiceName, + ITraceProcessor[] traceProcessors = null) { Settings = settings; AgentWriter = agentWriter; @@ -69,6 +72,18 @@ public TracerManager( TraceIdConvention = traceIdConvention; DirectLogSubmission = directLogSubmission; Telemetry = telemetry; + TraceProcessors = traceProcessors ?? Array.Empty(); + + var lstTagProcessors = new List(TraceProcessors.Length); + foreach (var traceProcessor in TraceProcessors) + { + if (traceProcessor?.GetTagProcessor() is { } tagProcessor) + { + lstTagProcessors.Add(tagProcessor); + } + } + + TagProcessors = lstTagProcessors.ToArray(); } /// @@ -122,6 +137,10 @@ public static TracerManager Instance public IDogStatsd Statsd { get; } + public ITraceProcessor[] TraceProcessors { get; } + + public ITagProcessor[] TagProcessors { get; } + public ITelemetryController Telemetry { get; } private RuntimeMetricsWriter RuntimeMetrics { get; } @@ -454,5 +473,29 @@ private static void HeartbeatCallback(object state) // send traces to the Agent _instance?.Statsd?.Gauge(TracerMetricNames.Health.Heartbeat, Tracer.LiveTracerCount); } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void WriteTrace(ArraySegment trace) + { + foreach (var processor in TraceProcessors) + { + if (processor is not null) + { + try + { + trace = processor.Process(trace); + } + catch (Exception e) + { + Log.Error(e, e.Message); + } + } + } + + if (trace.Count > 0) + { + AgentWriter.WriteTrace(trace); + } + } } } diff --git a/tracer/src/Datadog.Trace/Util/ArraySlice.cs b/tracer/src/Datadog.Trace/Util/ArraySlice.cs new file mode 100644 index 000000000..70a862511 --- /dev/null +++ b/tracer/src/Datadog.Trace/Util/ArraySlice.cs @@ -0,0 +1,72 @@ +// +// 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. +// + +using System.Runtime.CompilerServices; + +namespace Datadog.Trace.Util +{ + /// + /// Array slice. + /// Similar to ArraySegment but with write support over the index. + /// Also as Span`1 it's a readonly ref struct. + /// + /// Type of the array + internal readonly ref struct ArraySlice + { + public readonly T[] Array; + public readonly int Offset; + public readonly int Count; + + public ArraySlice(T[] array, int offset, int count) + { + Array = array; + Offset = offset; + Count = count; + } + + public T this[int index] + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return Array[Offset + index]; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set + { + Array[Offset + index] = value; + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public ArraySlice Slice(int start) + { + if (Count - start < 0) + { + ThrowHelper.ThrowArgumentException("Start value is greater than the total number of elements", nameof(start)); + } + + return new ArraySlice(Array, Offset + start, Count - start); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public ArraySlice Slice(int start, int count) + { + if (count > Count - start) + { + ThrowHelper.ThrowArgumentOutOfRangeException(nameof(count)); + } + + return new ArraySlice(Array, Offset + start, count); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void CopyTo(ArraySlice other) + { + System.Array.Copy(Array, Offset, other.Array, other.Offset, Count); + } + } +} diff --git a/tracer/src/Datadog.Trace/Util/ThrowHelper.cs b/tracer/src/Datadog.Trace/Util/ThrowHelper.cs index e244eb80a..43f232a92 100644 --- a/tracer/src/Datadog.Trace/Util/ThrowHelper.cs +++ b/tracer/src/Datadog.Trace/Util/ThrowHelper.cs @@ -67,5 +67,10 @@ internal class ThrowHelper [DebuggerHidden] [DoesNotReturn] internal static void ThrowKeyNotFoundException(string message) => throw new KeyNotFoundException(message); + + [MethodImpl(MethodImplOptions.NoInlining)] + [DebuggerHidden] + [DoesNotReturn] + internal static void ThrowNullReferenceException(string message) => throw new NullReferenceException(message); } } diff --git a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/Agent/CIAgentWriterTests.cs b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/Agent/CIAgentWriterTests.cs new file mode 100644 index 000000000..7de2cc764 --- /dev/null +++ b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/Agent/CIAgentWriterTests.cs @@ -0,0 +1,73 @@ +// +// 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. +// + +// Modified by Splunk Inc. + +using System; +using System.Linq; +using System.Threading.Tasks; +using Datadog.Trace.Agent; +using Datadog.Trace.Agent.MessagePack; +using Datadog.Trace.Ci.Agent; +using Datadog.Trace.Ci.Agent.MessagePack; +using Moq; +using Xunit; + +namespace Datadog.Trace.ClrProfiler.IntegrationTests.CI.Agent +{ + public class CIAgentWriterTests + { + private readonly CIAgentWriter _ciAgentWriter; + private readonly Configuration.ImmutableTracerSettings _settings; + private readonly Mock _api; + + public CIAgentWriterTests() + { + var tracer = new Mock(); + tracer.Setup(x => x.DefaultServiceName).Returns("Default"); + _settings = new Configuration.ImmutableTracerSettings(Ci.Configuration.CIVisibilitySettings.FromDefaultSources().TracerSettings); + + _api = new Mock(); + _ciAgentWriter = new CIAgentWriter(_api.Object); + } + + [Fact] + public async Task WriteTrace_2Traces_SendToApi() + { + var trace = new[] { new Span(new SpanContext(TraceId.CreateFromUlong(1), 1), DateTimeOffset.UtcNow) }; + var expectedData1 = Vendors.MessagePack.MessagePackSerializer.Serialize(trace, SpanFormatterResolver.Instance); + + _ciAgentWriter.WriteTrace(new ArraySegment(trace)); + await _ciAgentWriter.FlushTracesAsync(); // Force a flush to make sure the trace is written to the API + + _api.Verify(x => x.SendTracesAsync(It.Is>(y => Equals(y, expectedData1)), It.Is(i => i == 1)), Times.Once); + + _api.Invocations.Clear(); + + trace = new[] { new Span(new SpanContext(TraceId.CreateFromUlong(2), 2), DateTimeOffset.UtcNow) }; + var expectedData2 = Vendors.MessagePack.MessagePackSerializer.Serialize(trace, SpanFormatterResolver.Instance); + + _ciAgentWriter.WriteTrace(new ArraySegment(trace)); + await _ciAgentWriter.FlushTracesAsync(); // Force a flush to make sure the trace is written to the API + + _api.Verify(x => x.SendTracesAsync(It.Is>(y => Equals(y, expectedData2)), It.Is(i => i == 1)), Times.Once); + + await _ciAgentWriter.FlushAndCloseAsync(); + } + + [Fact] + public async Task FlushTwice() + { + var w = new CIAgentWriter(_api.Object); + await w.FlushAndCloseAsync(); + await w.FlushAndCloseAsync(); + } + + private static bool Equals(ArraySegment data, byte[] expectedData) + { + return data.Array.Skip(data.Offset).Take(data.Count).Skip(SpanBuffer.HeaderSize).SequenceEqual(expectedData); + } + } +} diff --git a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/Agent/CIAgentlessEventBufferTests.cs b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/Agent/CIAgentlessEventBufferTests.cs new file mode 100644 index 000000000..a23374b13 --- /dev/null +++ b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/Agent/CIAgentlessEventBufferTests.cs @@ -0,0 +1,123 @@ +// +// 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. +// + +// Modified by Splunk Inc. + +using System; +using System.Collections.Generic; +using System.Linq; +using Datadog.Trace.Ci.EventModel; +using Xunit; + +namespace Datadog.Trace.ClrProfiler.IntegrationTests.CI.Agent +{ + public class CIAgentlessEventBufferTests + { + [Theory] + [InlineData(5, 5, false)] + [InlineData(50, 50, true)] + public void SerializeSpans(int traceCount, int spanCount, bool resizeExpected) + { + var buffer = new Ci.Agent.Payloads.EventsBuffer(10 * 1024 * 1024, Ci.Agent.MessagePack.CIFormatterResolver.Instance); + + var events = new List(); + + for (int i = 0; i < traceCount; i++) + { + for (int j = 0; j < spanCount; j++) + { + events.Add(new SpanEvent(new Span(new SpanContext(TraceId.CreateFromInt(i), (ulong)i), DateTimeOffset.UtcNow))); + } + } + + foreach (var @event in events) + { + Assert.True(buffer.TryWrite(@event)); + } + + buffer.Lock(); + + Assert.Equal(traceCount * spanCount, buffer.Count); + + var content = buffer.Data; + var resized = content.Count > Ci.Agent.Payloads.EventsBuffer.InitialBufferSize; + + // We want to test the case where the buffer is big enough from the start, and the case where it has to be resized + // Make sure that the span/trace count assumptions are correct to test the scenario + Assert.True(resizeExpected == resized, $"Total serialized size was {content.Count}"); + } + + [Fact] + public void Overflow() + { + var buffer = new Ci.Agent.Payloads.EventsBuffer(10, Ci.Agent.MessagePack.CIFormatterResolver.Instance); + + Assert.False(buffer.IsFull); + + var spanEvent = new SpanEvent(new Span(new SpanContext(TraceId.CreateFromUlong(1), 1), DateTimeOffset.UtcNow)); + + var result = buffer.TryWrite(spanEvent); + + Assert.False(result); + Assert.Equal(0, buffer.Count); + Assert.True(buffer.IsFull); + + buffer.Lock(); + + var innerBuffer = buffer.Data; + + var actualBuffer = innerBuffer.Skip(innerBuffer.Offset).Take(innerBuffer.Count).ToArray(); + + Assert.True(actualBuffer.Skip(Ci.Agent.Payloads.EventsBuffer.HeaderSize).All(b => b == 0x0), "No data should have been written to the buffer"); + + buffer.Clear(); + + Assert.False(buffer.IsFull); + } + + [Fact] + public void LockingBuffer() + { + var buffer = new Ci.Agent.Payloads.EventsBuffer(10 * 1024 * 1024, Ci.Agent.MessagePack.CIFormatterResolver.Instance); + var spanEvent = new SpanEvent(new Span(new SpanContext(TraceId.CreateFromUlong(1), 1), DateTimeOffset.UtcNow)); + + Assert.True(buffer.TryWrite(spanEvent)); + + buffer.Lock(); + + Assert.False(buffer.TryWrite(spanEvent)); + + buffer.Clear(); + + Assert.True(buffer.TryWrite(spanEvent)); + } + + [Fact] + public void ClearingBuffer() + { + var buffer = new Ci.Agent.Payloads.EventsBuffer(10 * 1024 * 1024, Ci.Agent.MessagePack.CIFormatterResolver.Instance); + var spanEvent = new SpanEvent(new Span(new SpanContext(TraceId.CreateFromUlong(1), 1), DateTimeOffset.UtcNow)); + + Assert.True(buffer.TryWrite(spanEvent)); + + Assert.Equal(1, buffer.Count); + + buffer.Clear(); + + Assert.Equal(0, buffer.Count); + + buffer.Lock(); + + var innerBuffer = buffer.Data; + Assert.Equal(Ci.Agent.Payloads.EventsBuffer.HeaderSize, innerBuffer.Count); + } + + [Fact] + public void InvalidSize() + { + Assert.Throws(() => new Ci.Agent.Payloads.EventsBuffer(4, Ci.Agent.MessagePack.CIFormatterResolver.Instance)); + } + } +} diff --git a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/Agent/CIAgentlessWriterTests.cs b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/Agent/CIAgentlessWriterTests.cs new file mode 100644 index 000000000..f24cba101 --- /dev/null +++ b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/Agent/CIAgentlessWriterTests.cs @@ -0,0 +1,141 @@ +// +// 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. +// + +// Modified by Splunk Inc. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using Datadog.Trace.Ci.Agent; +using Datadog.Trace.Ci.EventModel; +using Datadog.Trace.Ci.Tags; +using Datadog.Trace.Vendors.MessagePack; +using Moq; +using Xunit; + +namespace Datadog.Trace.ClrProfiler.IntegrationTests.CI.Agent +{ + public class CIAgentlessWriterTests + { + private readonly Configuration.ImmutableTracerSettings _settings; + + public CIAgentlessWriterTests() + { + _settings = new Configuration.ImmutableTracerSettings(Ci.Configuration.CIVisibilitySettings.FromDefaultSources().TracerSettings); + } + + [Fact] + public async Task AgentlessTestEventTest() + { + var sender = new Mock(); + var agentlessWriter = new CIAgentlessWriter(_settings, null, sender.Object); + + var span = new Span(new SpanContext(TraceId.CreateFromUlong(1), 1), DateTimeOffset.UtcNow); + span.Type = SpanTypes.Test; + span.SetTag(TestTags.Type, TestTags.TypeTest); + + var expectedPayload = new Ci.Agent.Payloads.CITestCyclePayload(); + expectedPayload.TryProcessEvent(new TestEvent(span)); + var expectedBytes = expectedPayload.ToArray(); + + byte[] finalPayload = null; + sender.Setup(x => x.SendPayloadAsync(It.IsAny())) + .Returns(payload => + { + finalPayload = payload.ToArray(); + return Task.CompletedTask; + }); + + var trace = new[] { span }; + agentlessWriter.WriteTrace(new ArraySegment(trace)); + await agentlessWriter.FlushTracesAsync(); // Force a flush to make sure the trace is written to the API + + Assert.True(finalPayload.SequenceEqual(expectedBytes)); + } + + [Fact] + public async Task SlowSenderTest() + { + var flushTcs = new TaskCompletionSource(); + + var sender = new Mock(); + var agentlessWriter = new CIAgentlessWriter(_settings, null, sender.Object); + var lstPayloads = new List(); + + sender.Setup(x => x.SendPayloadAsync(It.IsAny())) + .Returns(payload => + { + lstPayloads.Add(payload.ToArray()); + return flushTcs.Task; + }); + + var span = new Span(new SpanContext(TraceId.CreateFromUlong(1), 1), DateTimeOffset.UtcNow); + var expectedPayload = new Ci.Agent.Payloads.CITestCyclePayload(); + expectedPayload.TryProcessEvent(new SpanEvent(span)); + expectedPayload.TryProcessEvent(new SpanEvent(span)); + expectedPayload.TryProcessEvent(new SpanEvent(span)); + var expectedBytes = expectedPayload.ToArray(); + + agentlessWriter.WriteEvent(new SpanEvent(span)); + agentlessWriter.WriteEvent(new SpanEvent(span)); + agentlessWriter.WriteEvent(new SpanEvent(span)); + + var firstFlush = agentlessWriter.FlushTracesAsync(); + + agentlessWriter.WriteEvent(new SpanEvent(span)); + agentlessWriter.WriteEvent(new SpanEvent(span)); + agentlessWriter.WriteEvent(new SpanEvent(span)); + + var secondFlush = agentlessWriter.FlushTracesAsync(); + flushTcs.TrySetResult(true); + + agentlessWriter.WriteEvent(new SpanEvent(span)); + agentlessWriter.WriteEvent(new SpanEvent(span)); + agentlessWriter.WriteEvent(new SpanEvent(span)); + + var thirdFlush = agentlessWriter.FlushTracesAsync(); + + await Task.WhenAll(firstFlush, secondFlush, thirdFlush); + + // We expect 3 batches. + Assert.Equal(3, lstPayloads.Count); + + foreach (var payloadBytes in lstPayloads) + { + Assert.True(payloadBytes.SequenceEqual(expectedBytes)); + } + } + + [Fact] + public void EventsBufferTest() + { + int headerSize = Ci.Agent.Payloads.EventsBuffer.HeaderSize; + + var span = new Span(new SpanContext(TraceId.CreateFromUlong(1), 1), DateTimeOffset.UtcNow); + var spanEvent = new SpanEvent(span); + var individualType = MessagePackSerializer.Serialize(spanEvent, Ci.Agent.MessagePack.CIFormatterResolver.Instance); + + int bufferSize = 256; + int maxBufferSize = (int)(4.5 * 1024 * 1024); + + while (bufferSize < maxBufferSize) + { + var eventBuffer = new Ci.Agent.Payloads.EventsBuffer(bufferSize, Ci.Agent.MessagePack.CIFormatterResolver.Instance); + while (eventBuffer.TryWrite(spanEvent)) + { + // . + } + + // The number of items in the events should be the same as the num calculated + // without decimals (items that doesn't fit doesn't get added) + var numItemsTrunc = (bufferSize - headerSize) / individualType.Length; + Assert.Equal(numItemsTrunc, eventBuffer.Count); + + bufferSize *= 2; + } + } + } +} diff --git a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/MsTestV2Tests.cs b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/MsTestV2Tests.cs index 1c04e88bd..db420b91b 100644 --- a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/MsTestV2Tests.cs +++ b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/MsTestV2Tests.cs @@ -92,11 +92,11 @@ public void SubmitTraces(string packageVersion) // Check the Environment AssertTargetSpanEqual(targetSpan, Tags.Env, "integration_tests"); - // CI Library Language - AssertTargetSpanEqual(targetSpan, TestTags.Language, TracerConstants.Language); + // Language + AssertTargetSpanEqual(targetSpan, Tags.Language, TracerConstants.Language); // CI Library Language - AssertTargetSpanEqual(targetSpan, TestTags.CILibraryVersion, TracerConstants.AssemblyVersion); + AssertTargetSpanEqual(targetSpan, CommonTags.LibraryVersion, TracerConstants.AssemblyVersion); // check specific test span switch (targetSpan.Tags[TestTags.Name]) diff --git a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/NUnitTests.cs b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/NUnitTests.cs index fa8ce8199..d27aeee47 100644 --- a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/NUnitTests.cs +++ b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/NUnitTests.cs @@ -107,11 +107,11 @@ public void SubmitTraces(string packageVersion) // Check the Environment AssertTargetSpanEqual(targetSpan, Tags.Env, "integration_tests"); - // CI Library Language - AssertTargetSpanEqual(targetSpan, TestTags.Language, TracerConstants.Language); + // Language + AssertTargetSpanEqual(targetSpan, Tags.Language, TracerConstants.Language); // CI Library Language - AssertTargetSpanEqual(targetSpan, TestTags.CILibraryVersion, TracerConstants.AssemblyVersion); + AssertTargetSpanEqual(targetSpan, CommonTags.LibraryVersion, TracerConstants.AssemblyVersion); // check specific test span switch (targetSpan.Tags[TestTags.Name]) diff --git a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/XUnitTests.cs b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/XUnitTests.cs index a3be73b78..20db2039d 100644 --- a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/XUnitTests.cs +++ b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/CI/XUnitTests.cs @@ -93,11 +93,11 @@ public void SubmitTraces(string packageVersion) // Check the Environment AssertTargetSpanEqual(targetSpan, Tags.Env, "integration_tests"); - // CI Library Language - AssertTargetSpanEqual(targetSpan, TestTags.Language, TracerConstants.Language); + // Language + AssertTargetSpanEqual(targetSpan, Tags.Language, TracerConstants.Language); // CI Library Language - AssertTargetSpanEqual(targetSpan, TestTags.CILibraryVersion, TracerConstants.AssemblyVersion); + AssertTargetSpanEqual(targetSpan, CommonTags.LibraryVersion, TracerConstants.AssemblyVersion); // check specific test span switch (targetSpan.Tags[TestTags.Name]) diff --git a/tracer/test/Datadog.Trace.SourceGenerators.Tests/TagsListGeneratorTests.cs b/tracer/test/Datadog.Trace.SourceGenerators.Tests/TagsListGeneratorTests.cs index 140912c89..e6dc443bb 100644 --- a/tracer/test/Datadog.Trace.SourceGenerators.Tests/TagsListGeneratorTests.cs +++ b/tracer/test/Datadog.Trace.SourceGenerators.Tests/TagsListGeneratorTests.cs @@ -28,6 +28,8 @@ public class TestList const string expected = @"// #nullable enable +using Datadog.Trace.Processors; + namespace MyTests.TestListNameSpace { partial class TestList @@ -66,16 +68,16 @@ public override void SetTag(string key, string value) return TestListProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (Id != null) { count++; - WriteTag(ref bytes, ref offset, IdBytes, Id); + WriteTag(ref bytes, ref offset, IdBytes, Id, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) @@ -113,6 +115,8 @@ public class TestList const string expected = @"// #nullable enable +using Datadog.Trace.Processors; + namespace MyTests.TestListNameSpace { partial class TestList @@ -148,16 +152,16 @@ public override void SetMetric(string key, double? value) } } - protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (Id != null) { count++; - WriteMetric(ref bytes, ref offset, IdBytes, Id.Value); + WriteMetric(ref bytes, ref offset, IdBytes, Id.Value, tagProcessors); } - return count + base.WriteAdditionalMetrics(ref bytes, ref offset); + return count + base.WriteAdditionalMetrics(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalMetrics(System.Text.StringBuilder sb) @@ -198,6 +202,8 @@ public class TestList const string expected = @"// #nullable enable +using Datadog.Trace.Processors; + namespace MyTests.TestListNameSpace { partial class TestList @@ -242,22 +248,22 @@ public override void SetTag(string key, string value) return TestListProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (Id != null) { count++; - WriteTag(ref bytes, ref offset, IdBytes, Id); + WriteTag(ref bytes, ref offset, IdBytes, Id, tagProcessors); } if (Name != null) { count++; - WriteTag(ref bytes, ref offset, NameBytes, Name); + WriteTag(ref bytes, ref offset, NameBytes, Name, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) @@ -304,6 +310,8 @@ public class TestList const string expected = @"// #nullable enable +using Datadog.Trace.Processors; + namespace MyTests.TestListNameSpace { partial class TestList @@ -344,22 +352,22 @@ public override void SetMetric(string key, double? value) } } - protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (Id != null) { count++; - WriteMetric(ref bytes, ref offset, IdBytes, Id.Value); + WriteMetric(ref bytes, ref offset, IdBytes, Id.Value, tagProcessors); } if (Name != null) { count++; - WriteMetric(ref bytes, ref offset, NameBytes, Name.Value); + WriteMetric(ref bytes, ref offset, NameBytes, Name.Value, tagProcessors); } - return count + base.WriteAdditionalMetrics(ref bytes, ref offset); + return count + base.WriteAdditionalMetrics(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalMetrics(System.Text.StringBuilder sb) @@ -406,6 +414,8 @@ public class TestList const string expected = @"// #nullable enable +using Datadog.Trace.Processors; + namespace MyTests.TestListNameSpace { partial class TestList @@ -444,22 +454,22 @@ public override void SetTag(string key, string value) return TestListProperties; } - protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalTags(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (Id != null) { count++; - WriteTag(ref bytes, ref offset, IdBytes, Id); + WriteTag(ref bytes, ref offset, IdBytes, Id, tagProcessors); } if (Name != null) { count++; - WriteTag(ref bytes, ref offset, NameBytes, Name); + WriteTag(ref bytes, ref offset, NameBytes, Name, tagProcessors); } - return count + base.WriteAdditionalTags(ref bytes, ref offset); + return count + base.WriteAdditionalTags(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalTags(System.Text.StringBuilder sb) @@ -506,6 +516,8 @@ public class TestList const string expected = @"// #nullable enable +using Datadog.Trace.Processors; + namespace MyTests.TestListNameSpace { partial class TestList @@ -540,22 +552,22 @@ public override void SetMetric(string key, double? value) } } - protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset) + protected override int WriteAdditionalMetrics(ref byte[] bytes, ref int offset, ITagProcessor[] tagProcessors) { var count = 0; if (Id != null) { count++; - WriteMetric(ref bytes, ref offset, IdBytes, Id.Value); + WriteMetric(ref bytes, ref offset, IdBytes, Id.Value, tagProcessors); } if (Name != null) { count++; - WriteMetric(ref bytes, ref offset, NameBytes, Name.Value); + WriteMetric(ref bytes, ref offset, NameBytes, Name.Value, tagProcessors); } - return count + base.WriteAdditionalMetrics(ref bytes, ref offset); + return count + base.WriteAdditionalMetrics(ref bytes, ref offset, tagProcessors); } protected override void WriteAdditionalMetrics(System.Text.StringBuilder sb) diff --git a/tracer/test/Datadog.Trace.TestHelpers/AssemblyInfo.cs b/tracer/test/Datadog.Trace.TestHelpers/AssemblyInfo.cs index df0e9c517..fec21defc 100644 --- a/tracer/test/Datadog.Trace.TestHelpers/AssemblyInfo.cs +++ b/tracer/test/Datadog.Trace.TestHelpers/AssemblyInfo.cs @@ -9,3 +9,4 @@ [assembly: InternalsVisibleTo("Datadog.Trace.Tests, PublicKey=002400000480000094000000060200000024000052534131000400000100010071199d8b058c0eb78fce058d551fdaa764da7336f3b23a5e71cd013dcaf4b6693de5a398a2f2cddc05484bb55622034dd64ad75aa23adad8fde3b01b6e212254963f081ea86c7dae6c4800500dde59e268e7f9e4eec2e0437b662a39db7a5fbf3b0a789da7aa0151b7b6336fcc82cd7a149df7f666f5396c8de92ca644d7a2d1")] [assembly: InternalsVisibleTo("Datadog.Trace.ClrProfiler.Managed.Tests, PublicKey=002400000480000094000000060200000024000052534131000400000100010071199d8b058c0eb78fce058d551fdaa764da7336f3b23a5e71cd013dcaf4b6693de5a398a2f2cddc05484bb55622034dd64ad75aa23adad8fde3b01b6e212254963f081ea86c7dae6c4800500dde59e268e7f9e4eec2e0437b662a39db7a5fbf3b0a789da7aa0151b7b6336fcc82cd7a149df7f666f5396c8de92ca644d7a2d1")] +[assembly: InternalsVisibleTo("Datadog.Trace.IntegrationTests, PublicKey=002400000480000094000000060200000024000052534131000400000100010071199d8b058c0eb78fce058d551fdaa764da7336f3b23a5e71cd013dcaf4b6693de5a398a2f2cddc05484bb55622034dd64ad75aa23adad8fde3b01b6e212254963f081ea86c7dae6c4800500dde59e268e7f9e4eec2e0437b662a39db7a5fbf3b0a789da7aa0151b7b6336fcc82cd7a149df7f666f5396c8de92ca644d7a2d1")] diff --git a/tracer/test/Datadog.Trace.Tests/HttpClientRequestTests.cs b/tracer/test/Datadog.Trace.Tests/HttpClientRequestTests.cs index 999d47ca4..0e2124b45 100644 --- a/tracer/test/Datadog.Trace.Tests/HttpClientRequestTests.cs +++ b/tracer/test/Datadog.Trace.Tests/HttpClientRequestTests.cs @@ -55,7 +55,7 @@ public async Task SerializeSpans() Assert.IsAssignableFrom(message.Content); } - private class CustomHandler : DelegatingHandler + private class CustomHandler : HttpClientHandler { public HttpRequestMessage Message { get; private set; } diff --git a/tracer/test/Datadog.Trace.Tests/Logging/DirectSubmission/Sink/LogsApiTests.cs b/tracer/test/Datadog.Trace.Tests/Logging/DirectSubmission/Sink/LogsApiTests.cs index 2c4731b76..fc6469352 100644 --- a/tracer/test/Datadog.Trace.Tests/Logging/DirectSubmission/Sink/LogsApiTests.cs +++ b/tracer/test/Datadog.Trace.Tests/Logging/DirectSubmission/Sink/LogsApiTests.cs @@ -1,4 +1,4 @@ -// +// // 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. // @@ -6,6 +6,7 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Net; using System.Text; using System.Threading.Tasks; using Datadog.Trace.Agent; @@ -139,6 +140,10 @@ public IApiRequest Create(Uri endpoint) return request; } + + public void SetProxy(WebProxy proxy, NetworkCredential credential) + { + } } internal class TestApiRequest : IApiRequest diff --git a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.AssemblyReferencesHaveNotChanged.netcoreapp3.1.verified.txt b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.AssemblyReferencesHaveNotChanged.netcoreapp3.1.verified.txt index aaf1ccfeb..59f4dd594 100644 --- a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.AssemblyReferencesHaveNotChanged.netcoreapp3.1.verified.txt +++ b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.AssemblyReferencesHaveNotChanged.netcoreapp3.1.verified.txt @@ -29,6 +29,7 @@ System.Net.Primitives, Version=4.1.2.0, Culture=neutral, PublicKeyToken=b03f5f7f System.Net.Requests, Version=4.1.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Net.Sockets, Version=4.2.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Net.WebHeaderCollection, Version=4.1.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a +System.Net.WebProxy, Version=4.0.2.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51 System.ObjectModel, Version=4.1.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Reflection.Emit, Version=4.1.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a System.Reflection.Emit.ILGeneration, Version=4.1.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a diff --git a/tracer/test/Datadog.Trace.Tests/TraceProcessors/NormalizerTraceProcessorTests.cs b/tracer/test/Datadog.Trace.Tests/TraceProcessors/NormalizerTraceProcessorTests.cs new file mode 100644 index 000000000..294eb26ef --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/TraceProcessors/NormalizerTraceProcessorTests.cs @@ -0,0 +1,126 @@ +// +// 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. +// + +using System.Collections.Generic; +using System.Text; +using Xunit; + +namespace Datadog.Trace.Tests.TraceProcessors +{ + public class NormalizerTraceProcessorTests + { + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize_test.go#L17 + [Fact] + public void NormalizeTagTests() + { + foreach (var value in GetNormalizeTagValues()) + { + var inValue = (string)value[0]; + var expectedValue = (string)value[1]; + + var actualValue = Trace.Processors.TraceUtil.NormalizeTag(inValue); + Assert.Equal(expectedValue, actualValue); + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize_test.go#L17 + static IEnumerable GetNormalizeTagValues() + { + yield return new object[] { "#test_starting_hash", "test_starting_hash" }; + yield return new object[] { "TestCAPSandSuch", "testcapsandsuch" }; + yield return new object[] { "Test Conversion Of Weird !@#$%^&**() Characters", "test_conversion_of_weird_characters" }; + yield return new object[] { "$#weird_starting", "weird_starting" }; + yield return new object[] { "allowed:c0l0ns", "allowed:c0l0ns" }; + yield return new object[] { "1love", "love" }; + yield return new object[] { "ünicöde", "ünicöde" }; + yield return new object[] { "ünicöde:metäl", "ünicöde:metäl" }; + yield return new object[] { "Data🐨dog🐶 繋がっ⛰てて", "data_dog_繋がっ_てて" }; + yield return new object[] { " spaces ", "spaces" }; + yield return new object[] { " #hashtag!@#spaces #__<># ", "hashtag_spaces" }; + yield return new object[] { ":testing", ":testing" }; + yield return new object[] { "_foo", "foo" }; + yield return new object[] { ":::test", ":::test" }; + yield return new object[] { "contiguous_____underscores", "contiguous_underscores" }; + yield return new object[] { "foo_", "foo" }; + yield return new object[] { "\u017Fodd_\u017Fcase\u017F", "\u017Fodd_\u017Fcase\u017F" }; // edge-case + yield return new object[] { string.Empty, string.Empty }; + yield return new object[] { " ", string.Empty }; + yield return new object[] { "ok", "ok" }; + yield return new object[] { "™Ö™Ö™™Ö™", "ö_ö_ö" }; + yield return new object[] { "AlsO:ök", "also:ök" }; + yield return new object[] { ":still_ok", ":still_ok" }; + yield return new object[] { "___trim", "trim" }; + yield return new object[] { "12.:trim@", ":trim" }; + yield return new object[] { "12.:trim@@", ":trim" }; + yield return new object[] { "fun:ky__tag/1", "fun:ky_tag/1" }; + yield return new object[] { "fun:ky@tag/2", "fun:ky_tag/2" }; + yield return new object[] { "fun:ky@@@tag/3", "fun:ky_tag/3" }; + yield return new object[] { "tag:1/2.3", "tag:1/2.3" }; + yield return new object[] { "---fun:k####y_ta@#g/1_@@#", "fun:k_y_ta_g/1" }; + yield return new object[] { "AlsO:œ#@ö))œk", "also:œ_ö_œk" }; + yield return new object[] { "test\x99\x8f", "test" }; + yield return new object[] { new string('a', 888), new string('a', 200) }; + + var sBuilder = new StringBuilder("a"); + for (var i = 0; i < 799; i++) + { + sBuilder.Append("🐶"); + } + + sBuilder.Append('b'); + yield return new object[] { sBuilder.ToString(), "a" }; + yield return new object[] { "a\xFFFD", "a" }; + yield return new object[] { "a\xFFFD\xFFFD", "a" }; + yield return new object[] { "a\xFFFD\xFFFDb", "a_b" }; + yield return new object[] { null, string.Empty }; + } + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize_test.go#L94 + [Fact] + public void NormalizeNameTests() + { + foreach (var value in GetNormalizeNameValues()) + { + var inValue = (string)value[0]; + var expectedValue = (string)value[1]; + + var actualValue = Trace.Processors.NormalizerTraceProcessor.NormalizeName(inValue); + Assert.Equal(expectedValue, actualValue); + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize_test.go#L100-L119 + static IEnumerable GetNormalizeNameValues() + { + yield return new object[] { string.Empty, Trace.Processors.NormalizerTraceProcessor.DefaultSpanName }; + yield return new object[] { "good", "good" }; + yield return new object[] { "Too-Long-.Too-Long-.Too-Long-.Too-Long-.Too-Long-.Too-Long-.Too-Long-.Too-Long-.Too-Long-.Too-Long-.Too-Long-.", "Too_Long.Too_Long.Too_Long.Too_Long.Too_Long.Too_Long.Too_Long.Too_Long.Too_Long.Too_Long." }; + yield return new object[] { "bad-name", "bad_name" }; + } + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize_test.go#L127 + [Fact] + public void NormalizeServiceTests() + { + foreach (var value in GetNormalizeServiceValues()) + { + var inValue = (string)value[0]; + var expectedValue = (string)value[1]; + + var actualValue = Trace.Processors.NormalizerTraceProcessor.NormalizeService(inValue); + Assert.Equal(expectedValue, actualValue); + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/normalize_test.go#L134-L153 + static IEnumerable GetNormalizeServiceValues() + { + yield return new object[] { string.Empty, Trace.Processors.NormalizerTraceProcessor.DefaultServiceName }; + yield return new object[] { "good", "good" }; + yield return new object[] { "Too$Long$.Too$Long$.Too$Long$.Too$Long$.Too$Long$.Too$Long$.Too$Long$.Too$Long$.Too$Long$.Too$Long$.Too$Long$.", "too_long_.too_long_.too_long_.too_long_.too_long_.too_long_.too_long_.too_long_.too_long_.too_long_." }; + yield return new object[] { "bad$service", "bad_service" }; + } + } + } +} diff --git a/tracer/test/Datadog.Trace.Tests/TraceProcessors/TruncatorTraceProcessorTests.cs b/tracer/test/Datadog.Trace.Tests/TraceProcessors/TruncatorTraceProcessorTests.cs new file mode 100644 index 000000000..e5c11828b --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/TraceProcessors/TruncatorTraceProcessorTests.cs @@ -0,0 +1,43 @@ +// +// 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. +// + +using System.Collections.Generic; +using System.Text; +using Xunit; + +namespace Datadog.Trace.Tests.TraceProcessors +{ + public class TruncatorTraceProcessorTests + { + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/truncate_test.go#L15-L23 + [Fact] + public void TruncateString() + { + Assert.Equal(string.Empty, TruncateUTF8(string.Empty, 5)); + Assert.Equal("télé", TruncateUTF8("télé", 5)); + Assert.Equal("t", TruncateUTF8("télé", 2)); + Assert.Equal("éé", TruncateUTF8("ééééé", 5)); + Assert.Equal("ééééé", TruncateUTF8("ééééé", 18)); + Assert.Equal("ééééé", TruncateUTF8("ééééé", 10)); + Assert.Equal("ééé", TruncateUTF8("ééééé", 6)); + + static string TruncateUTF8(string value, int limit) + { + Trace.Processors.TraceUtil.TruncateUTF8(ref value, limit); + return value; + } + } + + // https://github.com/DataDog/datadog-agent/blob/eac2327c5574da7f225f9ef0f89eaeb05ed10382/pkg/trace/traceutil/truncate_test.go#L25-L38 + [Fact] + public void TruncateResourceTest() + { + Assert.Equal("resource", Trace.Processors.TruncatorTraceProcessor.TruncateResource("resource")); + + var s = new string('a', Trace.Processors.TruncatorTraceProcessor.MaxResourceLen); + Assert.Equal(s, Trace.Processors.TruncatorTraceProcessor.TruncateResource(s + "extra string")); + } + } +} diff --git a/tracer/test/Datadog.Trace.Tests/TracerInstanceTest.cs b/tracer/test/Datadog.Trace.Tests/TracerInstanceTest.cs index a1ae9304c..44e3e3be7 100644 --- a/tracer/test/Datadog.Trace.Tests/TracerInstanceTest.cs +++ b/tracer/test/Datadog.Trace.Tests/TracerInstanceTest.cs @@ -62,7 +62,7 @@ public void LockedTracerInstanceSwap() Assert.Throws(() => Tracer.Instance = null); Assert.Throws(() => TracerManager.ReplaceGlobalManager(null, TracerManagerFactory.Instance)); - Assert.Throws(() => TracerManager.ReplaceGlobalManager(null, new CITracerManagerFactory())); + Assert.Throws(() => TracerManager.ReplaceGlobalManager(null, new CITracerManagerFactory(CIVisibility.Settings))); } [Fact] diff --git a/tracer/test/benchmarks/Benchmarks.Trace/AgentWriterBenchmark.cs b/tracer/test/benchmarks/Benchmarks.Trace/AgentWriterBenchmark.cs index a3272e650..0d8ab6082 100644 --- a/tracer/test/benchmarks/Benchmarks.Trace/AgentWriterBenchmark.cs +++ b/tracer/test/benchmarks/Benchmarks.Trace/AgentWriterBenchmark.cs @@ -2,6 +2,7 @@ using System; using System.IO; +using System.Net; using System.Threading.Tasks; using BenchmarkDotNet.Attributes; using Datadog.Trace; @@ -75,6 +76,10 @@ public IApiRequest Create(Uri endpoint) return new FakeApiRequest(request); } + + public void SetProxy(WebProxy proxy, NetworkCredential credential) + { + } } private class FakeApiRequest : IApiRequest