From 37059ef79a8ed423ccfbacb1f5475ff1d9970e44 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Sun, 30 Nov 2025 19:55:47 +0100 Subject: [PATCH 01/54] RCM and Evaluator initial implementation --- .../ClrProfiler/Instrumentation.cs | 11 + .../Configuration/TracerSettings.cs | 8 + .../Datadog.Trace/FeatureFlags/Evaluation.cs | 29 + .../FeatureFlags/EvaluationContext.cs | 36 + .../FeatureFlags/EvaluationReason.cs | 28 + .../FeatureFlags/Exposure/Allocation.cs | 37 + .../FeatureFlags/Exposure/ExposureEvent.cs | 25 + .../FeatureFlags/Exposure/Flag.cs | 17 + .../FeatureFlags/Exposure/Subject.cs | 19 + .../FeatureFlags/Exposure/Variant.cs | 17 + .../FeatureFlags/FeatureFlagsEvaluator.cs | 641 ++++++++++++++++++ .../FeatureFlags/FeatureFlagsModule.cs | 102 +++ .../FeatureFlags/Rcm/FfeProduct.cs | 62 ++ .../FeatureFlags/Rcm/Model/Allocation.cs | 26 + .../Rcm/Model/ConditionConfiguration.cs | 20 + .../Rcm/Model/ConditionOperator.cs | 24 + .../FeatureFlags/Rcm/Model/Environment.cs | 16 + .../FeatureFlags/Rcm/Model/Flag.cs | 24 + .../FeatureFlags/Rcm/Model/Rule.cs | 16 + .../Rcm/Model/ServerConfiguration.cs | 22 + .../FeatureFlags/Rcm/Model/Shard.cs | 21 + .../FeatureFlags/Rcm/Model/ShardRange.cs | 19 + .../FeatureFlags/Rcm/Model/Split.cs | 20 + .../FeatureFlags/Rcm/Model/ValueType.cs | 20 + .../FeatureFlags/Rcm/Model/Variant.cs | 23 + .../RcmCapabilitiesIndices.cs | 2 + .../RcmProducts.cs | 3 + .../FeatureFlagsEvaluatorTests.cs | 379 +++++++++++ 28 files changed, 1667 insertions(+) create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/EvaluationReason.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Exposure/Allocation.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureEvent.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Exposure/Flag.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Exposure/Subject.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Exposure/Variant.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Allocation.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ConditionConfiguration.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ConditionOperator.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Environment.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Flag.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Rule.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ServerConfiguration.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Shard.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ShardRange.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Split.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ValueType.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Variant.cs create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs diff --git a/tracer/src/Datadog.Trace/ClrProfiler/Instrumentation.cs b/tracer/src/Datadog.Trace/ClrProfiler/Instrumentation.cs index 33ec90c848eb..9ace782dcd8c 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/Instrumentation.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/Instrumentation.cs @@ -19,6 +19,7 @@ using Datadog.Trace.Debugger.ExceptionAutoInstrumentation; using Datadog.Trace.Debugger.Helpers; using Datadog.Trace.DiagnosticListeners; +using Datadog.Trace.FeatureFlags; using Datadog.Trace.Iast.Dataflow; using Datadog.Trace.Logging; using Datadog.Trace.Processors; @@ -323,6 +324,16 @@ internal static void InitializeNoNativeParts(Stopwatch sw = null) Log.Error(ex, "Error initializing Security"); } + try + { + Log.Debug("Initializing Feature Flags singleton instance."); + _ = FeatureFlagsModule.Instance; + } + catch (Exception ex) + { + Log.Error(ex, "Error initializing Feature Flags Module"); + } + #if !NETFRAMEWORK try { diff --git a/tracer/src/Datadog.Trace/Configuration/TracerSettings.cs b/tracer/src/Datadog.Trace/Configuration/TracerSettings.cs index 9a1d42c2ddec..452f906fb4ef 100644 --- a/tracer/src/Datadog.Trace/Configuration/TracerSettings.cs +++ b/tracer/src/Datadog.Trace/Configuration/TracerSettings.cs @@ -610,6 +610,9 @@ not null when string.Equals(value, "otlp", StringComparison.OrdinalIgnoreCase) = DisabledAdoNetCommandTypes.UnionWith(userSplit); } + IsFlaggingProviderEnabled = config.WithKeys(ConfigurationKeys.FeatureFlags.FlaggingProviderEnabled) + .AsBool(false); + if (source is CompositeConfigurationSource compositeSource) { foreach (var nestedSource in compositeSource) @@ -1249,6 +1252,11 @@ not null when string.Equals(value, "otlp", StringComparison.OrdinalIgnoreCase) = /// internal HashSet DisabledAdoNetCommandTypes { get; } + /// + /// Gets a value indicating whether remote Feature Flags Provider is enabled + /// + internal bool IsFlaggingProviderEnabled { get; } + /// /// Gets a value indicating whether partial flush is enabled /// diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs b/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs new file mode 100644 index 000000000000..6162b5537e93 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs @@ -0,0 +1,29 @@ +// +// 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 System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Web; + +namespace Datadog.Trace.FeatureFlags +{ + internal class Evaluation(T value, EvaluationReason reason, string? variant = null, string? error = null, Dictionary? metadata = null) + { + public T Value { get; } = value; + + public EvaluationReason Reason { get; } = reason; + + public string? Variant { get; } = variant; + + public string? Error { get; } = error; + + public Dictionary? Metadata { get; } = metadata; + } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs new file mode 100644 index 000000000000..c47593c33568 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.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. +// + +#nullable enable + +using System; +using System.Collections.Generic; + +namespace Datadog.Trace.FeatureFlags +{ + internal class EvaluationContext(string key, Dictionary? values = null, Func? convertValue = null) + { + private readonly Func? _convertValue = convertValue; + + public string TargetingKey { get; } = key; + + public Dictionary Values { get; } = values ?? new Dictionary(); + + public object? GetValue(string key) + { + if (Values is null || !Values.TryGetValue(key, out var res)) + { + return null; + } + + return res; + } + + public object? ConvertValue(object? value) + { + return _convertValue?.Invoke(value); + } + } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationReason.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationReason.cs new file mode 100644 index 000000000000..0009b01c3d85 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationReason.cs @@ -0,0 +1,28 @@ +// +// 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 System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Web; + +namespace Datadog.Trace.FeatureFlags +{ + internal enum EvaluationReason + { + DEFAULT, + STATIC, + TARGETING_MATCH, + SPLIT, + DISABLED, + CACHED, + UNKNOWN, + ERROR + } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Allocation.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Allocation.cs new file mode 100644 index 000000000000..bd1a60cbefa8 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Allocation.cs @@ -0,0 +1,37 @@ +// +// 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 System.Collections.Generic; +using Datadog.Trace.ClrProfiler.AutoInstrumentation.Aerospike; + +namespace Datadog.Trace.FeatureFlags.Exposure; + +internal class Allocation(string key) +{ + public string Key { get; } = key; + + public override bool Equals(object? obj) + { + if (this == obj) + { + return true; + } + + if (obj is Allocation that) + { + return Key.Equals(that.Key); + } + + return false; + } + + public override int GetHashCode() + { + return Key.GetHashCode(); + } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureEvent.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureEvent.cs new file mode 100644 index 000000000000..b07f74bf174d --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureEvent.cs @@ -0,0 +1,25 @@ +// +// 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 System.Collections.Generic; +using System.Security.Cryptography.X509Certificates; + +namespace Datadog.Trace.FeatureFlags.Exposure; + +internal class ExposureEvent(long timeStamp, Allocation allocation, Flag flag, Variant variant, Subject subject) +{ + public long TimeStamp { get; } = timeStamp; + + public Allocation Allocation { get; } = allocation; + + public Flag Flag { get; } = flag; + + public Variant Variant { get; } = variant; + + public Subject Subject { get; } = subject; +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Flag.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Flag.cs new file mode 100644 index 000000000000..4778ba055f23 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Flag.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. +// + +#nullable enable + +using System; +using System.Collections.Generic; +using Datadog.Trace.ClrProfiler.AutoInstrumentation.Aerospike; + +namespace Datadog.Trace.FeatureFlags.Exposure; + +internal class Flag(string key) +{ + public string Key { get; } = key; +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Subject.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Subject.cs new file mode 100644 index 000000000000..a234d5543d06 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Subject.cs @@ -0,0 +1,19 @@ +// +// 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 System.Collections.Generic; +using Datadog.Trace.ClrProfiler.AutoInstrumentation.Aerospike; + +namespace Datadog.Trace.FeatureFlags.Exposure; + +internal class Subject(string id, IDictionary attributes) +{ + public string Id { get; } = id; + + public IDictionary Attributes { get; } = attributes; +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Variant.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Variant.cs new file mode 100644 index 000000000000..1c3e3b4621fe --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Variant.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. +// + +#nullable enable + +using System; +using System.Collections.Generic; +using Datadog.Trace.ClrProfiler.AutoInstrumentation.Aerospike; + +namespace Datadog.Trace.FeatureFlags.Exposure; + +internal class Variant(string key) +{ + public string Key { get; } = key; +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs new file mode 100644 index 000000000000..e8938fc1757a --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -0,0 +1,641 @@ +// +// 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 System.Collections; +using System.Collections.Generic; +using System.Globalization; +using System.Linq; +using System.Runtime.CompilerServices; +using System.Security.Cryptography; +using System.Text; +using System.Text.RegularExpressions; +using Datadog.Trace.FeatureFlags.Rcm.Model; +using Datadog.Trace.Logging; + +namespace Datadog.Trace.FeatureFlags +{ + internal class FeatureFlagsEvaluator + { + internal static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(FeatureFlagsEvaluator)); + + private static readonly string[] DateFormats = + { + "yyyy-MM-dd'T'HH:mm:ss.fff'Z'", + "yyyy-MM-dd'T'HH:mm:ss'Z'" + }; + + private static readonly HashSet SupportedResolutionTypes = + new() + { + typeof(string), + typeof(bool), + typeof(int), + typeof(double), + // typeof(Value) + }; + + private readonly Action? _onExposureEvent; + private readonly ServerConfiguration? _config; + private readonly long _timeoutMs; + + public FeatureFlagsEvaluator(Action? onExposureEvent, ServerConfiguration? config, long timeoutMs = 1000) + { + _onExposureEvent = onExposureEvent; + _config = config; + _timeoutMs = timeoutMs; + } + + private delegate bool NumberEquality(double a, double b); + + public Evaluation Evaluate(string key, T defaultValue, EvaluationContext context) + { + try + { + var config = _config; + if (config == null) + { + return new Evaluation( + defaultValue, + EvaluationReason.ERROR, + error: "PROVIDER_NOT_READY", + metadata: new Dictionary + { + ["errorCode"] = "PROVIDER_NOT_READY" + }); + } + + if (context == null) + { + return new Evaluation( + defaultValue, + EvaluationReason.ERROR, + error: "INVALID_CONTEXT", + metadata: new Dictionary + { + ["errorCode"] = "INVALID_CONTEXT" + }); + } + + if (string.IsNullOrEmpty(context.TargetingKey)) + { + return new Evaluation( + defaultValue, + EvaluationReason.ERROR, + error: "TARGETING_KEY_MISSING", + metadata: new Dictionary + { + ["errorCode"] = "TARGETING_KEY_MISSING" + }); + } + + if (config.Flags is null || !config.Flags.TryGetValue(key, out var flag) || flag is null) + { + return new Evaluation( + defaultValue, + EvaluationReason.ERROR, + error: "FLAG_NOT_FOUND", + metadata: new Dictionary + { + ["errorCode"] = "FLAG_NOT_FOUND" + }); + } + + if (!flag.Enabled is true) + { + return new Evaluation( + defaultValue, + EvaluationReason.DISABLED); + } + + if (flag.Allocations is { Count: 0 }) + { + return new Evaluation( + defaultValue, + EvaluationReason.ERROR, + error: "Missing allocations", + metadata: new Dictionary + { + ["errorCode"] = "GENERAL", + ["message"] = $"Missing allocations for flag {flag.Key}" + }); + } + + var now = DateTime.UtcNow; + var targetingKey = context.TargetingKey; + + foreach (var allocation in flag.Allocations!) + { + if (!IsAllocationActive(allocation, now)) + { + continue; + } + + if (allocation.Rules is { Count: > 0 }) + { + if (!EvaluateRules(allocation.Rules!, context)) + { + continue; + } + } + + if (allocation.Splits is { Count: > 0 }) + { + foreach (var split in allocation.Splits) + { + if (split.Shards is { Count: 0 }) + { + return ResolveVariant(key, defaultValue, flag, split.VariationKey ?? string.Empty, allocation, context); + } + + var allShardsMatch = true; + foreach (var shard in split.Shards!) + { + if (!MatchesShard(shard, targetingKey)) + { + allShardsMatch = false; + break; + } + } + + if (allShardsMatch) + { + return ResolveVariant(key, defaultValue, flag, split.VariationKey ?? string.Empty, allocation, context); + } + } + } + } + + // No allocation / split matched – use default + return new Evaluation( + defaultValue, + EvaluationReason.DEFAULT); + } + catch (FormatException ex) + { + Log.Debug(ex, "Evaluation failed for key {Key}", key); + return new Evaluation( + defaultValue, + EvaluationReason.ERROR, + error: "TYPE_MISMATCH", + metadata: new Dictionary + { + ["errorCode"] = "TYPE_MISMATCH" + }); + } + catch (Exception ex) + { + Log.Debug(ex, "Evaluation failed for key {Key}", key); + return new Evaluation( + defaultValue, + EvaluationReason.ERROR, + error: ex.Message, + metadata: new Dictionary + { + ["errorCode"] = "GENERAL", + ["message"] = ex.Message + }); + } + } + + // --------- helpers ---------- + + private static bool IsAllocationActive(Allocation allocation, DateTime now) + { + var startDate = ParseDate(allocation.StartAt); + if (startDate.HasValue && now < startDate.Value) + { + return false; + } + + var endDate = ParseDate(allocation.EndAt); + if (endDate.HasValue && now > endDate.Value) + { + return false; + } + + return true; + } + + private static bool EvaluateRules(IEnumerable rules, EvaluationContext context) + { + foreach (var rule in rules) + { + if (rule.Conditions is null || rule.Conditions.Count == 0) + { + continue; + } + + var allConditionsMatch = true; + foreach (var condition in rule.Conditions) + { + if (!EvaluateCondition(condition, context)) + { + allConditionsMatch = false; + break; + } + } + + if (allConditionsMatch) + { + return true; + } + } + + return false; + } + + private static bool EvaluateCondition(ConditionConfiguration condition, EvaluationContext context) + { + if (condition.Operator is null) + { + return false; + } + + if (condition.Operator == ConditionOperator.IS_NULL) + { + var value = ResolveAttribute(condition.Attribute, context); + var isNull = value == null; + var expectedNull = condition.Value is bool b ? b : true; + return isNull == expectedNull; + } + + var attributeValue = ResolveAttribute(condition.Attribute, context); + if (attributeValue == null) + { + return false; + } + + switch (condition.Operator) + { + case ConditionOperator.MATCHES: + return MatchesRegex(attributeValue, condition.Value); + case ConditionOperator.NOT_MATCHES: + return !MatchesRegex(attributeValue, condition.Value); + case ConditionOperator.ONE_OF: + return IsOneOf(attributeValue, condition.Value); + case ConditionOperator.NOT_ONE_OF: + return !IsOneOf(attributeValue, condition.Value); + case ConditionOperator.GTE: + return CompareNumber(attributeValue, condition.Value, (a, b) => a >= b); + case ConditionOperator.GT: + return CompareNumber(attributeValue, condition.Value, (a, b) => a > b); + case ConditionOperator.LTE: + return CompareNumber(attributeValue, condition.Value, (a, b) => a <= b); + case ConditionOperator.LT: + return CompareNumber(attributeValue, condition.Value, (a, b) => a < b); + default: + return false; + } + } + + private static bool MatchesRegex(object attributeValue, object? conditionValue) + { + if (conditionValue is null) + { + return false; + } + + try + { + var pattern = conditionValue?.ToString() ?? string.Empty; + var regex = new Regex(pattern); + return regex.IsMatch(attributeValue?.ToString() ?? string.Empty); + } + catch + { + return false; + } + } + + private static bool IsOneOf(object attributeValue, object? conditionValue) + { + if (conditionValue is not IEnumerable enumerable) + { + return false; + } + + foreach (var value in enumerable) + { + if (ValuesEqual(attributeValue, value)) + { + return true; + } + } + + return false; + } + + private static bool ValuesEqual(object a, object? b) + { + if (b is null) + { + return false; + } + + if (Equals(a, b)) + { + return true; + } + + if (a is IConvertible || b is IConvertible) + { + return CompareNumber(a, b, (first, second) => Math.Abs(first - second) < double.Epsilon); + } + + return string.Equals(Convert.ToString(a), Convert.ToString(b), StringComparison.Ordinal); + } + + private static bool CompareNumber(object attributeValue, object? conditionValue, NumberEquality comparator) + { + if (conditionValue is null) + { + return false; + } + + var a = ParseDouble(attributeValue); + var b = ParseDouble(conditionValue); + return comparator(a, b); + } + + private static bool MatchesShard(Shard shard, string targetingKey) + { + if (shard.Ranges is null) + { + return false; + } + + var assignedShard = GetShard(shard.Salt ?? string.Empty, targetingKey, shard.TotalShards); + foreach (var range in shard.Ranges) + { + if (assignedShard >= range.Start && assignedShard < range.End) + { + return true; + } + } + + return false; + } + + private static int GetShard(string salt, string targetingKey, int totalShards) + { + var hashKey = $"{salt}-{targetingKey}"; + var md5Hash = GetMd5Hash(hashKey); + var first8Chars = md5Hash.Substring(0, Math.Min(8, md5Hash.Length)); + var intFromHash = Convert.ToInt64(first8Chars, 16); + return (int)(intFromHash % totalShards); + } + + private static string GetMd5Hash(string input) + { + using var md5 = MD5.Create(); + var bytes = Encoding.UTF8.GetBytes(input); + var hashBytes = md5.ComputeHash(bytes); + var sb = new StringBuilder(); + foreach (var b in hashBytes) + { + sb.Append(b.ToString("x2")); + } + + return sb.ToString(); + } + + private static DateTime? ParseDate(string? dateString) + { + if (dateString == null) + { + return null; + } + + foreach (var fmt in DateFormats) + { + if (DateTime.TryParseExact( + dateString, + fmt, + System.Globalization.CultureInfo.InvariantCulture, + System.Globalization.DateTimeStyles.AdjustToUniversal, + out var dt)) + { + return dt; + } + } + + return null; + } + + private static object? ResolveAttribute(string? name, EvaluationContext context) + { + if (name == null) + { + return null; + } + + // Special case "id": if not present, use targeting key + if (name == "id" && !context.Values.ContainsKey(name)) + { + return context.TargetingKey; + } + + var resolved = context.GetValue(name); + return context.ConvertValue(resolved) ?? resolved; + } + + internal static T MapValue(object? value) + { + if (value is null) + { + return default!; + } + + var target = typeof(T); + + if (!SupportedResolutionTypes.Contains(target)) + { + throw new ArgumentException($"Type not supported: {target}"); + } + + if (target.IsInstanceOfType(value)) + { + return (T)value; + } + + if (target == typeof(string)) + { + return (T)(object)Convert.ToString(value, CultureInfo.InvariantCulture)!; + } + + if (target == typeof(bool)) + { + if (value is IConvertible) + { + if (value is IFormattable && value is not bool) + { + return (T)(object)(ParseDouble(value) != 0); + } + + return (T)(object)Convert.ToBoolean(value); + } + + return (T)(object)bool.Parse(value.ToString()!); + } + + if (target == typeof(int)) + { + var number = ParseDouble(value); + return (T)(object)(int)number; + } + + if (target == typeof(double)) + { + var number = ParseDouble(value); + return (T)(object)number; + } + + return default!; + // return (T)(object)Value.ObjectToValue(value); + } + + private static double ParseDouble(object value) + { + if (value is IConvertible) + { + return Convert.ToDouble(value, CultureInfo.InvariantCulture); + } + + return double.Parse(Convert.ToString(value)!); + } + + private static string? AllocationKey(Evaluation evaluation) + { + if (evaluation.Metadata == null) + { + return null; + } + + return evaluation.Metadata.TryGetValue("allocationKey", out var key) ? key : null; + } + + internal static IDictionary FlattenContext(EvaluationContext context) + { + var keys = context.Values.Keys; + var result = new Dictionary(); + var seen = new HashSet(); + + foreach (var key in keys) + { + var stack = new Stack(); + stack.Push(new FlattenEntry(key, context.GetValue(key))); + + while (stack.Count > 0) + { + var entry = stack.Pop(); + var value = entry.Value; + + if (value == null || seen.Add(value)) + { + if (value == null) + { + result[entry.Key] = null; + } + else if (value is IList list) + { + for (var i = 0; i < list.Count; i++) + { + stack.Push(new FlattenEntry($"{entry.Key}[{i}]", list[i])); + } + } + + // else if (value.IsStructure()) // Not implemented yet + // { + // } + else + { + result[entry.Key] = context.ConvertValue(value); + } + } + } + } + + return result; + } + + private Evaluation ResolveVariant( + string key, + T defaultValue, + Flag flag, + string variationKey, + Allocation allocation, + EvaluationContext context) + { + if (flag.Variations is null || !flag.Variations.TryGetValue(variationKey, out var variant) || variant == null) + { + return new Evaluation( + defaultValue, + EvaluationReason.ERROR, + error: $"Variant not found for: {variationKey}", + metadata: new Dictionary + { + ["errorCode"] = "GENERAL", + ["message"] = $"Variant not found for: {variationKey}" + }); + } + + var mappedValue = MapValue(variant.Value); + + var metadata = new Dictionary + { + ["flagKey"] = flag.Key ?? string.Empty, + ["variationType"] = flag.VariationType?.ToString() ?? string.Empty, + ["allocationKey"] = allocation.Key ?? string.Empty + }; + + var evaluation = new Evaluation( + mappedValue, + EvaluationReason.TARGETING_MATCH, + variant: variant.Key, + metadata: metadata); + + var doLog = allocation.DoLog.HasValue && allocation.DoLog.Value; + if (doLog) + { + DispatchExposure(key, evaluation, context); + } + + return evaluation; + } + + private void DispatchExposure( + string flag, + Evaluation evaluation, + EvaluationContext context) + { + var allocationKey = AllocationKey(evaluation); + var variantKey = evaluation.Variant; + + if (allocationKey == null || variantKey == null) + { + return; + } + + var evt = new Exposure.ExposureEvent( + DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(), + new Exposure.Allocation(allocationKey), + new Exposure.Flag(flag), + new Exposure.Variant(variantKey), + new Exposure.Subject(context.TargetingKey, FlattenContext(context))); + + _onExposureEvent?.Invoke(evt); + } + + private sealed class FlattenEntry(string key, object? value) + { + public string Key { get; } = key; + + public object? Value { get; } = value; + } + } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs new file mode 100644 index 000000000000..b495da5a0c22 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -0,0 +1,102 @@ +// +// 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 System.Collections.Generic; +using System.Linq; +using System.Threading; +using Datadog.Trace.Agent.DiscoveryService; +using Datadog.Trace.AppSec.Rcm; +using Datadog.Trace.AppSec.Rcm.Models.AsmFeatures; +using Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcAspNetCoreServer; +using Datadog.Trace.Configuration; +using Datadog.Trace.FeatureFlags.Exposure; +using Datadog.Trace.FeatureFlags.Rcm; +using Datadog.Trace.FeatureFlags.Rcm.Model; +using Datadog.Trace.RemoteConfigurationManagement; +using Datadog.Trace.Sampling; +using Datadog.Trace.Telemetry; +using Datadog.Trace.Vendors.Serilog; + +namespace Datadog.Trace.FeatureFlags +{ + internal class FeatureFlagsModule + { + private static FeatureFlagsModule? _instance; + private static bool _globalInstanceInitialized; + private static object _globalInstanceLock = new(); + + private readonly TracerSettings _settings; + private readonly IRcmSubscriptionManager _rcmSubscriptionManager; + private ISubscription? _rcmSubscription = null; + private FfeProduct? _ffeProduct = null; + + private FeatureFlagsEvaluator? _evaluator = null; + + static FeatureFlagsModule() + { + } + + /// + /// Initializes a new instance of the class with default settings. + /// + public FeatureFlagsModule(IRcmSubscriptionManager? rcmSubscriptionManager = null) + : this(TracerSettings.FromDefaultSourcesInternal(), rcmSubscriptionManager) + { + } + + internal FeatureFlagsModule(TracerSettings settings, IRcmSubscriptionManager? rcmSubscriptionManager = null) + { + _settings = settings; + _rcmSubscriptionManager = rcmSubscriptionManager ?? RcmSubscriptionManager.Instance; + + if (settings.IsFlaggingProviderEnabled) + { + _ffeProduct = new FfeProduct(UpdateConfig); + _rcmSubscription = new Subscription(_ffeProduct.UpdateFromRcm, RcmProducts.FfeFlags); + _rcmSubscriptionManager.SubscribeToChanges(_rcmSubscription); + _rcmSubscriptionManager.SetCapability(RcmCapabilitiesIndices.AsmActivation, true); + } + } + + /// + /// Gets or sets the global instance. + /// + public static FeatureFlagsModule Instance + { + get => LazyInitializer.EnsureInitialized(ref _instance, ref _globalInstanceInitialized, ref _globalInstanceLock)!; + + set + { + lock (_globalInstanceLock) + { + _instance = value; + _globalInstanceInitialized = true; + } + } + } + + public long Timeout { get; set; } = 1000; + + private void ApplyServerConfigs() + { + } + + private void UpdateConfig(List> list) + { + // Feed configs to the rules evaluator + if (list.Count > 0) + { + _evaluator = new FeatureFlagsEvaluator(ReportExposure, list[0].Value, Timeout); + } + } + + private void ReportExposure(ExposureEvent exposure) + { + } + } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs new file mode 100644 index 000000000000..52d81ec9ddf9 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs @@ -0,0 +1,62 @@ +// +// 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 System.Collections.Generic; +using System.Linq; +using Datadog.Trace.AppSec.Rcm.Models.AsmDd; +using Datadog.Trace.FeatureFlags.Rcm.Model; +using Datadog.Trace.Logging; +using Datadog.Trace.RemoteConfigurationManagement; +using Datadog.Trace.Vendors.Newtonsoft.Json.Linq; + +namespace Datadog.Trace.AppSec.Rcm; + +internal class FfeProduct +{ + private readonly Action>> _onNewConfig; + private List> _serverConfigurations = new List>(); + + public FfeProduct(Action>> onNewConfig) + { + _onNewConfig = onNewConfig; + } + + public ApplyDetails[] UpdateFromRcm(Dictionary> configsByProduct, Dictionary>? removedConfigsByProduct) + { + List res = new List(); + bool apply = false; + + if (removedConfigsByProduct is not null && removedConfigsByProduct.TryGetValue(RcmProducts.FfeFlags, out var removedConfigs)) + { + foreach (var removedConfig in removedConfigs) + { + apply |= (_serverConfigurations.RemoveAll((x) => x.Key == removedConfig.Path) > 0); + } + } + + if (configsByProduct.TryGetValue(RcmProducts.FfeFlags, out var ffeConfigs)) + { + foreach (var ffeConfig in ffeConfigs) + { + var serverConfigFile = new NamedRawFile(ffeConfig.Path, ffeConfig.Contents).Deserialize(); + if (serverConfigFile.TypedFile is not null) + { + _serverConfigurations.Add(new KeyValuePair(ffeConfig.Path.Id, serverConfigFile.TypedFile)); + res.Add(ApplyDetails.FromOk(ffeConfig.Path.Id)); + apply = true; + } + } + } + + if (apply) + { + _onNewConfig?.Invoke(_serverConfigurations); + } + + return [.. res]; + } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Allocation.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Allocation.cs new file mode 100644 index 000000000000..43c74c36abc4 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Allocation.cs @@ -0,0 +1,26 @@ +// +// 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 System.Collections.Generic; + +namespace Datadog.Trace.FeatureFlags.Rcm.Model; + +internal class Allocation +{ + public string? Key { get; set; } + + public List? Rules { get; set; } + + public string? StartAt { get; set; } + + public string? EndAt { get; set; } + + public List? Splits { get; set; } + + public bool? DoLog { get; set; } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ConditionConfiguration.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ConditionConfiguration.cs new file mode 100644 index 000000000000..e2b51b5a10c9 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ConditionConfiguration.cs @@ -0,0 +1,20 @@ +// +// 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 System.Collections.Generic; + +namespace Datadog.Trace.FeatureFlags.Rcm.Model; + +internal class ConditionConfiguration +{ + public ConditionOperator? Operator { get; set; } + + public string? Attribute { get; set; } + + public object? Value { get; set; } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ConditionOperator.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ConditionOperator.cs new file mode 100644 index 000000000000..62d8f01f6d0e --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ConditionOperator.cs @@ -0,0 +1,24 @@ +// +// 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 System.Collections.Generic; + +namespace Datadog.Trace.FeatureFlags.Rcm.Model; + +internal enum ConditionOperator +{ + LT, + LTE, + GT, + GTE, + MATCHES, + NOT_MATCHES, + ONE_OF, + NOT_ONE_OF, + IS_NULL +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Environment.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Environment.cs new file mode 100644 index 000000000000..b5728be10faa --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Environment.cs @@ -0,0 +1,16 @@ +// +// 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 System.Collections.Generic; + +namespace Datadog.Trace.FeatureFlags.Rcm.Model; + +internal class Environment +{ + public string? Name { get; set; } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Flag.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Flag.cs new file mode 100644 index 000000000000..8215eb47278a --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Flag.cs @@ -0,0 +1,24 @@ +// +// 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 System.Collections.Generic; + +namespace Datadog.Trace.FeatureFlags.Rcm.Model; + +internal class Flag +{ + public string? Key { get; set; } + + public bool? Enabled { get; set; } + + public ValueType? VariationType { get; set; } + + public Dictionary? Variations { get; set; } + + public List? Allocations { get; set; } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Rule.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Rule.cs new file mode 100644 index 000000000000..d9382546bda2 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Rule.cs @@ -0,0 +1,16 @@ +// +// 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 System.Collections.Generic; + +namespace Datadog.Trace.FeatureFlags.Rcm.Model; + +internal class Rule(List? conditions) +{ + public List? Conditions { get; set; } = conditions; +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ServerConfiguration.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ServerConfiguration.cs new file mode 100644 index 000000000000..e74c534bd8bb --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ServerConfiguration.cs @@ -0,0 +1,22 @@ +// +// 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 System.Collections.Generic; + +namespace Datadog.Trace.FeatureFlags.Rcm.Model; + +internal class ServerConfiguration +{ + public string? CreatedAt { get; set; } + + public string? Format { get; set; } + + public Environment? Environment { get; set; } + + public Dictionary? Flags { get; set; } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Shard.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Shard.cs new file mode 100644 index 000000000000..0841dee177c3 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Shard.cs @@ -0,0 +1,21 @@ +// +// 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 System.Collections.Generic; +using Datadog.Trace.Iast; + +namespace Datadog.Trace.FeatureFlags.Rcm.Model; + +internal class Shard +{ + public string? Salt { get; set; } + + public List? Ranges { get; set; } + + public int TotalShards { get; set; } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ShardRange.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ShardRange.cs new file mode 100644 index 000000000000..2e2787ca342a --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ShardRange.cs @@ -0,0 +1,19 @@ +// +// 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 System.Collections.Generic; +using Datadog.Trace.Iast; + +namespace Datadog.Trace.FeatureFlags.Rcm.Model; + +internal class ShardRange +{ + public int Start { get; set; } + + public int End { get; set; } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Split.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Split.cs new file mode 100644 index 000000000000..787515ee3ce8 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Split.cs @@ -0,0 +1,20 @@ +// +// 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 System.Collections.Generic; + +namespace Datadog.Trace.FeatureFlags.Rcm.Model; + +internal class Split +{ + public List? Shards { get; set; } + + public string? VariationKey { get; set; } + + public Dictionary? ExtraLogging { get; set; } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ValueType.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ValueType.cs new file mode 100644 index 000000000000..939a09289763 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ValueType.cs @@ -0,0 +1,20 @@ +// +// 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 System.Collections.Generic; + +namespace Datadog.Trace.FeatureFlags.Rcm.Model; + +internal enum ValueType +{ + BOOLEAN, + INTEGER, + NUMERIC, + STRING, + JSON +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Variant.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Variant.cs new file mode 100644 index 000000000000..7c08ba5ef526 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Variant.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. +// + +#nullable enable + +using System; +using System.Collections.Generic; + +namespace Datadog.Trace.FeatureFlags.Rcm.Model; + +internal class Variant(string? key, string? value) +{ + public Variant() + : this(null, null) + { + } + + public string? Key { get; set; } = key; + + public string? Value { get; set; } = value; +} diff --git a/tracer/src/Datadog.Trace/RemoteConfigurationManagement/RcmCapabilitiesIndices.cs b/tracer/src/Datadog.Trace/RemoteConfigurationManagement/RcmCapabilitiesIndices.cs index f0d88cecc9d1..74da98c0d098 100644 --- a/tracer/src/Datadog.Trace/RemoteConfigurationManagement/RcmCapabilitiesIndices.cs +++ b/tracer/src/Datadog.Trace/RemoteConfigurationManagement/RcmCapabilitiesIndices.cs @@ -101,6 +101,8 @@ internal static class RcmCapabilitiesIndices public static readonly BigInteger ApmTracingMulticonfig = Create(45); + public static readonly BigInteger FfeFlagConfigurationRules = Create(46); + private static BigInteger Create(int index) => new(1UL << index); } } diff --git a/tracer/src/Datadog.Trace/RemoteConfigurationManagement/RcmProducts.cs b/tracer/src/Datadog.Trace/RemoteConfigurationManagement/RcmProducts.cs index c0ce39f54f84..af03af371804 100644 --- a/tracer/src/Datadog.Trace/RemoteConfigurationManagement/RcmProducts.cs +++ b/tracer/src/Datadog.Trace/RemoteConfigurationManagement/RcmProducts.cs @@ -9,6 +9,7 @@ internal static class RcmProducts { public const string LiveDebugging = "LIVE_DEBUGGING"; public const string LiveDebuggingSymbolDb = "LIVE_DEBUGGING_SYMBOL_DB"; + public const string Asm = "ASM"; public const string AsmFeatures = "ASM_FEATURES"; public const string AsmDd = "ASM_DD"; @@ -16,4 +17,6 @@ internal static class RcmProducts public const string TracerFlareInitiated = "AGENT_CONFIG"; public const string TracerFlareRequested = "AGENT_TASK"; + + public const string FfeFlags = "FFE_FLAGS"; } diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs new file mode 100644 index 000000000000..4bb0500e70bb --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs @@ -0,0 +1,379 @@ +// +// 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 System.Collections.Generic; +using Datadog.Trace.FeatureFlags; +using Datadog.Trace.FeatureFlags.Rcm.Model; +using Moq; +using Xunit; +using ValueType = Datadog.Trace.FeatureFlags.Rcm.Model.ValueType; + +namespace Datadog.Trace.Tests.FeatureFlags; + +public class FeatureFlagsEvaluatorTests +{ +#pragma warning disable SA1204 // Static elements should appear before instance elements +#pragma warning disable SA1500 // Braces for multi-line statements should not share line + + // --------------------------------------------------------------------- + // MapValue tests + // --------------------------------------------------------------------- + + public static IEnumerable MapValueCases() + { + // targetType, value, expected (or typeof(Exception)) + // String + yield return new object?[] { "hello", "hello" }; + yield return new object?[] { 123, "123" }; + yield return new object?[] { true, "True" }; + yield return new object?[] { 3.14, "3.14" }; + yield return new object?[] { null, null }; + + // Bool + yield return new object?[] { true, true }; + yield return new object?[] { false, false }; + yield return new object?[] { "true", true }; + yield return new object?[] { "false", false }; + yield return new object?[] { "TRUE", true }; + yield return new object?[] { "FALSE", false }; + yield return new object?[] { 1, true }; + yield return new object?[] { 0, false }; + yield return new object?[] { null, null }; + + // Int + yield return new object?[] { 42, (int)42 }; + yield return new object?[] { "42", (int)42 }; + yield return new object?[] { 3.14, (int)3 }; + yield return new object?[] { "3.14", (int)3 }; + yield return new object?[] { null, null }; + + // Double + yield return new object?[] { 3.14, 3.14 }; + yield return new object?[] { "3.14", 3.14 }; + yield return new object?[] { 42, 42d }; + yield return new object?[] { "42", 42d }; + yield return new object?[] { null, null }; + + // Unsupported + yield return new object?[] { new DateTime(2023, 12, 21), typeof(ArgumentException) }; + } + + [Theory] + [MemberData(nameof(MapValueCases))] + public void MapValueTests(object? input, object? expected) + { + if (expected is null || expected is string) + { + var res = FeatureFlagsEvaluator.MapValue(input); + Assert.Equal(expected, res); + } + else if (expected is int expectedInt) + { + var res = FeatureFlagsEvaluator.MapValue(input); + Assert.Equal(expected, res); + } + else if (expected is double expectedDouble) + { + var res = FeatureFlagsEvaluator.MapValue(input); + Assert.Equal(expected, res); + } + else if (expected is bool expectedBool) + { + var res = FeatureFlagsEvaluator.MapValue(input); + Assert.Equal(expected, res); + } + else if (expected is System.Type) + { + try + { + _ = FeatureFlagsEvaluator.MapValue(input); + } + catch (Exception res) + { + Assert.Equal(expected, res.GetType()); + } + } + else + { + throw new Exception($"Unknown expected type {expected.GetType()}"); + } + } + + [Fact] + public void EvaluateWithoutConfigReturnsProviderNotReadyAndDefault() + { + var evaluator = new FeatureFlagsEvaluator(null, null, 1000); + var ctx = new EvaluationContext("target"); + + var result = evaluator.Evaluate("test", 23, ctx); + + Assert.Equal(23, result.Value); + Assert.Equal(EvaluationReason.ERROR, result.Reason); + Assert.Equal("PROVIDER_NOT_READY", result.Error); + } + + [Fact] + public void EvaluateWithMissingTargetingKeyReturnsTargetingKeyMissing() + { + var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration(), 1000); + var ctx = new EvaluationContext(string.Empty); // no targetingKey + + var result = evaluator.Evaluate("flag", "default", ctx); + + Assert.Equal("default", result.Value); + Assert.Equal(EvaluationReason.ERROR, result.Reason); + Assert.Equal("TARGETING_KEY_MISSING", result.Error); + } + + [Fact] + public void EvaluateWithUnknownFlagReturnsFlagNotFound() + { + var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration(), 1000); + var ctx = new EvaluationContext("user-123"); + var result = evaluator.Evaluate("unknown", "default", ctx); + + Assert.Equal("default", result.Value); + Assert.Equal(EvaluationReason.ERROR, result.Reason); + Assert.Equal("FLAG_NOT_FOUND", result.Error); + } + + [Fact] + public void EvaluateDisabledFlagReturnsDisabledReason() + { + var flags = new Dictionary + { + ["disabled-flag"] = new Flag { Key = "disabled-flag", Enabled = false, VariationType = ValueType.BOOLEAN } + }; + var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); + var ctx = new EvaluationContext("user"); + + var result = evaluator.Evaluate("disabled-flag", true, ctx); + + Assert.True(result.Value); + Assert.Equal(EvaluationReason.DISABLED, result.Reason); + Assert.Null(result.Error); + } + + [Fact] + public void EvaluateFlagWithoutAllocationsReturnsGeneralError() + { + var flags = new Dictionary + { + ["null-allocation"] = new Flag { Key = "target", Enabled = true, VariationType = ValueType.STRING }, + ["empty-allocation"] = new Flag { Key = "target", Enabled = true, VariationType = ValueType.STRING, Allocations = new List() }, + }; + var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); + var ctx = new EvaluationContext("allocation"); + + var result1 = evaluator.Evaluate("null-allocation", 23, ctx); + Assert.Equal(23, result1.Value); + Assert.Equal(EvaluationReason.ERROR, result1.Reason); + Assert.Equal("GENERAL", result1.Metadata?["errorCode"]); + + var result2 = evaluator.Evaluate("empty-allocation", 23, ctx); + Assert.Equal(23, result2.Value); + Assert.Equal(EvaluationReason.ERROR, result2.Reason); + Assert.Equal("GENERAL", result2.Metadata?["errorCode"]); + } + + // --------------------------------------------------------------------- + // Happy-path evaluation + rule-based + numeric + exposure + // These are example slices; you can easily add more tests in same style. + // --------------------------------------------------------------------- + + [Fact] + public void EvaluateSimpleStringFlagReturnsTargetingMatch() + { + var flags = new Dictionary + { + ["simple-string"] = CreateSimpleFlag("simple-string", ValueType.STRING, "test-value", "on") + }; + + var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); + var ctx = new EvaluationContext("user-123"); + + var result = evaluator.Evaluate("simple-string", "default", ctx); + + Assert.Equal("test-value", result.Value); + Assert.Equal(EvaluationReason.TARGETING_MATCH, result.Reason); + Assert.Equal("on", result.Variant); + } + + [Fact] + public void EvaluateRuleBasedFlagMatchesEmailPremium() + { + var flags = new Dictionary + { + ["rule-based-flag"] = CreateRuleBasedFlag() + }; + + var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); + var ctx = new EvaluationContext("user-premium", new Dictionary { { "email", "john@company.com" } }); + + var result = evaluator.Evaluate("rule-based-flag", "default", ctx); + + Assert.Equal("premium", result.Value); + Assert.Equal(EvaluationReason.TARGETING_MATCH, result.Reason); + Assert.Equal("premium", result.Variant); + } + + [Fact] + public void EvaluateNumericRuleFlagMatchesScoreGte800() + { + var flags = new Dictionary + { + ["numeric-rule-flag"] = CreateNumericRuleFlag() + }; + + var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); + var ctx = new EvaluationContext("user-vip", new Dictionary { { "score", 850 } }); + + var result = evaluator.Evaluate("numeric-rule-flag", "default", ctx); + + Assert.Equal("vip", result.Value); + Assert.Equal(EvaluationReason.TARGETING_MATCH, result.Reason); + Assert.Equal("vip", result.Variant); + } + + [Fact] + public void EvaluateTimeBasedFlagWithExpiredAllocationReturnsDefaultReason() + { + var flags = new Dictionary + { + ["time-based-flag"] = CreateTimeBasedFlag() + }; + + var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); + var ctx = new EvaluationContext("user"); + + var result = evaluator.Evaluate("time-based-flag", "default", ctx); + + Assert.Equal("default", result.Value); + Assert.Equal(EvaluationReason.DEFAULT, result.Reason); + } + + [Fact] + public void EvaluateExposureFlagLogsExposureEvent() + { + var flags = new Dictionary + { + ["exposure-flag"] = CreateExposureFlag() + }; + + List events = new List(); + var evaluator = new FeatureFlagsEvaluator((e) => events.Add(e), new ServerConfiguration { Flags = flags }); + var ctx = new EvaluationContext("user-123"); + + var result = evaluator.Evaluate("exposure-flag", "default", ctx); + + Assert.Equal("tracked-value", result.Value); + Assert.Equal(EvaluationReason.TARGETING_MATCH, result.Reason); + Assert.Equal("tracked", result.Variant); + + // DoLog=true -> one exposure event + Assert.Single(events); + } + + // --------------------------------------------------------------------- + // Helpers to build flags (minimal subset) + // --------------------------------------------------------------------- + + private static Flag CreateSimpleFlag(string key, ValueType type, object value, string variantKey) + { + var variants = new Dictionary + { + [variantKey] = new Variant { Key = variantKey, Value = (string)value }, + }; + + var splits = new List + { + new Split { Shards = new List(), VariationKey = variantKey } + }; + + var allocations = new List + { + new Allocation { Key = "alloc1", Splits = splits, DoLog = false } + }; + + return new Flag { Key = key, Enabled = true, VariationType = type, Variations = variants, Allocations = allocations }; + } + + private static Flag CreateRuleBasedFlag() + { + var variants = new Dictionary + { + ["premium"] = new Variant { Key = "premium", Value = "premium" }, + ["basic"] = new Variant { Key = "basic", Value = "basic" }, + }; + + var premiumConditions = new List + { + new ConditionConfiguration { Operator = ConditionOperator.MATCHES, Attribute = "email", Value = "@company\\.com$" }, + }; + + var premiumRules = new List { new Rule(premiumConditions) }; + var premiumSplits = new List { new Split { Shards = new List(), VariationKey = "premium" } }; + var premiumAlloc = new Allocation { Key = "premium-alloc", Rules = premiumRules, Splits = premiumSplits, DoLog = false }; + + var basicSplits = new List { new Split { Shards = new List(), VariationKey = "basic" } }; + var basicAlloc = new Allocation { Key = "basic-alloc", Splits = basicSplits, DoLog = false }; + + return new Flag { Key = "rule-based-flag", Enabled = true, VariationType = ValueType.STRING, Variations = variants, Allocations = new List { premiumAlloc, basicAlloc } }; + } + + private static Flag CreateNumericRuleFlag() + { + var variants = new Dictionary + { + ["vip"] = new Variant("vip", "vip"), + ["regular"] = new Variant("regular", "regular") + }; + + var vipConditions = new List + { + new ConditionConfiguration { Operator = ConditionOperator.GTE, Attribute = "score", Value = 800 }, + }; + + var vipRules = new List { new Rule(vipConditions) }; + var vipSplits = new List { new Split { Shards = new List(), VariationKey = "vip" } }; + var vipAlloc = new Allocation { Key = "vip-alloc", Rules = vipRules, Splits = vipSplits, DoLog = false }; + + var regularSplits = new List { new Split { Shards = new List(), VariationKey = "regular" } }; + var regularAlloc = new Allocation { Key = "regular-alloc", Splits = regularSplits, DoLog = false }; + + return new Flag { Key = "numeric-rule-flag", Enabled = true, VariationType = ValueType.STRING, Variations = variants, Allocations = new List { vipAlloc, regularAlloc } }; + } + + private static Flag CreateTimeBasedFlag() + { + var variants = new Dictionary + { + ["time-limited"] = new Variant("time-limited", "time-limited") + }; + + var splits = new List { new Split { Shards = new List(), VariationKey = "time-limited" } }; + var alloc = new Allocation { Key = "time-alloc", StartAt = "2022-01-01T00:00:00Z", EndAt = "2022-12-31T23:59:59Z", Splits = splits, DoLog = false }; + + return new Flag { Key = "time-based-flag", Enabled = true, VariationType = ValueType.STRING, Variations = variants, Allocations = new List { alloc } }; + } + + private static Flag CreateExposureFlag() + { + var variants = new Dictionary + { + ["tracked"] = new Variant("tracked", "tracked-value") + }; + + var splits = new List { new Split { VariationKey = "tracked", Shards = new List() } }; + var alloc = new Allocation { Key = "exposure-alloc", Splits = splits, DoLog = true }; + + return new Flag { Key = "exposure-flag", Enabled = true, VariationType = ValueType.STRING, Variations = variants, Allocations = new List { alloc } }; + } +} +#pragma warning restore SA1204 // Static elements should appear before instance elements +#pragma warning restore SA1500 // Braces for multi-line statements should not share line From 45e8bd28322ff1239e50074f4c03f0c0638f39bd Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Mon, 1 Dec 2025 18:15:00 +0100 Subject: [PATCH 02/54] Support for context flattening --- .../FeatureFlags/FeatureFlagsEvaluator.cs | 14 +++-- .../FeatureFlagsEvaluatorTests.cs | 56 ++++++++++++++++++- 2 files changed, 62 insertions(+), 8 deletions(-) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index e8938fc1757a..e98c546bbb9a 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -496,7 +496,6 @@ internal static T MapValue(object? value) } return default!; - // return (T)(object)Value.ObjectToValue(value); } private static double ParseDouble(object value) @@ -548,13 +547,16 @@ private static double ParseDouble(object value) stack.Push(new FlattenEntry($"{entry.Key}[{i}]", list[i])); } } - - // else if (value.IsStructure()) // Not implemented yet - // { - // } + else if (value is IDictionary dict) + { + foreach (var pairKey in dict.Keys) + { + stack.Push(new FlattenEntry($"{entry.Key}.{pairKey}", dict[pairKey!])); + } + } else { - result[entry.Key] = context.ConvertValue(value); + result[entry.Key] = context.ConvertValue(value) ?? value; } } } diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs index 4bb0500e70bb..6425504401db 100644 --- a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs @@ -9,6 +9,7 @@ using System.Collections.Generic; using Datadog.Trace.FeatureFlags; using Datadog.Trace.FeatureFlags.Rcm.Model; +using Google.Protobuf.WellKnownTypes; using Moq; using Xunit; using ValueType = Datadog.Trace.FeatureFlags.Rcm.Model.ValueType; @@ -181,6 +182,57 @@ public void EvaluateFlagWithoutAllocationsReturnsGeneralError() Assert.Equal("GENERAL", result2.Metadata?["errorCode"]); } + // --------------------------------------------------------------------- + // FlattenContext tests + // --------------------------------------------------------------------- + + public static IEnumerable FlattenContextCases() + { + // empty + yield return new object[] + { + new Dictionary(), + new Dictionary() + }; + + // scalars + yield return new object[] + { + new Dictionary { { "integer", 1 }, { "double", 23d }, { "boolean", true }, { "string", "string" }, { "null", null } }, + new Dictionary { { "integer", 1 }, { "double", 23d }, { "boolean", true }, { "string", "string" }, { "null", null } }, + }; + + // list: [1,2,[4]] + yield return new object[] + { + new Dictionary { { "list", new List { 1, 2, new List { 4 } } } }, + new Dictionary { { "list[0]", 1 }, { "list[1]", 2 }, { "list[2][0]", 4 } }, + }; + + // nested map + yield return new object[] + { + new Dictionary { { "map", new Dictionary { { "key1", 1 }, { "key2", 2 }, { "key3", new Dictionary { { "key4", 4 } } } } } }, + new Dictionary { { "map.key1", 1 }, { "map.key2", 2 }, { "map.key3.key4", 4 } }, + }; + } + + [Theory] + [MemberData(nameof(FlattenContextCases))] + public void FlattenContextFlattensListsAndDictionarys(Dictionary attrs, Dictionary expected) + { + var ctx = new EvaluationContext("structure", attrs); + var flattened = FeatureFlagsEvaluator.FlattenContext(ctx); + + Assert.Equal(expected.Count, flattened.Count); + + foreach (var pair in expected) + { + Assert.True(flattened.TryGetValue(pair.Key, out var actual)); + Assert.Equal(pair.Value, actual); + } + } + // --------------------------------------------------------------------- // Happy-path evaluation + rule-based + numeric + exposure // These are example slices; you can easily add more tests in same style. @@ -213,7 +265,7 @@ public void EvaluateRuleBasedFlagMatchesEmailPremium() }; var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); - var ctx = new EvaluationContext("user-premium", new Dictionary { { "email", "john@company.com" } }); + var ctx = new EvaluationContext("user-premium", new Dictionary { { "email", "john@company.com" } }); var result = evaluator.Evaluate("rule-based-flag", "default", ctx); @@ -231,7 +283,7 @@ public void EvaluateNumericRuleFlagMatchesScoreGte800() }; var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); - var ctx = new EvaluationContext("user-vip", new Dictionary { { "score", 850 } }); + var ctx = new EvaluationContext("user-vip", new Dictionary { { "score", 850 } }); var result = evaluator.Evaluate("numeric-rule-flag", "default", ctx); From a79998de06e87c1769b5a2ec67225b7d7e149dd9 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Wed, 3 Dec 2025 12:46:05 +0100 Subject: [PATCH 03/54] Integration tests seed --- Datadog.Trace.Samples.g.sln | 23 +++ Datadog.Trace.sln | 32 +++- tracer/build/supported_calltargets.g.json | 49 ++++++ .../Datadog.Trace.Manual.csproj | 3 + .../FeatureFlags/FeatureFlagsSdk.cs | 38 +++++ .../FeatureFlagsSdkEvaluateIntegration.cs | 48 ++++++ .../FeatureFlagsSdkIsAvailableIntegration.cs | 36 +++++ .../Datadog.Trace/FeatureFlags/Evaluation.cs | 7 +- .../FeatureFlags/EvaluationContext.cs | 5 +- .../FeatureFlags/EvaluationReason.cs | 46 +++--- .../FeatureFlags/FeatureFlagsEvaluator.cs | 69 +++++---- .../FeatureFlags/FeatureFlagsModule.cs | 13 +- .../Datadog.Trace/FeatureFlags/IEvaluation.cs | 34 +++++ .../FeatureFlags/IEvaluationContext.cs | 23 +++ .../InstrumentationDefinitions.g.cs | 2 + .../InstrumentationDefinitions.g.cs | 2 + .../InstrumentationDefinitions.g.cs | 2 + .../InstrumentationDefinitions.g.cs | 2 + .../FeatureFlags/FeatureFlagsTests.cs | 142 ++++++++++++++++++ .../Datadog.Trace.IntegrationTests.csproj | 4 + .../FeatureFlagsEvaluatorTests.cs | 4 +- .../Samples.FeatureFlags/Program.cs | 18 +++ .../Samples.FeatureFlags.csproj | 18 +++ .../Samples.OpenFeature-2.9/Program.cs | 2 + .../Samples.OpenFeature-2.9.csproj | 19 +++ 25 files changed, 578 insertions(+), 63 deletions(-) create mode 100644 tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs create mode 100644 tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs create mode 100644 tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkIsAvailableIntegration.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/IEvaluation.cs create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs create mode 100644 tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs create mode 100644 tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs create mode 100644 tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Samples.FeatureFlags.csproj create mode 100644 tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs create mode 100644 tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj diff --git a/Datadog.Trace.Samples.g.sln b/Datadog.Trace.Samples.g.sln index 4efa4b7a2d2a..7a8c01fea6c3 100644 --- a/Datadog.Trace.Samples.g.sln +++ b/Datadog.Trace.Samples.g.sln @@ -129,6 +129,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Generated", "Generated", "{ tracer\build\supported_calltargets.g.json = tracer\build\supported_calltargets.g.json EndProjectSection EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "feature-flags", "feature-flags", "{D0C69381-F696-4113-BE7E-BA43468F431C}" + ProjectSection(SolutionItems) = preProject + EndProjectSection +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Samples.ExampleLibrary", "tracer\test\test-applications\integrations\dependency-libs\Samples.ExampleLibrary\Samples.ExampleLibrary.csproj", "{FDB5C8D0-018D-4FF9-9680-C6A5078F819B}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Samples.ExampleLibraryTracer", "tracer\test\test-applications\integrations\dependency-libs\Samples.ExampleLibraryTracer\Samples.ExampleLibraryTracer.csproj", "{4B243CF1-4269-45C6-A238-1A9BFA58B8CC}" @@ -447,6 +451,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.Quartz", "tracer\te EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.AzureFunctions.V4Isolated.HostLogsDisabled", "tracer\test\test-applications\azure-functions\Samples.AzureFunctions.V4Isolated.HostLogsDisabled\Samples.AzureFunctions.V4Isolated.HostLogsDisabled.csproj", "{C770F9F8-0430-587D-EB7A-8BEC2FE9B61C}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.FeatureFlags", "tracer\test\test-applications\feature-flags\Samples.FeatureFlags\Samples.FeatureFlags.csproj", "{D5A8ABB9-CB23-974E-F338-5D9172D96CD8}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.OpenFeature-2.9", "tracer\test\test-applications\feature-flags\Samples.OpenFeature-2.9\Samples.OpenFeature-2.9.csproj", "{021D714E-1764-D76B-15B5-C9114FE934C2}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -957,6 +965,10 @@ Global {56DE0D44-E9E5-48DA-BAEA-2934B1E28D4E}.Debug|Any CPU.Build.0 = Debug|Any CPU {56DE0D44-E9E5-48DA-BAEA-2934B1E28D4E}.Release|Any CPU.ActiveCfg = Release|Any CPU {56DE0D44-E9E5-48DA-BAEA-2934B1E28D4E}.Release|Any CPU.Build.0 = Release|Any CPU + {BC44A41F-1BED-4438-9F66-0EA5607906D7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {BC44A41F-1BED-4438-9F66-0EA5607906D7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {BC44A41F-1BED-4438-9F66-0EA5607906D7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {BC44A41F-1BED-4438-9F66-0EA5607906D7}.Release|Any CPU.Build.0 = Release|Any CPU {D59C5649-BE0E-4A33-B868-B652D8614534}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {D59C5649-BE0E-4A33-B868-B652D8614534}.Debug|Any CPU.Build.0 = Debug|Any CPU {D59C5649-BE0E-4A33-B868-B652D8614534}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -1073,6 +1085,14 @@ Global {C770F9F8-0430-587D-EB7A-8BEC2FE9B61C}.Debug|Any CPU.Build.0 = Debug|Any CPU {C770F9F8-0430-587D-EB7A-8BEC2FE9B61C}.Release|Any CPU.ActiveCfg = Release|Any CPU {C770F9F8-0430-587D-EB7A-8BEC2FE9B61C}.Release|Any CPU.Build.0 = Release|Any CPU + {D5A8ABB9-CB23-974E-F338-5D9172D96CD8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D5A8ABB9-CB23-974E-F338-5D9172D96CD8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D5A8ABB9-CB23-974E-F338-5D9172D96CD8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D5A8ABB9-CB23-974E-F338-5D9172D96CD8}.Release|Any CPU.Build.0 = Release|Any CPU + {021D714E-1764-D76B-15B5-C9114FE934C2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {021D714E-1764-D76B-15B5-C9114FE934C2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {021D714E-1764-D76B-15B5-C9114FE934C2}.Release|Any CPU.ActiveCfg = Release|Any CPU + {021D714E-1764-D76B-15B5-C9114FE934C2}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(NestedProjects) = preSolution {9518425A-36A5-4B8F-B0B8-6137DB88441D} = {8CEC2042-F11C-49F5-A674-2355793B600A} @@ -1093,6 +1113,7 @@ Global {16427BFB-B4C6-46A9-A290-8EA51FF73FEA} = {9518425A-36A5-4B8F-B0B8-6137DB88441D} {0884B566-D22E-498C-BAA9-26D50ABCAE3A} = {16427BFB-B4C6-46A9-A290-8EA51FF73FEA} {E1B0F72C-991A-409D-9266-DE5ED1BD940E} = {A0C5FBBB-CFB2-4FB9-B8F0-55676E9DCF06} + {D0C69381-F696-4113-BE7E-BA43468F431C} = {9518425A-36A5-4B8F-B0B8-6137DB88441D} {FDB5C8D0-018D-4FF9-9680-C6A5078F819B} = {8683D82A-2BBE-4199-9C36-C59F48804F90} {4B243CF1-4269-45C6-A238-1A9BFA58B8CC} = {8683D82A-2BBE-4199-9C36-C59F48804F90} {086FF8A0-9CEE-470A-9751-78B0F1340649} = {BAF8F246-3645-42AD-B1D0-0F7EAFBAB34A} @@ -1252,5 +1273,7 @@ Global {59A9EDCD-6892-4817-8957-54DE84BDCAFB} = {BAF8F246-3645-42AD-B1D0-0F7EAFBAB34A} {CF69BC17-1527-425A-9B02-8E223BC31DB8} = {BAF8F246-3645-42AD-B1D0-0F7EAFBAB34A} {C770F9F8-0430-587D-EB7A-8BEC2FE9B61C} = {C4C1E313-C7C1-4490-AECE-0DD0062380A4} + {D5A8ABB9-CB23-974E-F338-5D9172D96CD8} = {D0C69381-F696-4113-BE7E-BA43468F431C} + {021D714E-1764-D76B-15B5-C9114FE934C2} = {D0C69381-F696-4113-BE7E-BA43468F431C} EndGlobalSection EndGlobal diff --git a/Datadog.Trace.sln b/Datadog.Trace.sln index 0a6909c96d58..39bc49be3033 100644 --- a/Datadog.Trace.sln +++ b/Datadog.Trace.sln @@ -1,7 +1,7 @@  Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio Version 17 -VisualStudioVersion = 17.1.31903.286 +# Visual Studio Version 18 +VisualStudioVersion = 18.0.11205.157 MinimumVisualStudioVersion = 15.0.26124.0 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Datadog.Tracer.Native", "tracer\src\Datadog.Tracer.Native\Datadog.Tracer.Native.vcxproj", "{91B6272F-5780-4C94-8071-DBBA7B4F67F3}" ProjectSection(ProjectDependencies) = postProject @@ -625,6 +625,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.Quartz", "tracer\te EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.AzureFunctions.V4Isolated.HostLogsDisabled", "tracer\test\test-applications\azure-functions\Samples.AzureFunctions.V4Isolated.HostLogsDisabled\Samples.AzureFunctions.V4Isolated.HostLogsDisabled.csproj", "{C770F9F8-0430-587D-EB7A-8BEC2FE9B61C}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "feature-flags", "feature-flags", "{D0C69381-F696-4113-BE7E-BA43468F431C}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.FeatureFlags", "tracer\test\test-applications\feature-flags\Samples.FeatureFlags\Samples.FeatureFlags.csproj", "{D5A8ABB9-CB23-974E-F338-5D9172D96CD8}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.OpenFeature-2.9", "tracer\test\test-applications\feature-flags\Samples.OpenFeature-2.9\Samples.OpenFeature-2.9.csproj", "{021D714E-1764-D76B-15B5-C9114FE934C2}" +EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Datadog.Trace.Tools.Analyzers.CodeFixes", "tracer\src\Datadog.Trace.Tools.Analyzers.CodeFixes\Datadog.Trace.Tools.Analyzers.CodeFixes.csproj", "{32521F0A-D52D-4DB1-86C4-3D72DEDA6E55}" EndProject Global @@ -1343,6 +1349,10 @@ Global {56DE0D44-E9E5-48DA-BAEA-2934B1E28D4E}.Debug|Any CPU.Build.0 = Debug|Any CPU {56DE0D44-E9E5-48DA-BAEA-2934B1E28D4E}.Release|Any CPU.ActiveCfg = Release|Any CPU {56DE0D44-E9E5-48DA-BAEA-2934B1E28D4E}.Release|Any CPU.Build.0 = Release|Any CPU + {BC44A41F-1BED-4438-9F66-0EA5607906D7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {BC44A41F-1BED-4438-9F66-0EA5607906D7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {BC44A41F-1BED-4438-9F66-0EA5607906D7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {BC44A41F-1BED-4438-9F66-0EA5607906D7}.Release|Any CPU.Build.0 = Release|Any CPU {B28A33A4-C694-4514-BC30-2680605B0B3D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B28A33A4-C694-4514-BC30-2680605B0B3D}.Debug|Any CPU.Build.0 = Debug|Any CPU {B28A33A4-C694-4514-BC30-2680605B0B3D}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -1507,6 +1517,14 @@ Global {C770F9F8-0430-587D-EB7A-8BEC2FE9B61C}.Debug|Any CPU.Build.0 = Debug|Any CPU {C770F9F8-0430-587D-EB7A-8BEC2FE9B61C}.Release|Any CPU.ActiveCfg = Release|Any CPU {C770F9F8-0430-587D-EB7A-8BEC2FE9B61C}.Release|Any CPU.Build.0 = Release|Any CPU + {D5A8ABB9-CB23-974E-F338-5D9172D96CD8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D5A8ABB9-CB23-974E-F338-5D9172D96CD8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D5A8ABB9-CB23-974E-F338-5D9172D96CD8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D5A8ABB9-CB23-974E-F338-5D9172D96CD8}.Release|Any CPU.Build.0 = Release|Any CPU + {021D714E-1764-D76B-15B5-C9114FE934C2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {021D714E-1764-D76B-15B5-C9114FE934C2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {021D714E-1764-D76B-15B5-C9114FE934C2}.Release|Any CPU.ActiveCfg = Release|Any CPU + {021D714E-1764-D76B-15B5-C9114FE934C2}.Release|Any CPU.Build.0 = Release|Any CPU {32521F0A-D52D-4DB1-86C4-3D72DEDA6E55}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {32521F0A-D52D-4DB1-86C4-3D72DEDA6E55}.Debug|Any CPU.Build.0 = Debug|Any CPU {32521F0A-D52D-4DB1-86C4-3D72DEDA6E55}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -1757,18 +1775,21 @@ Global {59A9EDCD-6892-4817-8957-54DE84BDCAFB} = {BAF8F246-3645-42AD-B1D0-0F7EAFBAB34A} {CF69BC17-1527-425A-9B02-8E223BC31DB8} = {BAF8F246-3645-42AD-B1D0-0F7EAFBAB34A} {C770F9F8-0430-587D-EB7A-8BEC2FE9B61C} = {C4C1E313-C7C1-4490-AECE-0DD0062380A4} + {D0C69381-F696-4113-BE7E-BA43468F431C} = {9518425A-36A5-4B8F-B0B8-6137DB88441D} + {D5A8ABB9-CB23-974E-F338-5D9172D96CD8} = {D0C69381-F696-4113-BE7E-BA43468F431C} + {021D714E-1764-D76B-15B5-C9114FE934C2} = {D0C69381-F696-4113-BE7E-BA43468F431C} {32521F0A-D52D-4DB1-86C4-3D72DEDA6E55} = {9E5F0022-0A50-40BF-AC6A-C3078585ECAB} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {160A1D00-1F5B-40F8-A155-621B4459D78F} EndGlobalSection GlobalSection(SharedMSBuildProjectFiles) = preSolution + tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{021d714e-1764-d76b-15b5-c9114fe934c2}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{021efba6-c4ba-4de5-bf3f-c263ee9e20db}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{061ab58b-8235-4dae-8d56-5f081dd78f5e}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{086ff8a0-9cee-470a-9751-78b0f1340649}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{0980bcdd-a231-42d1-b689-41a41bba161a}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{0c0578cb-3b67-4f95-8547-206cd2a560cd}*SharedItemsImports = 5 - tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{0d996eee-7c04-4888-af48-9c1e2f261a00}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{0df4363a-0df4-4882-a39f-3c9f404b8de5}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{0e036453-2c80-4fc9-a517-771f0071734b}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{0f0f7d45-0e13-42b0-a158-8f303bbe8358}*SharedItemsImports = 5 @@ -1788,7 +1809,6 @@ Global tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{268b6d05-b6d5-4d20-b2b1-0b9422a92d73}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{2a6d3042-c675-4ea3-a8e7-5bdd3c5758ea}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{2ca0d70c-dfc1-458a-871b-328ab6e87e3a}*SharedItemsImports = 5 - tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{2cc63aeb-0098-4d3b-9606-f07692c03e90}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{2d1ff937-3237-4a1b-9c6c-82fa5e22cad7}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{2f3b6271-b9a3-48a3-9db6-847f3ef41f0a}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{303f8e41-691f-4453-ab7d-88a0036c0465}*SharedItemsImports = 5 @@ -1874,6 +1894,8 @@ Global tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{bbad4449-d414-4a20-bca2-de9c40e4a866}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{bbb60b0f-bf01-4499-936a-4a299a9acfd4}*SharedItemsImports = 4 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{bc44a41f-1bed-4438-9f66-0ea5607906d5}*SharedItemsImports = 5 + tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{bc44a41f-1bed-4438-9f66-0ea5607906d6}*SharedItemsImports = 5 + tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{bc44a41f-1bed-4438-9f66-0ea5607906d7}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{bc998acd-353b-4a56-8a56-df6200e141b6}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{bd46efcc-177c-466e-81df-39314b780ada}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{bdee131f-ccf5-49bd-9764-9c4a8864ce4e}*SharedItemsImports = 5 @@ -1891,9 +1913,11 @@ Global tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{c98950b1-dc4b-43da-974f-ef2cf325ec2b}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{ca3d605f-8dd7-4041-b024-70a24036afa1}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{cb56ac5a-d2c1-40de-99d5-dcf9f44c9482}*SharedItemsImports = 5 + tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{cf69bc17-1527-425a-9b02-8e223bc31db8}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{d00ddbda-66f5-490d-8c1c-16cc5e142170}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{d141bd06-dd95-4caf-85cd-657116e0dad4}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{d59c5649-be0e-4a33-b868-b652d8614534}*SharedItemsImports = 5 + tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{d5a8abb9-cb23-974e-f338-5d9172d96cd8}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{d6155f26-8245-4b66-8944-79c3df9f9da3}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{d79491f0-ca92-439b-98ce-7af9f57ebeb0}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{da0a44fb-d562-4776-aafb-8266e78aa1a6}*SharedItemsImports = 5 diff --git a/tracer/build/supported_calltargets.g.json b/tracer/build/supported_calltargets.g.json index c32f0a38a9e5..16c2775d50ca 100644 --- a/tracer/build/supported_calltargets.g.json +++ b/tracer/build/supported_calltargets.g.json @@ -6682,6 +6682,55 @@ "IsAdoNetIntegration": false, "InstrumentationCategory": 1 }, + { + "IntegrationName": "DatadogTraceManual", + "AssemblyName": "Datadog.Trace.Manual", + "TargetTypeName": "Datadog.Trace.FeatureFlags.FeatureFlagsSdk", + "TargetMethodName": "Evaluate", + "TargetReturnType": "Datadog.Trace.FeatureFlags.IEvaluation", + "TargetParameterTypes": [ + "System.String", + "System.Type", + "System.Object", + "Datadog.Trace.FeatureFlags.IEvaluationContext" + ], + "MinimumVersion": { + "Item1": 3, + "Item2": 31, + "Item3": 0 + }, + "MaximumVersion": { + "Item1": 3, + "Item2": 65535, + "Item3": 65535 + }, + "InstrumentationTypeName": "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkEvaluateIntegration", + "IntegrationKind": 0, + "IsAdoNetIntegration": false, + "InstrumentationCategory": 1 + }, + { + "IntegrationName": "DatadogTraceManual", + "AssemblyName": "Datadog.Trace.Manual", + "TargetTypeName": "Datadog.Trace.FeatureFlags.FeatureFlagsSdk", + "TargetMethodName": "IsAvailable", + "TargetReturnType": "System.Boolean", + "TargetParameterTypes": [], + "MinimumVersion": { + "Item1": 3, + "Item2": 31, + "Item3": 0 + }, + "MaximumVersion": { + "Item1": 3, + "Item2": 65535, + "Item3": 65535 + }, + "InstrumentationTypeName": "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkIsAvailableIntegration", + "IntegrationKind": 0, + "IsAdoNetIntegration": false, + "InstrumentationCategory": 1 + }, { "IntegrationName": "DatadogTraceManual", "AssemblyName": "Datadog.Trace.Manual", diff --git a/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj b/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj index df523ed9a80b..81eabaf001d1 100644 --- a/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj +++ b/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj @@ -29,6 +29,9 @@ + + + diff --git a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs new file mode 100644 index 000000000000..7f2f2b635e3a --- /dev/null +++ b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs @@ -0,0 +1,38 @@ +// +// 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.Runtime.CompilerServices; +using Datadog.Trace.SourceGenerators; + +namespace Datadog.Trace.FeatureFlags; + +/// +/// Handlers for setting ASM login success / failures events in traces +/// Includes a security scan if asm is enabled +/// +public static class FeatureFlagsSdk +{ + /// Gets a value indicating wether FeatureFlags framework is available or not + /// True if FeatureFlagsSDK is instrumented + [Instrumented] + [MethodImpl(MethodImplOptions.NoInlining)] + public static bool IsAvailable() => false; + + /// + /// Sets the details of a successful login on the local root span + /// + /// Returns the evaluation result + /// The feature flag key to evaluate + /// The desired result type + /// The default value + /// The evaluation context + [Instrumented] + [MethodImpl(MethodImplOptions.NoInlining)] + public static IEvaluation? Evaluate(string key, Type targetType, object? defaultValue, IEvaluationContext? context) + { + return null; + } +} diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs new file mode 100644 index 000000000000..89814f140944 --- /dev/null +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs @@ -0,0 +1,48 @@ +// +// 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 System.ComponentModel; +using System.IO; +using System.Threading; +using Datadog.Trace.ClrProfiler.CallTarget; +using Datadog.Trace.Configuration; +using Datadog.Trace.FeatureFlags; + +namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual; + +/// +/// Datadog.Trace.FeatureFlags.IEvaluation Datadog.Trace.FeatureFlags.FeatureFlagsSdk::Evaluate(System.String,System.Type,System.Object,Datadog.Trace.FeatureFlags.IEvaluationContext) calltarget instrumentation +/// +[InstrumentMethod( + AssemblyName = "Datadog.Trace.Manual", + TypeName = "Datadog.Trace.FeatureFlags.FeatureFlagsSdk", + MethodName = "Evaluate", + ReturnTypeName = "Datadog.Trace.FeatureFlags.IEvaluation", + ParameterTypeNames = [ClrNames.String, ClrNames.Type, ClrNames.Object, "Datadog.Trace.FeatureFlags.IEvaluationContext"], + MinimumVersion = "3.31.0", + MaximumVersion = "3.*.*", + IntegrationName = nameof(IntegrationId.DatadogTraceManual))] +[Browsable(false)] +[EditorBrowsable(EditorBrowsableState.Never)] +public class FeatureFlagsSdkEvaluateIntegration +{ + internal static CallTargetState OnMethodBegin(ref string key, ref Type targetType, ref object? defaultValue, ref TContext? context) + { + return new CallTargetState(null, new State(key, targetType, defaultValue, context)); + } + + internal static CallTargetReturn OnMethodEnd(TReturn? returnValue, Exception? exception, in CallTargetState state) + { + var parameters = (State)state.State!; + var res = FeatureFlagsModule.Instance.Evaluate(parameters.Key!, parameters.TargetType, parameters.DefaultValue, (EvaluationContext)parameters.Context!); + return new CallTargetReturn(returnValue); + } + + private record struct State(string? Key, Type TargetType, object? DefaultValue, object? Context) + { + } +} diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkIsAvailableIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkIsAvailableIntegration.cs new file mode 100644 index 000000000000..bafd30330d19 --- /dev/null +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkIsAvailableIntegration.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. +// +#nullable enable + +using System; +using System.ComponentModel; +using System.IO; +using System.Threading; +using Datadog.Trace.ClrProfiler.CallTarget; +using Datadog.Trace.Configuration; + +namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual; + +/// +/// System.Boolean Datadog.Trace.FeatureFlags.FeatureFlagsSdk::IsAvailable() calltarget instrumentation +/// +[InstrumentMethod( + AssemblyName = "Datadog.Trace.Manual", + TypeName = "Datadog.Trace.FeatureFlags.FeatureFlagsSdk", + MethodName = "IsAvailable", + ReturnTypeName = ClrNames.Bool, + ParameterTypeNames = [], + MinimumVersion = "3.31.0", + MaximumVersion = "3.*.*", + IntegrationName = nameof(IntegrationId.DatadogTraceManual))] +[Browsable(false)] +[EditorBrowsable(EditorBrowsableState.Never)] +public class FeatureFlagsSdkIsAvailableIntegration +{ + internal static CallTargetReturn OnMethodEnd(bool returnValue, Exception? exception, in CallTargetState state) + { + return new CallTargetReturn(true); + } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs b/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs index 6162b5537e93..7b7afbd483b1 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs @@ -14,9 +14,10 @@ namespace Datadog.Trace.FeatureFlags { - internal class Evaluation(T value, EvaluationReason reason, string? variant = null, string? error = null, Dictionary? metadata = null) + internal class Evaluation(object? value, EvaluationReason reason, string? variant = null, string? error = null, IDictionary? metadata = null) + : IEvaluation { - public T Value { get; } = value; + public object? Value { get; } = value; public EvaluationReason Reason { get; } = reason; @@ -24,6 +25,6 @@ internal class Evaluation(T value, EvaluationReason reason, string? variant = public string? Error { get; } = error; - public Dictionary? Metadata { get; } = metadata; + public IDictionary? Metadata { get; } = metadata; } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs index c47593c33568..82a5f9cae9c2 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs @@ -10,13 +10,14 @@ namespace Datadog.Trace.FeatureFlags { - internal class EvaluationContext(string key, Dictionary? values = null, Func? convertValue = null) + internal class EvaluationContext(string key, IDictionary? values = null, Func? convertValue = null) + : IEvaluationContext { private readonly Func? _convertValue = convertValue; public string TargetingKey { get; } = key; - public Dictionary Values { get; } = values ?? new Dictionary(); + public IDictionary Values { get; } = values ?? new Dictionary(); public object? GetValue(string key) { diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationReason.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationReason.cs index 0009b01c3d85..9714dcd5b94b 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationReason.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationReason.cs @@ -5,24 +5,32 @@ #nullable enable -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; -using System.Web; - -namespace Datadog.Trace.FeatureFlags +namespace Datadog.Trace.FeatureFlags; + +/// Evaluation result reason +public enum EvaluationReason { - internal enum EvaluationReason - { - DEFAULT, - STATIC, - TARGETING_MATCH, - SPLIT, - DISABLED, - CACHED, - UNKNOWN, - ERROR - } + /// Default value + DEFAULT, + + /// Static value + STATIC, + + /// Targeting match + TARGETING_MATCH, + + /// Split match + SPLIT, + + /// Target disabled + DISABLED, + + /// Cached result + CACHED, + + /// Unknown reason + UNKNOWN, + + /// Error + ERROR } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index e98c546bbb9a..7b45e47ccc2c 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -52,14 +52,19 @@ public FeatureFlagsEvaluator(Action? onExposureEvent, Se private delegate bool NumberEquality(double a, double b); - public Evaluation Evaluate(string key, T defaultValue, EvaluationContext context) + public Evaluation Evaluate(string key, T defaultValue, EvaluationContext context) + { + return Evaluate(key, typeof(T), defaultValue, context); + } + + public Evaluation Evaluate(string key, Type resultType, object? defaultValue, EvaluationContext context) { try { var config = _config; if (config == null) { - return new Evaluation( + return new Evaluation( defaultValue, EvaluationReason.ERROR, error: "PROVIDER_NOT_READY", @@ -71,7 +76,7 @@ public Evaluation Evaluate(string key, T defaultValue, EvaluationContext c if (context == null) { - return new Evaluation( + return new Evaluation( defaultValue, EvaluationReason.ERROR, error: "INVALID_CONTEXT", @@ -83,7 +88,7 @@ public Evaluation Evaluate(string key, T defaultValue, EvaluationContext c if (string.IsNullOrEmpty(context.TargetingKey)) { - return new Evaluation( + return new Evaluation( defaultValue, EvaluationReason.ERROR, error: "TARGETING_KEY_MISSING", @@ -95,7 +100,7 @@ public Evaluation Evaluate(string key, T defaultValue, EvaluationContext c if (config.Flags is null || !config.Flags.TryGetValue(key, out var flag) || flag is null) { - return new Evaluation( + return new Evaluation( defaultValue, EvaluationReason.ERROR, error: "FLAG_NOT_FOUND", @@ -107,14 +112,14 @@ public Evaluation Evaluate(string key, T defaultValue, EvaluationContext c if (!flag.Enabled is true) { - return new Evaluation( + return new Evaluation( defaultValue, EvaluationReason.DISABLED); } if (flag.Allocations is { Count: 0 }) { - return new Evaluation( + return new Evaluation( defaultValue, EvaluationReason.ERROR, error: "Missing allocations", @@ -149,7 +154,7 @@ public Evaluation Evaluate(string key, T defaultValue, EvaluationContext c { if (split.Shards is { Count: 0 }) { - return ResolveVariant(key, defaultValue, flag, split.VariationKey ?? string.Empty, allocation, context); + return ResolveVariant(key, resultType, defaultValue, flag, split.VariationKey ?? string.Empty, allocation, context); } var allShardsMatch = true; @@ -164,21 +169,21 @@ public Evaluation Evaluate(string key, T defaultValue, EvaluationContext c if (allShardsMatch) { - return ResolveVariant(key, defaultValue, flag, split.VariationKey ?? string.Empty, allocation, context); + return ResolveVariant(key, resultType, defaultValue, flag, split.VariationKey ?? string.Empty, allocation, context); } } } } // No allocation / split matched – use default - return new Evaluation( + return new Evaluation( defaultValue, EvaluationReason.DEFAULT); } catch (FormatException ex) { Log.Debug(ex, "Evaluation failed for key {Key}", key); - return new Evaluation( + return new Evaluation( defaultValue, EvaluationReason.ERROR, error: "TYPE_MISMATCH", @@ -190,7 +195,7 @@ public Evaluation Evaluate(string key, T defaultValue, EvaluationContext c catch (Exception ex) { Log.Debug(ex, "Evaluation failed for key {Key}", key); - return new Evaluation( + return new Evaluation( defaultValue, EvaluationReason.ERROR, error: ex.Message, @@ -444,15 +449,18 @@ private static string GetMd5Hash(string input) return context.ConvertValue(resolved) ?? resolved; } - internal static T MapValue(object? value) + internal static object? MapValue(object? value) + { + return MapValue(typeof(T), value); + } + + internal static object? MapValue(Type target, object? value) { if (value is null) { return default!; } - var target = typeof(T); - if (!SupportedResolutionTypes.Contains(target)) { throw new ArgumentException($"Type not supported: {target}"); @@ -460,12 +468,12 @@ internal static T MapValue(object? value) if (target.IsInstanceOfType(value)) { - return (T)value; + return Convert.ChangeType(value, target); } if (target == typeof(string)) { - return (T)(object)Convert.ToString(value, CultureInfo.InvariantCulture)!; + return Convert.ToString(value, CultureInfo.InvariantCulture); } if (target == typeof(bool)) @@ -474,25 +482,25 @@ internal static T MapValue(object? value) { if (value is IFormattable && value is not bool) { - return (T)(object)(ParseDouble(value) != 0); + return (ParseDouble(value) != 0); } - return (T)(object)Convert.ToBoolean(value); + return Convert.ToBoolean(value); } - return (T)(object)bool.Parse(value.ToString()!); + return bool.Parse(value.ToString()!); } if (target == typeof(int)) { var number = ParseDouble(value); - return (T)(object)(int)number; + return (int)number; } if (target == typeof(double)) { var number = ParseDouble(value); - return (T)(object)number; + return (double)number; } return default!; @@ -508,7 +516,7 @@ private static double ParseDouble(object value) return double.Parse(Convert.ToString(value)!); } - private static string? AllocationKey(Evaluation evaluation) + private static string? AllocationKey(Evaluation evaluation) { if (evaluation.Metadata == null) { @@ -565,9 +573,10 @@ private static double ParseDouble(object value) return result; } - private Evaluation ResolveVariant( + private Evaluation ResolveVariant( string key, - T defaultValue, + Type resultType, + object? defaultValue, Flag flag, string variationKey, Allocation allocation, @@ -575,7 +584,7 @@ private Evaluation ResolveVariant( { if (flag.Variations is null || !flag.Variations.TryGetValue(variationKey, out var variant) || variant == null) { - return new Evaluation( + return new Evaluation( defaultValue, EvaluationReason.ERROR, error: $"Variant not found for: {variationKey}", @@ -586,7 +595,7 @@ private Evaluation ResolveVariant( }); } - var mappedValue = MapValue(variant.Value); + var mappedValue = MapValue(resultType, variant.Value); var metadata = new Dictionary { @@ -595,7 +604,7 @@ private Evaluation ResolveVariant( ["allocationKey"] = allocation.Key ?? string.Empty }; - var evaluation = new Evaluation( + var evaluation = new Evaluation( mappedValue, EvaluationReason.TARGETING_MATCH, variant: variant.Key, @@ -610,9 +619,9 @@ private Evaluation ResolveVariant( return evaluation; } - private void DispatchExposure( + private void DispatchExposure( string flag, - Evaluation evaluation, + Evaluation evaluation, EvaluationContext context) { var allocationKey = AllocationKey(evaluation); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index b495da5a0c22..ee911046578e 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -14,6 +14,7 @@ using Datadog.Trace.AppSec.Rcm.Models.AsmFeatures; using Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcAspNetCoreServer; using Datadog.Trace.Configuration; +using Datadog.Trace.Debugger.Configurations; using Datadog.Trace.FeatureFlags.Exposure; using Datadog.Trace.FeatureFlags.Rcm; using Datadog.Trace.FeatureFlags.Rcm.Model; @@ -29,8 +30,8 @@ internal class FeatureFlagsModule private static FeatureFlagsModule? _instance; private static bool _globalInstanceInitialized; private static object _globalInstanceLock = new(); + private static bool _enabled = false; - private readonly TracerSettings _settings; private readonly IRcmSubscriptionManager _rcmSubscriptionManager; private ISubscription? _rcmSubscription = null; private FfeProduct? _ffeProduct = null; @@ -51,11 +52,11 @@ public FeatureFlagsModule(IRcmSubscriptionManager? rcmSubscriptionManager = null internal FeatureFlagsModule(TracerSettings settings, IRcmSubscriptionManager? rcmSubscriptionManager = null) { - _settings = settings; _rcmSubscriptionManager = rcmSubscriptionManager ?? RcmSubscriptionManager.Instance; if (settings.IsFlaggingProviderEnabled) { + _enabled = true; _ffeProduct = new FfeProduct(UpdateConfig); _rcmSubscription = new Subscription(_ffeProduct.UpdateFromRcm, RcmProducts.FfeFlags); _rcmSubscriptionManager.SubscribeToChanges(_rcmSubscription); @@ -82,8 +83,14 @@ public static FeatureFlagsModule Instance public long Timeout { get; set; } = 1000; - private void ApplyServerConfigs() + internal Evaluation? Evaluate(string key, Type resultType, object? defaultValue, EvaluationContext context) { + if (!_enabled) + { + return new Evaluation(null, EvaluationReason.ERROR, null, "FeatureFlagsSdk is disabled"); + } + + return _evaluator?.Evaluate(key, resultType, defaultValue, context); } private void UpdateConfig(List> list) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluation.cs b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluation.cs new file mode 100644 index 000000000000..08368d5dd097 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluation.cs @@ -0,0 +1,34 @@ +// +// 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 System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Web; + +namespace Datadog.Trace.FeatureFlags; + +/// FeatureFlag Evaluation result. +public partial interface IEvaluation +{ + /// Gets the evaluation result + object? Value { get; } + + /// Gets the evaluation result reason + EvaluationReason Reason { get; } + + /// Gets the evaluation result variant + string? Variant { get; } + + /// Gets the evaluation error + string? Error { get; } + + /// Gets the evaluation metadata + IDictionary? Metadata { get; } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs new file mode 100644 index 000000000000..7f6c3dd3103d --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.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. +// + +#nullable enable + +using System.Collections.Generic; + +namespace Datadog.Trace.FeatureFlags; + +/// FeatureFlag Evaluation result. +public partial interface IEvaluationContext +{ + /// Gets the tareting key. + string TargetingKey { get; } + + /// Gets context values. + public IDictionary Values { get; } + + /// Custom value converter. + object? ConvertValue(object? value); +} diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs index b29b34646637..f321b6b645c0 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs @@ -306,6 +306,8 @@ internal static bool IsInstrumentedAssembly(string assemblyName) or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.PopulateDictionaryIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.DiagnosticSourceEnabledSetIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetTraceSamplingPriorityIntegration" + or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkEvaluateIntegration" + or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkIsAvailableIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorConstructorIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIncludingDsmIntegration" diff --git a/tracer/src/Datadog.Trace/Generated/net6.0/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs b/tracer/src/Datadog.Trace/Generated/net6.0/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs index 010b6e403ffc..4bdb61131d69 100644 --- a/tracer/src/Datadog.Trace/Generated/net6.0/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net6.0/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs @@ -325,6 +325,8 @@ internal static bool IsInstrumentedAssembly(string assemblyName) or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.PopulateDictionaryIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.DiagnosticSourceEnabledSetIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetTraceSamplingPriorityIntegration" + or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkEvaluateIntegration" + or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkIsAvailableIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorConstructorIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIncludingDsmIntegration" diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs index e7d9123dc9ba..6706fa879175 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs @@ -321,6 +321,8 @@ internal static bool IsInstrumentedAssembly(string assemblyName) or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.PopulateDictionaryIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.DiagnosticSourceEnabledSetIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetTraceSamplingPriorityIntegration" + or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkEvaluateIntegration" + or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkIsAvailableIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorConstructorIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIncludingDsmIntegration" diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs index e7d9123dc9ba..6706fa879175 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs @@ -321,6 +321,8 @@ internal static bool IsInstrumentedAssembly(string assemblyName) or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.PopulateDictionaryIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.DiagnosticSourceEnabledSetIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetTraceSamplingPriorityIntegration" + or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkEvaluateIntegration" + or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkIsAvailableIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorConstructorIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIncludingDsmIntegration" diff --git a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs new file mode 100644 index 000000000000..627ae43e76e3 --- /dev/null +++ b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs @@ -0,0 +1,142 @@ +// +// 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.Linq; +using System.Runtime.InteropServices; +using System.Threading.Tasks; +using Datadog.Trace.Configuration; +using Datadog.Trace.TestHelpers; +using FluentAssertions; +using FluentAssertions.Execution; +using VerifyXunit; +using Xunit; +using Xunit.Abstractions; + +namespace Datadog.Trace.ClrProfiler.IntegrationTests; + +#if NETFRAMEWORK +// The .NET Framework tests use NGEN which is a global thing, so make sure we don't parallelize +// Include these tests in the ManualInstrumentation batch +[Collection(nameof(ManualInstrumentationTests))] +#endif +[UsesVerify] +public class FeatureFlagsTests : TestHelper +{ + public FeatureFlagsTests(ITestOutputHelper output) + : base("FeatureFlags", output) + { + } + + [SkippableFact] + [Trait("RunOnWindows", "True")] + public async Task EnabledNoConfig() + { + var output = await RunTest(); + Assert.NotNull(output); + } + + /* + [SkippableFact] + [Trait("RunOnWindows", "True")] + public async Task ManualAndAutomatic() => await RunTest(usePublishWithRID: false); + + #if NETFRAMEWORK + [SkippableFact] + [Trait("RunOnWindows", "True")] + public async Task NGenRunManualAndAutomatic() + { + SetEnvironmentVariable("READY2RUN_ENABLED", "1"); + var sampleAppPath = EnvironmentHelper.GetSampleApplicationPath(); + NgenHelper.InstallToNativeImageCache(Output, sampleAppPath); + try + { + await RunTest(usePublishWithRID: false); + } + finally + { + NgenHelper.UninstallFromNativeImageCache(Output, sampleAppPath); + } + } + #else + [SkippableFact] + [Trait("RunOnWindows", "True")] + public async Task ReadyToRunManualAndAutomatic() + { + #if NET9_0_OR_GREATER + // OK, I know, this is weird, but AFAICT they changed the host FX lookup logic in .NET 9, + // and for some reason it doesn't seem to work properly in this _one_specific case... + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) + && Environment.GetEnvironmentVariable("DOTNET_EXE_32") is { } dotnet32BitExe) + { + var root = Path.GetDirectoryName(dotnet32BitExe); + SetEnvironmentVariable("DOTNET_ROOT(x86)", root); + } + #endif + #if !NET6_0_OR_GREATER + // osx-arm64 doesn't work with Ready2Run + SkipOn.PlatformAndArchitecture(SkipOn.PlatformValue.MacOs, SkipOn.ArchitectureValue.ARM64); + #endif + SetEnvironmentVariable("READY2RUN_ENABLED", "1"); + await RunTest(usePublishWithRID: true); + } + #endif + + [SkippableFact] + [Trait("RunOnWindows", "True")] + public async Task ManualOnly() + { + SetEnvironmentVariable("AUTO_INSTRUMENT_ENABLED", "0"); + EnvironmentHelper.SetAutomaticInstrumentation(false); + // with automatic instrumentation disabled, we don't expect _any_ spans + using var telemetry = this.ConfigureTelemetry(); + using var agent = EnvironmentHelper.GetMockAgent(); + using var assert = new AssertionScope(); + using var process = await RunSampleAndWaitForExit(agent); + + var spans = await agent.WaitForSpansAsync(0, timeoutInMilliseconds: 500); + spans.Should().BeEmpty(); + } + */ + + private async Task RunTest(bool usePublishWithRID = false) + { + SetEnvironmentVariable("DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED", "1"); + using var telemetry = this.ConfigureTelemetry(); + using var agent = EnvironmentHelper.GetMockAgent(); + using var assert = new AssertionScope(); + using var process = await RunSampleAndWaitForExit(agent, usePublishWithRID: usePublishWithRID); + + return process.StandardOutput.ToString(); + +/* + const int expectedSpans = 47; + var spans = await agent.WaitForSpansAsync(expectedSpans); + spans.Should().HaveCount(expectedSpans); + + var settings = VerifyHelper.GetSpanVerifierSettings(); + settings.UseMethodName(nameof(ManualAndAutomatic)); // they should be identical, so share + settings.DisableRequireUniquePrefix(); + + await VerifyHelper.VerifySpans(spans, settings); + + // telemetry should contain "code" config when it's set manually in code + // this just verifies we have values for all the settings we call, + // without being too rigid about the exact values to avoid fragility + var allConfig = TelemetryHelper.GetAllConfigurationPayloads(telemetry.Telemetry) + .SelectMany(x => x) + .Where(x => x.Origin == "code") + .Select(x => x.Name); + + allConfig.Should().Contain([ + ConfigurationKeys.DebugEnabled, + ConfigurationKeys.ServiceName, + ConfigurationKeys.Environment, + ConfigurationKeys.GlobalTags, + ]); +*/ + } +} diff --git a/tracer/test/Datadog.Trace.IntegrationTests/Datadog.Trace.IntegrationTests.csproj b/tracer/test/Datadog.Trace.IntegrationTests/Datadog.Trace.IntegrationTests.csproj index 01245785b1e9..29e95d469127 100644 --- a/tracer/test/Datadog.Trace.IntegrationTests/Datadog.Trace.IntegrationTests.csproj +++ b/tracer/test/Datadog.Trace.IntegrationTests/Datadog.Trace.IntegrationTests.csproj @@ -70,4 +70,8 @@ + + + + diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs index 6425504401db..209c2bb09950 100644 --- a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs @@ -155,7 +155,7 @@ public void EvaluateDisabledFlagReturnsDisabledReason() var result = evaluator.Evaluate("disabled-flag", true, ctx); - Assert.True(result.Value); + Assert.Equal(true, result.Value); Assert.Equal(EvaluationReason.DISABLED, result.Reason); Assert.Null(result.Error); } @@ -186,7 +186,7 @@ public void EvaluateFlagWithoutAllocationsReturnsGeneralError() // FlattenContext tests // --------------------------------------------------------------------- - public static IEnumerable FlattenContextCases() + public static IEnumerable FlattenContextCases() { // empty yield return new object[] diff --git a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs new file mode 100644 index 000000000000..3b5b53e27ce0 --- /dev/null +++ b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs @@ -0,0 +1,18 @@ +// See https://aka.ms/new-console-template for more information +Console.WriteLine("FeatureFlags SDK Sample"); + +var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate("DD_Enabled", "Not found", null); + +if (evaluation is null) +{ + Console.WriteLine($"Eval (DD_Enabled) : "); +} +else if (evaluation.Error is not null) +{ + Console.WriteLine($"Eval (DD_Enabled) : "); +} +else +{ + Console.WriteLine($"Eval (DD_Enabled) : "}>"); +} + diff --git a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Samples.FeatureFlags.csproj b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Samples.FeatureFlags.csproj new file mode 100644 index 000000000000..13e433dae186 --- /dev/null +++ b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Samples.FeatureFlags.csproj @@ -0,0 +1,18 @@ + + + + Exe + net10.0 + Samples.FeatureFlags + enable + enable + + + + + + + + + + diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs new file mode 100644 index 000000000000..3751555cbd32 --- /dev/null +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs @@ -0,0 +1,2 @@ +// See https://aka.ms/new-console-template for more information +Console.WriteLine("Hello, World!"); diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj new file mode 100644 index 000000000000..4815b05d3828 --- /dev/null +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj @@ -0,0 +1,19 @@ + + + + Exe + net10.0 + Samples.OpenFeature_2._9 + enable + enable + + + + + + + + + + + From f664ea5423c9fda47d7cbeae70a363068d08411f Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Wed, 3 Dec 2025 13:59:44 +0100 Subject: [PATCH 04/54] Integration tests update and bug fixes --- tracer/build/supported_calltargets.g.json | 24 ++++++++++++ .../FeatureFlags/FeatureFlagsSdk.cs | 8 ++++ .../build/Datadog.Trace.Trimming.xml | 3 ++ ...isterOnNewConfigEventHandlerIntegration.cs | 38 +++++++++++++++++++ .../FeatureFlags/FeatureFlagsModule.cs | 24 ++++++++++-- .../InstrumentationDefinitions.g.cs | 1 + .../InstrumentationDefinitions.g.cs | 1 + .../InstrumentationDefinitions.g.cs | 1 + .../InstrumentationDefinitions.g.cs | 1 + .../FeatureFlags/FeatureFlagsTests.cs | 4 ++ .../Samples.FeatureFlags/Program.cs | 12 +++++- 11 files changed, 111 insertions(+), 6 deletions(-) create mode 100644 tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs diff --git a/tracer/build/supported_calltargets.g.json b/tracer/build/supported_calltargets.g.json index 16c2775d50ca..f91d394b9dca 100644 --- a/tracer/build/supported_calltargets.g.json +++ b/tracer/build/supported_calltargets.g.json @@ -6731,6 +6731,30 @@ "IsAdoNetIntegration": false, "InstrumentationCategory": 1 }, + { + "IntegrationName": "DatadogTraceManual", + "AssemblyName": "Datadog.Trace.Manual", + "TargetTypeName": "Datadog.Trace.FeatureFlags.FeatureFlagsSdk", + "TargetMethodName": "RegisterOnNewConfigEventHandler", + "TargetReturnType": "System.Void", + "TargetParameterTypes": [ + "System.Action" + ], + "MinimumVersion": { + "Item1": 3, + "Item2": 31, + "Item3": 0 + }, + "MaximumVersion": { + "Item1": 3, + "Item2": 65535, + "Item3": 65535 + }, + "InstrumentationTypeName": "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration", + "IntegrationKind": 0, + "IsAdoNetIntegration": false, + "InstrumentationCategory": 1 + }, { "IntegrationName": "DatadogTraceManual", "AssemblyName": "Datadog.Trace.Manual", diff --git a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs index 7f2f2b635e3a..0b01a200ab05 100644 --- a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs +++ b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs @@ -21,6 +21,14 @@ public static class FeatureFlagsSdk [MethodImpl(MethodImplOptions.NoInlining)] public static bool IsAvailable() => false; + /// Installs an event handler to be fired when a new config has been received + /// Action to be called when the event is fired + [Instrumented] + [MethodImpl(MethodImplOptions.NoInlining)] + public static void RegisterOnNewConfigEventHandler(Action onNewConfig) + { + } + /// /// Sets the details of a successful login on the local root span /// diff --git a/tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml b/tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml index e729b88100d6..a6bea9519727 100644 --- a/tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml +++ b/tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml @@ -231,6 +231,7 @@ + @@ -582,6 +583,8 @@ + + diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs new file mode 100644 index 000000000000..0e8fbbd1e87f --- /dev/null +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs @@ -0,0 +1,38 @@ +// +// 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 System.ComponentModel; +using System.IO; +using System.Threading; +using Datadog.Trace.ClrProfiler.CallTarget; +using Datadog.Trace.Configuration; +using Datadog.Trace.FeatureFlags; + +namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual; + +/// +/// System.Void Datadog.Trace.FeatureFlags.FeatureFlagsSdk::RegisterOnNewConfigEventHandler(System.Action) calltarget instrumentation +/// +[InstrumentMethod( + AssemblyName = "Datadog.Trace.Manual", + TypeName = "Datadog.Trace.FeatureFlags.FeatureFlagsSdk", + MethodName = "RegisterOnNewConfigEventHandler", + ReturnTypeName = ClrNames.Void, + ParameterTypeNames = ["System.Action"], + MinimumVersion = "3.31.0", + MaximumVersion = "3.*.*", + IntegrationName = nameof(IntegrationId.DatadogTraceManual))] +[Browsable(false)] +[EditorBrowsable(EditorBrowsableState.Never)] +public class FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration +{ + internal static CallTargetState OnMethodBegin(ref Action? onNewConfig) + { + FeatureFlagsModule.Instance.RegisterOnNewConfigEventHandler(onNewConfig); + return CallTargetState.GetDefault(); + } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index ee911046578e..2dec6fa2bd67 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -18,6 +18,7 @@ using Datadog.Trace.FeatureFlags.Exposure; using Datadog.Trace.FeatureFlags.Rcm; using Datadog.Trace.FeatureFlags.Rcm.Model; +using Datadog.Trace.Logging; using Datadog.Trace.RemoteConfigurationManagement; using Datadog.Trace.Sampling; using Datadog.Trace.Telemetry; @@ -27,6 +28,8 @@ namespace Datadog.Trace.FeatureFlags { internal class FeatureFlagsModule { + internal static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(FeatureFlagsModule)); + private static FeatureFlagsModule? _instance; private static bool _globalInstanceInitialized; private static object _globalInstanceLock = new(); @@ -35,6 +38,7 @@ internal class FeatureFlagsModule private readonly IRcmSubscriptionManager _rcmSubscriptionManager; private ISubscription? _rcmSubscription = null; private FfeProduct? _ffeProduct = null; + private Action? _onNewConfigEventHander = null; private FeatureFlagsEvaluator? _evaluator = null; @@ -45,8 +49,8 @@ static FeatureFlagsModule() /// /// Initializes a new instance of the class with default settings. /// - public FeatureFlagsModule(IRcmSubscriptionManager? rcmSubscriptionManager = null) - : this(TracerSettings.FromDefaultSourcesInternal(), rcmSubscriptionManager) + public FeatureFlagsModule() + : this(TracerSettings.FromDefaultSourcesInternal(), null) { } @@ -56,6 +60,7 @@ internal FeatureFlagsModule(TracerSettings settings, IRcmSubscriptionManager? rc if (settings.IsFlaggingProviderEnabled) { + Log.Debug("FeatureFlagsModule ENABLED"); _enabled = true; _ffeProduct = new FfeProduct(UpdateConfig); _rcmSubscription = new Subscription(_ffeProduct.UpdateFromRcm, RcmProducts.FfeFlags); @@ -83,14 +88,24 @@ public static FeatureFlagsModule Instance public long Timeout { get; set; } = 1000; - internal Evaluation? Evaluate(string key, Type resultType, object? defaultValue, EvaluationContext context) + internal void RegisterOnNewConfigEventHandler(Action? onNewConfig) + { + _onNewConfigEventHander = onNewConfig; + } + + internal Evaluation Evaluate(string key, Type resultType, object? defaultValue, EvaluationContext context) { if (!_enabled) { return new Evaluation(null, EvaluationReason.ERROR, null, "FeatureFlagsSdk is disabled"); } - return _evaluator?.Evaluate(key, resultType, defaultValue, context); + if (_evaluator is null) + { + return new Evaluation(null, EvaluationReason.ERROR, null, "No config loaded"); + } + + return _evaluator.Evaluate(key, resultType, defaultValue, context); } private void UpdateConfig(List> list) @@ -99,6 +114,7 @@ private void UpdateConfig(List> list) if (list.Count > 0) { _evaluator = new FeatureFlagsEvaluator(ReportExposure, list[0].Value, Timeout); + _onNewConfigEventHander?.Invoke(); } } diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs index f321b6b645c0..15310aa92787 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs @@ -308,6 +308,7 @@ internal static bool IsInstrumentedAssembly(string assemblyName) or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetTraceSamplingPriorityIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkEvaluateIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkIsAvailableIntegration" + or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorConstructorIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIncludingDsmIntegration" diff --git a/tracer/src/Datadog.Trace/Generated/net6.0/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs b/tracer/src/Datadog.Trace/Generated/net6.0/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs index 4bdb61131d69..6dbf68dcdc1d 100644 --- a/tracer/src/Datadog.Trace/Generated/net6.0/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net6.0/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs @@ -327,6 +327,7 @@ internal static bool IsInstrumentedAssembly(string assemblyName) or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetTraceSamplingPriorityIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkEvaluateIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkIsAvailableIntegration" + or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorConstructorIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIncludingDsmIntegration" diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs index 6706fa879175..64330ba7024b 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs @@ -323,6 +323,7 @@ internal static bool IsInstrumentedAssembly(string assemblyName) or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetTraceSamplingPriorityIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkEvaluateIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkIsAvailableIntegration" + or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorConstructorIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIncludingDsmIntegration" diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs index 6706fa879175..64330ba7024b 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/InstrumentationDefinitionsGenerator/InstrumentationDefinitions.g.cs @@ -323,6 +323,7 @@ internal static bool IsInstrumentedAssembly(string assemblyName) or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetTraceSamplingPriorityIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkEvaluateIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkIsAvailableIntegration" + or "Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorConstructorIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIntegration" or "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIncludingDsmIntegration" diff --git a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs index 627ae43e76e3..9d7fe2217eea 100644 --- a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs +++ b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs @@ -35,8 +35,12 @@ public FeatureFlagsTests(ITestOutputHelper output) [Trait("RunOnWindows", "True")] public async Task EnabledNoConfig() { +#pragma warning disable CS0618 // Type or member is obsolete + EnableDebugMode(); +#pragma warning restore CS0618 // Type or member is obsolete var output = await RunTest(); Assert.NotNull(output); + Assert.Contains("", output); } /* diff --git a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs index 3b5b53e27ce0..6bc3c2d25a94 100644 --- a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs +++ b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs @@ -1,11 +1,19 @@ // See https://aka.ms/new-console-template for more information Console.WriteLine("FeatureFlags SDK Sample"); -var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate("DD_Enabled", "Not found", null); +if (!Datadog.Trace.FeatureFlags.FeatureFlagsSdk.IsAvailable()) +{ + Console.WriteLine($""); + return; +} + +Console.WriteLine($""); + +var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate("DD_Enabled", typeof(string), "Not found", null); if (evaluation is null) { - Console.WriteLine($"Eval (DD_Enabled) : "); + Console.WriteLine($"Eval (DD_Enabled) : "); } else if (evaluation.Error is not null) { From 372a676f24e7383a85c2384b2241abe6117af9ab Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Wed, 3 Dec 2025 20:14:36 +0100 Subject: [PATCH 05/54] RCM integration tests --- .../Datadog.Trace.Manual.csproj | 1 + .../FeatureFlags/IEvaluation.Manual.cs | 15 ++ .../FeatureFlagsSdkEvaluateIntegration.cs | 3 +- .../FeatureFlags/EvaluationContext.cs | 14 +- .../FeatureFlags/FeatureFlagsModule.cs | 5 +- .../FeatureFlags/FeatureFlagsTests.cs | 140 ++++++------------ .../FeatureFlagsHelpers.cs | 124 ++++++++++++++++ .../FeatureFlagsEvaluatorTests.cs | 107 +------------ .../Samples.FeatureFlags/Program.cs | 85 ++++++++--- 9 files changed, 273 insertions(+), 221 deletions(-) create mode 100644 tracer/src/Datadog.Trace.Manual/FeatureFlags/IEvaluation.Manual.cs create mode 100644 tracer/test/Datadog.Trace.TestHelpers/FeatureFlagsHelpers.cs diff --git a/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj b/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj index 81eabaf001d1..a189c2dbd734 100644 --- a/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj +++ b/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj @@ -29,6 +29,7 @@ + diff --git a/tracer/src/Datadog.Trace.Manual/FeatureFlags/IEvaluation.Manual.cs b/tracer/src/Datadog.Trace.Manual/FeatureFlags/IEvaluation.Manual.cs new file mode 100644 index 000000000000..daf3ed42d3b0 --- /dev/null +++ b/tracer/src/Datadog.Trace.Manual/FeatureFlags/IEvaluation.Manual.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 Datadog.Trace.DuckTyping; + +namespace Datadog.Trace.FeatureFlags; + +/// A Evaluate result. +[DuckType("Datadog.Trace.FeatureFlags.Evaluation", "Datadog.Trace")] +[DuckAsClass] +public partial interface IEvaluation +{ +} diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs index 89814f140944..c4e1659c2b1f 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs @@ -10,6 +10,7 @@ using System.Threading; using Datadog.Trace.ClrProfiler.CallTarget; using Datadog.Trace.Configuration; +using Datadog.Trace.DuckTyping; using Datadog.Trace.FeatureFlags; namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual; @@ -39,7 +40,7 @@ internal static CallTargetState OnMethodBegin(ref string key, { var parameters = (State)state.State!; var res = FeatureFlagsModule.Instance.Evaluate(parameters.Key!, parameters.TargetType, parameters.DefaultValue, (EvaluationContext)parameters.Context!); - return new CallTargetReturn(returnValue); + return new CallTargetReturn(res.DuckCast()); } private record struct State(string? Key, Type TargetType, object? DefaultValue, object? Context) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs index 82a5f9cae9c2..fb8b414428c0 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs @@ -10,15 +10,24 @@ namespace Datadog.Trace.FeatureFlags { - internal class EvaluationContext(string key, IDictionary? values = null, Func? convertValue = null) + /// Estandard implementation of a EvaluationContext + /// Targeting Key + /// Context optional parameters + /// Context optional convert value function + public class EvaluationContext(string key, IDictionary? values = null, Func? convertValue = null) : IEvaluationContext { private readonly Func? _convertValue = convertValue; + /// Gets the Context Targeting Key public string TargetingKey { get; } = key; + /// Gets the Context optional Values public IDictionary Values { get; } = values ?? new Dictionary(); + /// Get the Context value if existent + /// Value key + /// Returns Context Value or null public object? GetValue(string key) { if (Values is null || !Values.TryGetValue(key, out var res)) @@ -29,6 +38,9 @@ internal class EvaluationContext(string key, IDictionary? value return res; } + /// Optional value conversion function + /// Value to convert + /// Converted value public object? ConvertValue(object? value) { return _convertValue?.Invoke(value); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index 2dec6fa2bd67..f928c93ee9f2 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -65,7 +65,7 @@ internal FeatureFlagsModule(TracerSettings settings, IRcmSubscriptionManager? rc _ffeProduct = new FfeProduct(UpdateConfig); _rcmSubscription = new Subscription(_ffeProduct.UpdateFromRcm, RcmProducts.FfeFlags); _rcmSubscriptionManager.SubscribeToChanges(_rcmSubscription); - _rcmSubscriptionManager.SetCapability(RcmCapabilitiesIndices.AsmActivation, true); + _rcmSubscriptionManager.SetCapability(RcmCapabilitiesIndices.FfeFlagConfigurationRules, true); } } @@ -97,14 +97,17 @@ internal Evaluation Evaluate(string key, Type resultType, object? defaultValue, { if (!_enabled) { + Log.Debug("Evaluate: FeatureFlagsModule DISABLED"); return new Evaluation(null, EvaluationReason.ERROR, null, "FeatureFlagsSdk is disabled"); } if (_evaluator is null) { + Log.Debug("Evaluate: Evaluator is null (no config received)"); return new Evaluation(null, EvaluationReason.ERROR, null, "No config loaded"); } + Log.Debug("Evaluate: Returning Evaluation"); return _evaluator.Evaluate(key, resultType, defaultValue, context); } diff --git a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs index 9d7fe2217eea..4f521ca59744 100644 --- a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs +++ b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs @@ -8,7 +8,9 @@ using System.Linq; using System.Runtime.InteropServices; using System.Threading.Tasks; +using Datadog.Trace.AppSec.Rcm.Models.AsmFeatures; using Datadog.Trace.Configuration; +using Datadog.Trace.FeatureFlags.Rcm.Model; using Datadog.Trace.TestHelpers; using FluentAssertions; using FluentAssertions.Execution; @@ -29,118 +31,62 @@ public class FeatureFlagsTests : TestHelper public FeatureFlagsTests(ITestOutputHelper output) : base("FeatureFlags", output) { - } + SetEnvironmentVariable(ConfigurationKeys.Rcm.PollInterval, "0.5"); + SetEnvironmentVariable(ConfigurationKeys.AppSec.ApiSecurityEnabled, "false"); - [SkippableFact] - [Trait("RunOnWindows", "True")] - public async Task EnabledNoConfig() - { #pragma warning disable CS0618 // Type or member is obsolete EnableDebugMode(); #pragma warning restore CS0618 // Type or member is obsolete - var output = await RunTest(); - Assert.NotNull(output); - Assert.Contains("", output); } - /* - [SkippableFact] - [Trait("RunOnWindows", "True")] - public async Task ManualAndAutomatic() => await RunTest(usePublishWithRID: false); + [SkippableFact] + [Trait("RunOnWindows", "True")] + public async Task FfeEnabled() + { + using var agent = EnvironmentHelper.GetMockAgent(); + var output = await RunTest(agent, enabled: true); - #if NETFRAMEWORK - [SkippableFact] - [Trait("RunOnWindows", "True")] - public async Task NGenRunManualAndAutomatic() - { - SetEnvironmentVariable("READY2RUN_ENABLED", "1"); - var sampleAppPath = EnvironmentHelper.GetSampleApplicationPath(); - NgenHelper.InstallToNativeImageCache(Output, sampleAppPath); - try - { - await RunTest(usePublishWithRID: false); - } - finally - { - NgenHelper.UninstallFromNativeImageCache(Output, sampleAppPath); - } - } - #else - [SkippableFact] - [Trait("RunOnWindows", "True")] - public async Task ReadyToRunManualAndAutomatic() - { - #if NET9_0_OR_GREATER - // OK, I know, this is weird, but AFAICT they changed the host FX lookup logic in .NET 9, - // and for some reason it doesn't seem to work properly in this _one_specific case... - if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) - && Environment.GetEnvironmentVariable("DOTNET_EXE_32") is { } dotnet32BitExe) - { - var root = Path.GetDirectoryName(dotnet32BitExe); - SetEnvironmentVariable("DOTNET_ROOT(x86)", root); - } - #endif - #if !NET6_0_OR_GREATER - // osx-arm64 doesn't work with Ready2Run - SkipOn.PlatformAndArchitecture(SkipOn.PlatformValue.MacOs, SkipOn.ArchitectureValue.ARM64); - #endif - SetEnvironmentVariable("READY2RUN_ENABLED", "1"); - await RunTest(usePublishWithRID: true); - } - #endif + var request1 = await agent.SetupRcmAndWait( + Output, + [ + ((object)new ServerConfiguration + { + Flags = FeatureFlagsHelpers.CreateAllFlags(), + }, + "FFE_FLAGS", + nameof(FeatureFlagsTests)) + ], + timeoutInMilliseconds: 5000); + request1.Should().NotBeNull(); - [SkippableFact] - [Trait("RunOnWindows", "True")] - public async Task ManualOnly() - { - SetEnvironmentVariable("AUTO_INSTRUMENT_ENABLED", "0"); - EnvironmentHelper.SetAutomaticInstrumentation(false); - // with automatic instrumentation disabled, we don't expect _any_ spans - using var telemetry = this.ConfigureTelemetry(); - using var agent = EnvironmentHelper.GetMockAgent(); - using var assert = new AssertionScope(); - using var process = await RunSampleAndWaitForExit(agent); + Assert.NotNull(output); + Assert.Contains("", output); + Assert.Contains("Eval (nonexistent) : ", output); + Assert.Contains("Eval (simple-string) : ", output); + Assert.Contains("Eval (rule-based-flag) : ", output); + Assert.Contains("Eval (numeric-rule-flag) : ", output); + Assert.Contains("Eval (time-based-flag) : ", output); + Assert.Contains("Eval (exposure-flag) : ", output); + } - var spans = await agent.WaitForSpansAsync(0, timeoutInMilliseconds: 500); - spans.Should().BeEmpty(); - } - */ + [SkippableFact] + [Trait("RunOnWindows", "True")] + public async Task FfeDisabled() + { + using var agent = EnvironmentHelper.GetMockAgent(); + var output = await RunTest(agent, enabled: false); + Assert.NotNull(output); + Assert.Contains("", output); + Assert.Contains("FeatureFlagsSdk is disabled", output); + } - private async Task RunTest(bool usePublishWithRID = false) + private async Task RunTest(MockTracerAgent agent, bool enabled = true, bool usePublishWithRID = false) { - SetEnvironmentVariable("DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED", "1"); + SetEnvironmentVariable("DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED", enabled ? "1" : "0"); using var telemetry = this.ConfigureTelemetry(); - using var agent = EnvironmentHelper.GetMockAgent(); using var assert = new AssertionScope(); using var process = await RunSampleAndWaitForExit(agent, usePublishWithRID: usePublishWithRID); return process.StandardOutput.ToString(); - -/* - const int expectedSpans = 47; - var spans = await agent.WaitForSpansAsync(expectedSpans); - spans.Should().HaveCount(expectedSpans); - - var settings = VerifyHelper.GetSpanVerifierSettings(); - settings.UseMethodName(nameof(ManualAndAutomatic)); // they should be identical, so share - settings.DisableRequireUniquePrefix(); - - await VerifyHelper.VerifySpans(spans, settings); - - // telemetry should contain "code" config when it's set manually in code - // this just verifies we have values for all the settings we call, - // without being too rigid about the exact values to avoid fragility - var allConfig = TelemetryHelper.GetAllConfigurationPayloads(telemetry.Telemetry) - .SelectMany(x => x) - .Where(x => x.Origin == "code") - .Select(x => x.Name); - - allConfig.Should().Contain([ - ConfigurationKeys.DebugEnabled, - ConfigurationKeys.ServiceName, - ConfigurationKeys.Environment, - ConfigurationKeys.GlobalTags, - ]); -*/ } } diff --git a/tracer/test/Datadog.Trace.TestHelpers/FeatureFlagsHelpers.cs b/tracer/test/Datadog.Trace.TestHelpers/FeatureFlagsHelpers.cs new file mode 100644 index 000000000000..faf7dafe7448 --- /dev/null +++ b/tracer/test/Datadog.Trace.TestHelpers/FeatureFlagsHelpers.cs @@ -0,0 +1,124 @@ +// +// 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.Collections.Generic; +using Datadog.Trace.FeatureFlags.Rcm.Model; + +namespace Datadog.Trace.TestHelpers; + +internal static class FeatureFlagsHelpers +{ + // --------------------------------------------------------------------- + // Helpers to build flags (minimal subset) + // --------------------------------------------------------------------- + + internal static Dictionary CreateAllFlags() + { + var flags = new Dictionary + { + ["simple-string"] = CreateSimpleFlag("simple-string", ValueType.STRING, "test-value", "on"), + ["rule-based-flag"] = CreateRuleBasedFlag(), + ["numeric-rule-flag"] = CreateNumericRuleFlag(), + ["time-based-flag"] = CreateTimeBasedFlag(), + ["exposure-flag"] = FeatureFlagsHelpers.CreateExposureFlag(), + }; + + return flags; + } + + internal static Flag CreateSimpleFlag(string key, ValueType type, object value, string variantKey) + { + var variants = new Dictionary + { + [variantKey] = new Variant { Key = variantKey, Value = (string)value }, + }; + + var splits = new List + { + new Split { Shards = new List(), VariationKey = variantKey } + }; + + var allocations = new List + { + new Allocation { Key = "alloc1", Splits = splits, DoLog = false } + }; + + return new Flag { Key = key, Enabled = true, VariationType = type, Variations = variants, Allocations = allocations }; + } + + internal static Flag CreateRuleBasedFlag() + { + var variants = new Dictionary + { + ["premium"] = new Variant { Key = "premium", Value = "premium" }, + ["basic"] = new Variant { Key = "basic", Value = "basic" }, + }; + + var premiumConditions = new List + { + new ConditionConfiguration { Operator = ConditionOperator.MATCHES, Attribute = "email", Value = "@company\\.com$" }, + }; + + var premiumRules = new List { new Rule(premiumConditions) }; + var premiumSplits = new List { new Split { Shards = new List(), VariationKey = "premium" } }; + var premiumAlloc = new Allocation { Key = "premium-alloc", Rules = premiumRules, Splits = premiumSplits, DoLog = false }; + + var basicSplits = new List { new Split { Shards = new List(), VariationKey = "basic" } }; + var basicAlloc = new Allocation { Key = "basic-alloc", Splits = basicSplits, DoLog = false }; + + return new Flag { Key = "rule-based-flag", Enabled = true, VariationType = ValueType.STRING, Variations = variants, Allocations = new List { premiumAlloc, basicAlloc } }; + } + + internal static Flag CreateNumericRuleFlag() + { + var variants = new Dictionary + { + ["vip"] = new Variant("vip", "vip"), + ["regular"] = new Variant("regular", "regular") + }; + + var vipConditions = new List + { + new ConditionConfiguration { Operator = ConditionOperator.GTE, Attribute = "score", Value = 800 }, + }; + + var vipRules = new List { new Rule(vipConditions) }; + var vipSplits = new List { new Split { Shards = new List(), VariationKey = "vip" } }; + var vipAlloc = new Allocation { Key = "vip-alloc", Rules = vipRules, Splits = vipSplits, DoLog = false }; + + var regularSplits = new List { new Split { Shards = new List(), VariationKey = "regular" } }; + var regularAlloc = new Allocation { Key = "regular-alloc", Splits = regularSplits, DoLog = false }; + + return new Flag { Key = "numeric-rule-flag", Enabled = true, VariationType = ValueType.STRING, Variations = variants, Allocations = new List { vipAlloc, regularAlloc } }; + } + + internal static Flag CreateTimeBasedFlag() + { + var variants = new Dictionary + { + ["time-limited"] = new Variant("time-limited", "time-limited") + }; + + var splits = new List { new Split { Shards = new List(), VariationKey = "time-limited" } }; + var alloc = new Allocation { Key = "time-alloc", StartAt = "2022-01-01T00:00:00Z", EndAt = "2022-12-31T23:59:59Z", Splits = splits, DoLog = false }; + + return new Flag { Key = "time-based-flag", Enabled = true, VariationType = ValueType.STRING, Variations = variants, Allocations = new List { alloc } }; + } + + internal static Flag CreateExposureFlag() + { + var variants = new Dictionary + { + ["tracked"] = new Variant("tracked", "tracked-value") + }; + + var splits = new List { new Split { VariationKey = "tracked", Shards = new List() } }; + var alloc = new Allocation { Key = "exposure-alloc", Splits = splits, DoLog = true }; + + return new Flag { Key = "exposure-flag", Enabled = true, VariationType = ValueType.STRING, Variations = variants, Allocations = new List { alloc } }; + } +} diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs index 209c2bb09950..466a0be522d1 100644 --- a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs @@ -9,6 +9,7 @@ using System.Collections.Generic; using Datadog.Trace.FeatureFlags; using Datadog.Trace.FeatureFlags.Rcm.Model; +using Datadog.Trace.TestHelpers; using Google.Protobuf.WellKnownTypes; using Moq; using Xunit; @@ -243,7 +244,7 @@ public void EvaluateSimpleStringFlagReturnsTargetingMatch() { var flags = new Dictionary { - ["simple-string"] = CreateSimpleFlag("simple-string", ValueType.STRING, "test-value", "on") + ["simple-string"] = FeatureFlagsHelpers.CreateSimpleFlag("simple-string", ValueType.STRING, "test-value", "on") }; var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); @@ -261,7 +262,7 @@ public void EvaluateRuleBasedFlagMatchesEmailPremium() { var flags = new Dictionary { - ["rule-based-flag"] = CreateRuleBasedFlag() + ["rule-based-flag"] = FeatureFlagsHelpers.CreateRuleBasedFlag() }; var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); @@ -279,7 +280,7 @@ public void EvaluateNumericRuleFlagMatchesScoreGte800() { var flags = new Dictionary { - ["numeric-rule-flag"] = CreateNumericRuleFlag() + ["numeric-rule-flag"] = FeatureFlagsHelpers.CreateNumericRuleFlag() }; var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); @@ -297,7 +298,7 @@ public void EvaluateTimeBasedFlagWithExpiredAllocationReturnsDefaultReason() { var flags = new Dictionary { - ["time-based-flag"] = CreateTimeBasedFlag() + ["time-based-flag"] = FeatureFlagsHelpers.CreateTimeBasedFlag() }; var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); @@ -314,7 +315,7 @@ public void EvaluateExposureFlagLogsExposureEvent() { var flags = new Dictionary { - ["exposure-flag"] = CreateExposureFlag() + ["exposure-flag"] = FeatureFlagsHelpers.CreateExposureFlag() }; List events = new List(); @@ -330,102 +331,6 @@ public void EvaluateExposureFlagLogsExposureEvent() // DoLog=true -> one exposure event Assert.Single(events); } - - // --------------------------------------------------------------------- - // Helpers to build flags (minimal subset) - // --------------------------------------------------------------------- - - private static Flag CreateSimpleFlag(string key, ValueType type, object value, string variantKey) - { - var variants = new Dictionary - { - [variantKey] = new Variant { Key = variantKey, Value = (string)value }, - }; - - var splits = new List - { - new Split { Shards = new List(), VariationKey = variantKey } - }; - - var allocations = new List - { - new Allocation { Key = "alloc1", Splits = splits, DoLog = false } - }; - - return new Flag { Key = key, Enabled = true, VariationType = type, Variations = variants, Allocations = allocations }; - } - - private static Flag CreateRuleBasedFlag() - { - var variants = new Dictionary - { - ["premium"] = new Variant { Key = "premium", Value = "premium" }, - ["basic"] = new Variant { Key = "basic", Value = "basic" }, - }; - - var premiumConditions = new List - { - new ConditionConfiguration { Operator = ConditionOperator.MATCHES, Attribute = "email", Value = "@company\\.com$" }, - }; - - var premiumRules = new List { new Rule(premiumConditions) }; - var premiumSplits = new List { new Split { Shards = new List(), VariationKey = "premium" } }; - var premiumAlloc = new Allocation { Key = "premium-alloc", Rules = premiumRules, Splits = premiumSplits, DoLog = false }; - - var basicSplits = new List { new Split { Shards = new List(), VariationKey = "basic" } }; - var basicAlloc = new Allocation { Key = "basic-alloc", Splits = basicSplits, DoLog = false }; - - return new Flag { Key = "rule-based-flag", Enabled = true, VariationType = ValueType.STRING, Variations = variants, Allocations = new List { premiumAlloc, basicAlloc } }; - } - - private static Flag CreateNumericRuleFlag() - { - var variants = new Dictionary - { - ["vip"] = new Variant("vip", "vip"), - ["regular"] = new Variant("regular", "regular") - }; - - var vipConditions = new List - { - new ConditionConfiguration { Operator = ConditionOperator.GTE, Attribute = "score", Value = 800 }, - }; - - var vipRules = new List { new Rule(vipConditions) }; - var vipSplits = new List { new Split { Shards = new List(), VariationKey = "vip" } }; - var vipAlloc = new Allocation { Key = "vip-alloc", Rules = vipRules, Splits = vipSplits, DoLog = false }; - - var regularSplits = new List { new Split { Shards = new List(), VariationKey = "regular" } }; - var regularAlloc = new Allocation { Key = "regular-alloc", Splits = regularSplits, DoLog = false }; - - return new Flag { Key = "numeric-rule-flag", Enabled = true, VariationType = ValueType.STRING, Variations = variants, Allocations = new List { vipAlloc, regularAlloc } }; - } - - private static Flag CreateTimeBasedFlag() - { - var variants = new Dictionary - { - ["time-limited"] = new Variant("time-limited", "time-limited") - }; - - var splits = new List { new Split { Shards = new List(), VariationKey = "time-limited" } }; - var alloc = new Allocation { Key = "time-alloc", StartAt = "2022-01-01T00:00:00Z", EndAt = "2022-12-31T23:59:59Z", Splits = splits, DoLog = false }; - - return new Flag { Key = "time-based-flag", Enabled = true, VariationType = ValueType.STRING, Variations = variants, Allocations = new List { alloc } }; - } - - private static Flag CreateExposureFlag() - { - var variants = new Dictionary - { - ["tracked"] = new Variant("tracked", "tracked-value") - }; - - var splits = new List { new Split { VariationKey = "tracked", Shards = new List() } }; - var alloc = new Allocation { Key = "exposure-alloc", Splits = splits, DoLog = true }; - - return new Flag { Key = "exposure-flag", Enabled = true, VariationType = ValueType.STRING, Variations = variants, Allocations = new List { alloc } }; - } } #pragma warning restore SA1204 // Static elements should appear before instance elements #pragma warning restore SA1500 // Braces for multi-line statements should not share line diff --git a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs index 6bc3c2d25a94..c74fb70696ec 100644 --- a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs +++ b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs @@ -1,26 +1,71 @@ -// See https://aka.ms/new-console-template for more information -Console.WriteLine("FeatureFlags SDK Sample"); +using System; +using System.Diagnostics; +using Datadog.Trace.FeatureFlags; -if (!Datadog.Trace.FeatureFlags.FeatureFlagsSdk.IsAvailable()) +namespace Samples.FeatureFlags; +class Program { - Console.WriteLine($""); - return; -} -Console.WriteLine($""); + private static void Main(string[] args) + { + // See https://aka.ms/new-console-template for more information + Console.WriteLine("FeatureFlags SDK Sample"); -var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate("DD_Enabled", typeof(string), "Not found", null); + if (!Datadog.Trace.FeatureFlags.FeatureFlagsSdk.IsAvailable()) + { + Console.WriteLine($""); + return; + } -if (evaluation is null) -{ - Console.WriteLine($"Eval (DD_Enabled) : "); -} -else if (evaluation.Error is not null) -{ - Console.WriteLine($"Eval (DD_Enabled) : "); -} -else -{ - Console.WriteLine($"Eval (DD_Enabled) : "}>"); -} + Console.WriteLine($""); + + var ev = Evaluate("nonexistent"); + if (ev != null && ev.Error is "FeatureFlagsSdk is disabled") + { + return; + } + + int configUpdates = 0; + Datadog.Trace.FeatureFlags.FeatureFlagsSdk.RegisterOnNewConfigEventHandler(() => configUpdates++); + + int attempts = 5; + while (configUpdates == 0) + { + if (attempts-- == 0) + { + Console.WriteLine($"No RC received"); + return; + } + Console.WriteLine($"Waiting for RC..."); + Thread.Sleep(1000); + } + + Evaluate("simple-string"); + Evaluate("rule-based-flag"); + Evaluate("numeric-rule-flag"); + Evaluate("time-based-flag"); + Evaluate("exposure-flag"); + + IEvaluation? Evaluate(string key) + { + var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, typeof(string), "Not found", null); + + if (evaluation is null) + { + Console.WriteLine($"Eval ({key}) : "); + } + else if (evaluation.Error is not null) + { + Console.WriteLine($"Eval ({key}) : "); + } + else + { + Console.WriteLine($"Eval ({key}) : "}>"); + } + + return evaluation; + } + + } +} From abedc930a2af6b1ba06076a62a9a34b99b7af4cc Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Wed, 3 Dec 2025 20:51:07 +0100 Subject: [PATCH 06/54] Better traces --- .../src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs | 9 +++++---- tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs | 4 ++++ .../FeatureFlags/FeatureFlagsTests.cs | 7 +++---- 3 files changed, 12 insertions(+), 8 deletions(-) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index f928c93ee9f2..de582f6bd0cc 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -64,8 +64,8 @@ internal FeatureFlagsModule(TracerSettings settings, IRcmSubscriptionManager? rc _enabled = true; _ffeProduct = new FfeProduct(UpdateConfig); _rcmSubscription = new Subscription(_ffeProduct.UpdateFromRcm, RcmProducts.FfeFlags); - _rcmSubscriptionManager.SubscribeToChanges(_rcmSubscription); _rcmSubscriptionManager.SetCapability(RcmCapabilitiesIndices.FfeFlagConfigurationRules, true); + _rcmSubscriptionManager.SubscribeToChanges(_rcmSubscription); } } @@ -97,22 +97,23 @@ internal Evaluation Evaluate(string key, Type resultType, object? defaultValue, { if (!_enabled) { - Log.Debug("Evaluate: FeatureFlagsModule DISABLED"); + Log.Debug("FeatureFlagsModule::Evaluate -> FeatureFlagsModule DISABLED"); return new Evaluation(null, EvaluationReason.ERROR, null, "FeatureFlagsSdk is disabled"); } if (_evaluator is null) { - Log.Debug("Evaluate: Evaluator is null (no config received)"); + Log.Debug("FeatureFlagsModule::Evaluate -> Evaluator is null (no config received)"); return new Evaluation(null, EvaluationReason.ERROR, null, "No config loaded"); } - Log.Debug("Evaluate: Returning Evaluation"); + Log.Debug("FeatureFlagsModule::Evaluate -> Returning Evaluation"); return _evaluator.Evaluate(key, resultType, defaultValue, context); } private void UpdateConfig(List> list) { + Log.Debug("FeatureFlagsModule::UpdateConfig -> New config received."); // Feed configs to the rules evaluator if (list.Count > 0) { diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs index 52d81ec9ddf9..f86d19ef6a2a 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs @@ -8,6 +8,7 @@ using System.Collections.Generic; using System.Linq; using Datadog.Trace.AppSec.Rcm.Models.AsmDd; +using Datadog.Trace.FeatureFlags; using Datadog.Trace.FeatureFlags.Rcm.Model; using Datadog.Trace.Logging; using Datadog.Trace.RemoteConfigurationManagement; @@ -17,6 +18,8 @@ namespace Datadog.Trace.AppSec.Rcm; internal class FfeProduct { + internal static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(FfeProduct)); + private readonly Action>> _onNewConfig; private List> _serverConfigurations = new List>(); @@ -27,6 +30,7 @@ public FfeProduct(Action>> onNewC public ApplyDetails[] UpdateFromRcm(Dictionary> configsByProduct, Dictionary>? removedConfigsByProduct) { + Log.Debug("FfeProduct::UpdateFromRcm -> Processing new config..."); List res = new List(); bool apply = false; diff --git a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs index 4f521ca59744..d807e54f1ca3 100644 --- a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs +++ b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs @@ -11,6 +11,7 @@ using Datadog.Trace.AppSec.Rcm.Models.AsmFeatures; using Datadog.Trace.Configuration; using Datadog.Trace.FeatureFlags.Rcm.Model; +using Datadog.Trace.RemoteConfigurationManagement; using Datadog.Trace.TestHelpers; using FluentAssertions; using FluentAssertions.Execution; @@ -31,9 +32,6 @@ public class FeatureFlagsTests : TestHelper public FeatureFlagsTests(ITestOutputHelper output) : base("FeatureFlags", output) { - SetEnvironmentVariable(ConfigurationKeys.Rcm.PollInterval, "0.5"); - SetEnvironmentVariable(ConfigurationKeys.AppSec.ApiSecurityEnabled, "false"); - #pragma warning disable CS0618 // Type or member is obsolete EnableDebugMode(); #pragma warning restore CS0618 // Type or member is obsolete @@ -53,7 +51,7 @@ public async Task FfeEnabled() { Flags = FeatureFlagsHelpers.CreateAllFlags(), }, - "FFE_FLAGS", + RcmProducts.FfeFlags, nameof(FeatureFlagsTests)) ], timeoutInMilliseconds: 5000); @@ -82,6 +80,7 @@ public async Task FfeDisabled() private async Task RunTest(MockTracerAgent agent, bool enabled = true, bool usePublishWithRID = false) { + SetEnvironmentVariable(ConfigurationKeys.Rcm.PollInterval, "1"); SetEnvironmentVariable("DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED", enabled ? "1" : "0"); using var telemetry = this.ConfigureTelemetry(); using var assert = new AssertionScope(); From 3fe4bc4e14435b5c6959c1bef3c098199277a68e Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Wed, 3 Dec 2025 21:06:15 +0100 Subject: [PATCH 07/54] RCM update --- .../src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index de582f6bd0cc..c3fbe0f617ca 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -63,9 +63,11 @@ internal FeatureFlagsModule(TracerSettings settings, IRcmSubscriptionManager? rc Log.Debug("FeatureFlagsModule ENABLED"); _enabled = true; _ffeProduct = new FfeProduct(UpdateConfig); - _rcmSubscription = new Subscription(_ffeProduct.UpdateFromRcm, RcmProducts.FfeFlags); - _rcmSubscriptionManager.SetCapability(RcmCapabilitiesIndices.FfeFlagConfigurationRules, true); - _rcmSubscriptionManager.SubscribeToChanges(_rcmSubscription); + if (Interlocked.Exchange(ref _rcmSubscription, new Subscription(_ffeProduct.UpdateFromRcm, RcmProducts.FfeFlags)) == null) + { + _rcmSubscriptionManager.SubscribeToChanges(_rcmSubscription!); + _rcmSubscriptionManager.SetCapability(RcmCapabilitiesIndices.FfeFlagConfigurationRules, true); + } } } From 0ec128e3222242dc6bd3b555efe48fdefea4f571 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Thu, 4 Dec 2025 09:08:03 +0100 Subject: [PATCH 08/54] Fixed RC and Ducktyping bugs --- .../FeatureFlags/FeatureFlagsEvaluator.cs | 22 +++++++++++++------ .../FeatureFlags/FeatureFlagsModule.cs | 17 +++++++++----- .../FeatureFlags/IEvaluationContext.cs | 5 +++++ .../FeatureFlags/Rcm/FfeProduct.cs | 4 ++-- .../FeatureFlags/FeatureFlagsTests.cs | 11 +++++----- .../Samples.FeatureFlags/Program.cs | 3 ++- 6 files changed, 41 insertions(+), 21 deletions(-) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index 7b45e47ccc2c..c47a5561f7b0 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -48,6 +48,14 @@ public FeatureFlagsEvaluator(Action? onExposureEvent, Se _onExposureEvent = onExposureEvent; _config = config; _timeoutMs = timeoutMs; + if (_config is null) + { + Log.Debug("Creating Evaluator without config"); + } + else + { + Log.Debug("Creating Evaluator with {Flags} flags", _config.Flags?.Count ?? 0); + } } private delegate bool NumberEquality(double a, double b); @@ -57,7 +65,7 @@ public Evaluation Evaluate(string key, T defaultValue, EvaluationContext cont return Evaluate(key, typeof(T), defaultValue, context); } - public Evaluation Evaluate(string key, Type resultType, object? defaultValue, EvaluationContext context) + public Evaluation Evaluate(string key, Type resultType, object? defaultValue, IEvaluationContext context) { try { @@ -226,7 +234,7 @@ private static bool IsAllocationActive(Allocation allocation, DateTime now) return true; } - private static bool EvaluateRules(IEnumerable rules, EvaluationContext context) + private static bool EvaluateRules(IEnumerable rules, IEvaluationContext context) { foreach (var rule in rules) { @@ -254,7 +262,7 @@ private static bool EvaluateRules(IEnumerable rules, EvaluationContext con return false; } - private static bool EvaluateCondition(ConditionConfiguration condition, EvaluationContext context) + private static bool EvaluateCondition(ConditionConfiguration condition, IEvaluationContext context) { if (condition.Operator is null) { @@ -432,7 +440,7 @@ private static string GetMd5Hash(string input) return null; } - private static object? ResolveAttribute(string? name, EvaluationContext context) + private static object? ResolveAttribute(string? name, IEvaluationContext context) { if (name == null) { @@ -526,7 +534,7 @@ private static double ParseDouble(object value) return evaluation.Metadata.TryGetValue("allocationKey", out var key) ? key : null; } - internal static IDictionary FlattenContext(EvaluationContext context) + internal static IDictionary FlattenContext(IEvaluationContext context) { var keys = context.Values.Keys; var result = new Dictionary(); @@ -580,7 +588,7 @@ private Evaluation ResolveVariant( Flag flag, string variationKey, Allocation allocation, - EvaluationContext context) + IEvaluationContext context) { if (flag.Variations is null || !flag.Variations.TryGetValue(variationKey, out var variant) || variant == null) { @@ -622,7 +630,7 @@ private Evaluation ResolveVariant( private void DispatchExposure( string flag, Evaluation evaluation, - EvaluationContext context) + IEvaluationContext context) { var allocationKey = AllocationKey(evaluation); var variantKey = evaluation.Variant; diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index c3fbe0f617ca..3fd1f305580f 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -115,12 +115,19 @@ internal Evaluation Evaluate(string key, Type resultType, object? defaultValue, private void UpdateConfig(List> list) { - Log.Debug("FeatureFlagsModule::UpdateConfig -> New config received."); - // Feed configs to the rules evaluator - if (list.Count > 0) + Log.Debug("FeatureFlagsModule::UpdateConfig -> New config received. {Count}", list.Count); + try { - _evaluator = new FeatureFlagsEvaluator(ReportExposure, list[0].Value, Timeout); - _onNewConfigEventHander?.Invoke(); + // Feed configs to the rules evaluator + if (list.Count > 0) + { + Interlocked.Exchange(ref _evaluator, new FeatureFlagsEvaluator(ReportExposure, list[0].Value, Timeout)); + _onNewConfigEventHander?.Invoke(); + } + } + catch (Exception ex) + { + Log.Warning(ex, "FeatureFlagsModule::UpdateConfig -> Error processing new config"); } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs index 7f6c3dd3103d..21adb64c26e1 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs @@ -18,6 +18,11 @@ public partial interface IEvaluationContext /// Gets context values. public IDictionary Values { get; } + /// Get the Context value if existent + /// Value key + /// Returns Context Value or null + object? GetValue(string key); + /// Custom value converter. object? ConvertValue(object? value); } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs index f86d19ef6a2a..7919ac5efb80 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs @@ -49,8 +49,8 @@ public ApplyDetails[] UpdateFromRcm(Dictionary var serverConfigFile = new NamedRawFile(ffeConfig.Path, ffeConfig.Contents).Deserialize(); if (serverConfigFile.TypedFile is not null) { - _serverConfigurations.Add(new KeyValuePair(ffeConfig.Path.Id, serverConfigFile.TypedFile)); - res.Add(ApplyDetails.FromOk(ffeConfig.Path.Id)); + _serverConfigurations.Add(new KeyValuePair(ffeConfig.Path.Path, serverConfigFile.TypedFile)); + res.Add(ApplyDetails.FromOk(ffeConfig.Path.Path)); apply = true; } } diff --git a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs index d807e54f1ca3..99446272dc2b 100644 --- a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs +++ b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs @@ -7,6 +7,7 @@ using System.IO; using System.Linq; using System.Runtime.InteropServices; +using System.Threading; using System.Threading.Tasks; using Datadog.Trace.AppSec.Rcm.Models.AsmFeatures; using Datadog.Trace.Configuration; @@ -42,9 +43,7 @@ public FeatureFlagsTests(ITestOutputHelper output) public async Task FfeEnabled() { using var agent = EnvironmentHelper.GetMockAgent(); - var output = await RunTest(agent, enabled: true); - - var request1 = await agent.SetupRcmAndWait( + var request1 = agent.SetupRcm( Output, [ ((object)new ServerConfiguration @@ -53,9 +52,9 @@ public async Task FfeEnabled() }, RcmProducts.FfeFlags, nameof(FeatureFlagsTests)) - ], - timeoutInMilliseconds: 5000); - request1.Should().NotBeNull(); + ]); + + var output = await RunTest(agent, enabled: true); Assert.NotNull(output); Assert.Contains("", output); diff --git a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs index c74fb70696ec..91b9b043a4f6 100644 --- a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs +++ b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs @@ -49,7 +49,8 @@ private static void Main(string[] args) IEvaluation? Evaluate(string key) { - var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, typeof(string), "Not found", null); + var context = new EvaluationContext(key); + var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, typeof(string), "Not found", context); if (evaluation is null) { From ca53728b6762cd627edcd8901e0f8a6bf02b8049 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Thu, 4 Dec 2025 09:20:34 +0100 Subject: [PATCH 09/54] Fix duck cast error --- .../FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs | 2 +- tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs index c4e1659c2b1f..8426a240bc9d 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs @@ -39,7 +39,7 @@ internal static CallTargetState OnMethodBegin(ref string key, internal static CallTargetReturn OnMethodEnd(TReturn? returnValue, Exception? exception, in CallTargetState state) { var parameters = (State)state.State!; - var res = FeatureFlagsModule.Instance.Evaluate(parameters.Key!, parameters.TargetType, parameters.DefaultValue, (EvaluationContext)parameters.Context!); + var res = FeatureFlagsModule.Instance.Evaluate(parameters.Key!, parameters.TargetType, parameters.DefaultValue, parameters.Context.DuckCast()!); return new CallTargetReturn(res.DuckCast()); } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index 3fd1f305580f..62f8795acd51 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -95,7 +95,7 @@ internal void RegisterOnNewConfigEventHandler(Action? onNewConfig) _onNewConfigEventHander = onNewConfig; } - internal Evaluation Evaluate(string key, Type resultType, object? defaultValue, EvaluationContext context) + internal Evaluation Evaluate(string key, Type resultType, object? defaultValue, IEvaluationContext context) { if (!_enabled) { From 11e70f93dfd4fc391a7c102e06a076a396d916ac Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Tue, 9 Dec 2025 10:33:19 +0100 Subject: [PATCH 10/54] Fix integration test --- .../FeatureFlags/FeatureFlagsTests.cs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs index 99446272dc2b..1a77bbab2f02 100644 --- a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs +++ b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs @@ -59,11 +59,11 @@ public async Task FfeEnabled() Assert.NotNull(output); Assert.Contains("", output); Assert.Contains("Eval (nonexistent) : ", output); - Assert.Contains("Eval (simple-string) : ", output); - Assert.Contains("Eval (rule-based-flag) : ", output); - Assert.Contains("Eval (numeric-rule-flag) : ", output); - Assert.Contains("Eval (time-based-flag) : ", output); - Assert.Contains("Eval (exposure-flag) : ", output); + Assert.Contains("Eval (simple-string) : Date: Thu, 11 Dec 2025 20:13:19 +0100 Subject: [PATCH 11/54] Shared tests --- .../Datadog.Trace/FeatureFlags/Evaluation.cs | 2 +- .../FeatureFlags/FeatureFlagsEvaluator.cs | 47 +- .../Datadog.Trace/FeatureFlags/IEvaluation.cs | 2 +- .../FeatureFlags/Rcm/Model/Variant.cs | 2 +- .../Datadog.Trace.IntegrationTests.csproj | 4 - .../ResourceHelper.cs | 28 + .../Datadog.Trace.Tests.csproj | 21 + .../FeatureFlagsEvaluatorTests.Bundle.cs | 175 + .../FeatureFlagsEvaluatorTests.cs | 7 +- .../resources/config/flags-v1.json | 2898 +++++++++++++++++ .../test-case-boolean-one-of-matches.json | 240 ++ .../test-case-comparator-operator-flag.json | 82 + .../data/test-case-disabled-flag.json | 40 + .../resources/data/test-case-empty-flag.json | 40 + .../test-case-flag-with-empty-string.json | 36 + .../data/test-case-integer-flag.json | 382 +++ .../data/test-case-kill-switch-flag.json | 434 +++ .../test-case-new-user-onboarding-flag.json | 420 +++ .../data/test-case-no-allocations-flag.json | 52 + .../data/test-case-null-operator-flag.json | 94 + .../data/test-case-numeric-flag.json | 58 + .../data/test-case-numeric-one-of.json | 122 + .../data/test-case-race-conditions.json | 10 + .../resources/data/test-case-regex-flag.json | 65 + .../test-case-start-and-end-date-flag.json | 58 + .../data/test-flag-that-does-not-exist.json | 40 + .../resources/data/test-json-config-flag.json | 96 + .../data/test-no-allocations-flag.json | 52 + .../data/test-special-characters.json | 78 + .../test-string-with-special-characters.json | 1190 +++++++ 30 files changed, 6758 insertions(+), 17 deletions(-) create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/config/flags-v1.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-boolean-one-of-matches.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-comparator-operator-flag.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-disabled-flag.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-empty-flag.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-flag-with-empty-string.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-integer-flag.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-kill-switch-flag.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-new-user-onboarding-flag.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-no-allocations-flag.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-null-operator-flag.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-numeric-flag.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-numeric-one-of.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-race-conditions.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-regex-flag.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-start-and-end-date-flag.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-flag-that-does-not-exist.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-json-config-flag.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-no-allocations-flag.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-special-characters.json create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-string-with-special-characters.json diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs b/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs index 7b7afbd483b1..83a76f82571c 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs @@ -25,6 +25,6 @@ internal class Evaluation(object? value, EvaluationReason reason, string? varian public string? Error { get; } = error; - public IDictionary? Metadata { get; } = metadata; + public IDictionary? FlagMetadata { get; } = metadata; } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index c47a5561f7b0..d31c5ed1a987 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -25,8 +25,14 @@ internal class FeatureFlagsEvaluator private static readonly string[] DateFormats = { + "MM-dd-yyyy HH:mm:ss", + "MM/dd/yyyy HH:mm:ss", + "yyyy-MM-dd HH:mm:ss", + "yyyy/MM/dd HH:mm:ss", "yyyy-MM-dd'T'HH:mm:ss.fff'Z'", - "yyyy-MM-dd'T'HH:mm:ss'Z'" + "yyyy-MM-dd'T'HH:mm:ss'Z'", + "MM-dd-yyyy'T'HH:mm:ss.fff'Z'", + "MM-dd-yyyy'T'HH:mm:ss'Z'", }; private static readonly HashSet SupportedResolutionTypes = @@ -35,8 +41,8 @@ internal class FeatureFlagsEvaluator typeof(string), typeof(bool), typeof(int), + typeof(long), typeof(double), - // typeof(Value) }; private readonly Action? _onExposureEvent; @@ -317,12 +323,19 @@ private static bool MatchesRegex(object attributeValue, object? conditionValue) { var pattern = conditionValue?.ToString() ?? string.Empty; var regex = new Regex(pattern); - return regex.IsMatch(attributeValue?.ToString() ?? string.Empty); + return regex.IsMatch(ToString(attributeValue)); } catch { return false; } + + static string ToString(object attributeValue) + { + if (attributeValue is null) { return string.Empty; } + if (attributeValue is bool boolValue) { return boolValue ? "true" : "false"; } + return Convert.ToString(attributeValue, CultureInfo.InvariantCulture) ?? string.Empty; + } } private static bool IsOneOf(object attributeValue, object? conditionValue) @@ -355,6 +368,11 @@ private static bool ValuesEqual(object a, object? b) return true; } + if (a is string aTxt && b is string bTxt) + { + return aTxt.Equals(bTxt); + } + if (a is IConvertible || b is IConvertible) { return CompareNumber(a, b, (first, second) => Math.Abs(first - second) < double.Epsilon); @@ -505,6 +523,12 @@ private static string GetMd5Hash(string input) return (int)number; } + if (target == typeof(long)) + { + var number = ParseDouble(value); + return (long)number; + } + if (target == typeof(double)) { var number = ParseDouble(value); @@ -516,22 +540,31 @@ private static string GetMd5Hash(string input) private static double ParseDouble(object value) { - if (value is IConvertible) + if (value is string txt) + { + return txt.ToLower() switch + { + "true" => 1.0, + "false" => 0.0, + _ => double.Parse(txt, CultureInfo.InvariantCulture) + }; + } + else if (value is IConvertible) { return Convert.ToDouble(value, CultureInfo.InvariantCulture); } - return double.Parse(Convert.ToString(value)!); + return double.Parse(Convert.ToString(value)!, CultureInfo.InvariantCulture); } private static string? AllocationKey(Evaluation evaluation) { - if (evaluation.Metadata == null) + if (evaluation.FlagMetadata == null) { return null; } - return evaluation.Metadata.TryGetValue("allocationKey", out var key) ? key : null; + return evaluation.FlagMetadata.TryGetValue("allocationKey", out var key) ? key : null; } internal static IDictionary FlattenContext(IEvaluationContext context) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluation.cs b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluation.cs index 08368d5dd097..34aaac7838e4 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluation.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluation.cs @@ -30,5 +30,5 @@ public partial interface IEvaluation string? Error { get; } /// Gets the evaluation metadata - IDictionary? Metadata { get; } + IDictionary? FlagMetadata { get; } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Variant.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Variant.cs index 7c08ba5ef526..decfe1a586f1 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Variant.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Variant.cs @@ -19,5 +19,5 @@ public Variant() public string? Key { get; set; } = key; - public string? Value { get; set; } = value; + public object? Value { get; set; } = value; } diff --git a/tracer/test/Datadog.Trace.IntegrationTests/Datadog.Trace.IntegrationTests.csproj b/tracer/test/Datadog.Trace.IntegrationTests/Datadog.Trace.IntegrationTests.csproj index 29e95d469127..01245785b1e9 100644 --- a/tracer/test/Datadog.Trace.IntegrationTests/Datadog.Trace.IntegrationTests.csproj +++ b/tracer/test/Datadog.Trace.IntegrationTests/Datadog.Trace.IntegrationTests.csproj @@ -70,8 +70,4 @@ - - - - diff --git a/tracer/test/Datadog.Trace.TestHelpers/ResourceHelper.cs b/tracer/test/Datadog.Trace.TestHelpers/ResourceHelper.cs index a7266f5c38ed..f349cba7c4ce 100644 --- a/tracer/test/Datadog.Trace.TestHelpers/ResourceHelper.cs +++ b/tracer/test/Datadog.Trace.TestHelpers/ResourceHelper.cs @@ -31,4 +31,32 @@ public static string ReadAllText(string resourceName, string return reader.ReadToEnd(); } } + + public static IEnumerable> EnumFiles(string resourceName, string resourceNamespace = null) + where TContainerAssembly : class + { + var type = typeof(TContainerAssembly); + Assembly assembly = type.Assembly; + if (resourceNamespace == null) + { + resourceNamespace = type.Namespace; + } + + var prefix = resourceNamespace + "." + resourceName + "."; + + foreach (var name in assembly.GetManifestResourceNames()) + { + if (!name.StartsWith(prefix)) + { + continue; + } + + using (Stream stream = assembly.GetManifestResourceStream(name)) + using (StreamReader reader = new StreamReader(stream)) + { + var content = reader.ReadToEnd(); + yield return new KeyValuePair(name.Substring(prefix.Length), content); + } + } + } } diff --git a/tracer/test/Datadog.Trace.Tests/Datadog.Trace.Tests.csproj b/tracer/test/Datadog.Trace.Tests/Datadog.Trace.Tests.csproj index 74ea3a578db1..21ad217a4934 100644 --- a/tracer/test/Datadog.Trace.Tests/Datadog.Trace.Tests.csproj +++ b/tracer/test/Datadog.Trace.Tests/Datadog.Trace.Tests.csproj @@ -73,6 +73,27 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs new file mode 100644 index 000000000000..a75c4f4b0605 --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs @@ -0,0 +1,175 @@ +// +// 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 System.Collections.Generic; +using System.Linq; +using Datadog.Trace.FeatureFlags; +using Datadog.Trace.FeatureFlags.Rcm.Model; +using Datadog.Trace.TestHelpers; +using Datadog.Trace.Vendors.Newtonsoft.Json.Bson; +using Google.Protobuf.WellKnownTypes; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using Xunit; +using ValueType = Datadog.Trace.FeatureFlags.Rcm.Model.ValueType; + +namespace Datadog.Trace.Tests.FeatureFlags; + +/// FeatureFlagsEvaluator bundled tests +public partial class FeatureFlagsEvaluatorTests +{ +#pragma warning disable SA1204 // Static elements should appear before instance elements +#pragma warning disable SA1500 // Braces for multi-line statements should not share line +#pragma warning disable SA1401 // Fields should be private + public static List TestData = GetTestData(); + internal static ServerConfiguration _config = ReadConfig(); +#pragma warning restore SA1401 // Fields should be private + + [SkippableTheory] + [MemberData(nameof(TestData))] + public void BundledTest(string description, TestCase? testCase) + { + Assert.NotNull(testCase); + Assert.NotNull(testCase.Flag); + Assert.NotNull(testCase.Result); + + var evaluator = new FeatureFlagsEvaluator(null, _config); + var ctx = new EvaluationContext(testCase.TargetingKey ?? string.Empty, testCase.Attributes); + + // Not supported format + Skip.If(testCase.VariationType == "JSON", "JSON result format not supported"); + + var type = GetVariationType(testCase.VariationType); + + var result = evaluator.Evaluate(testCase.Flag, type, testCase.DefaultValue, ctx); + Assert.NotNull(result); + + if (testCase.Result.Value is null || !testCase.Result.Value.Equals(result.Value)) + { + _ = 0; + } + + Assert.Equal(testCase.Result.Value, result.Value); + Assert.Equal(testCase.Result.Variant, result.Variant); + + Assert.NotNull(description); + } + + private static System.Type GetVariationType(string? variationType) + { + return variationType switch + { + "INTEGER" => typeof(long), + "NUMERIC" => typeof(double), + "STRING" => typeof(string), + "BOOLEAN" => typeof(bool), + _ => throw new NotImplementedException(), + }; + } + + private static ServerConfiguration ReadConfig() + { + // Read config + var configContent = ResourceHelper.ReadAllText("resources.config.flags-v1.json"); + var fullObject = JObject.Parse(configContent); + var dataToken = fullObject.SelectToken("data.attributes.flags"); + var flags = dataToken?.ToObject>(); + Assert.NotNull(flags); + + foreach (var flag in flags) + { + if (flag.Value.Allocations is null) { continue; } + foreach (var allocation in flag.Value.Allocations) + { + if (allocation.Rules is null) { continue; } + foreach (var rule in allocation.Rules) + { + if (rule.Conditions is null) { continue; } + foreach (var condition in rule.Conditions) + { + if (condition.Value is not JArray jArray) { continue; } + var arr = jArray.ToObject(); + condition.Value = arr; + } + } + } + } + + var config = new ServerConfiguration { Flags = flags }; + + return config; + } + + private static List GetTestData() + { + // This file should regularly be updated from here https://github.com/DataDog/experimental/blob/main/teams/asm/iast/redaction/suite/evidence-redaction-suite.yml + + List testData = new List(); + + foreach (var file in ResourceHelper.EnumFiles("resources.data")) + { + var testCases = JsonConvert.DeserializeObject>(file.Value); + foreach (var testCase in testCases!) + { + testData.Add([file.Key, testCase]); + } + } + + return testData; + } + + public class TestCase + { + public string? Flag { get; set; } + + public string? VariationType { get; set; } + + public object? DefaultValue { get; set; } + + public string? TargetingKey { get; set; } + + public Dictionary? Attributes { get; set; } + + public Evaluation? Result { get; set; } + + public class Evaluation + { + public object? Value { get; set; } + + public EvaluationReason Reason { get; set; } + + public string? Variant { get; set; } + + public string? Error { get; set; } + + public Dictionary? FlagMetadata { get; set; } + } + } + + /* + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "alice", + "attributes": { + "one_of_flag": true + }, + "result": { + "value": 1, + "variant": "1", + "flagMetadata": { + "allocationKey": "1-for-one-of", + "variationType": "number", + "doLog": true + } + } + + */ +} +#pragma warning restore SA1204 // Static elements should appear before instance elements +#pragma warning restore SA1500 // Braces for multi-line statements should not share line diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs index 466a0be522d1..dd7c9b6a6cb2 100644 --- a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs @@ -17,7 +17,8 @@ namespace Datadog.Trace.Tests.FeatureFlags; -public class FeatureFlagsEvaluatorTests +/// FeatureFlagsEvaluator discrete tests +public partial class FeatureFlagsEvaluatorTests { #pragma warning disable SA1204 // Static elements should appear before instance elements #pragma warning disable SA1500 // Braces for multi-line statements should not share line @@ -175,12 +176,12 @@ public void EvaluateFlagWithoutAllocationsReturnsGeneralError() var result1 = evaluator.Evaluate("null-allocation", 23, ctx); Assert.Equal(23, result1.Value); Assert.Equal(EvaluationReason.ERROR, result1.Reason); - Assert.Equal("GENERAL", result1.Metadata?["errorCode"]); + Assert.Equal("GENERAL", result1.FlagMetadata?["errorCode"]); var result2 = evaluator.Evaluate("empty-allocation", 23, ctx); Assert.Equal(23, result2.Value); Assert.Equal(EvaluationReason.ERROR, result2.Reason); - Assert.Equal("GENERAL", result2.Metadata?["errorCode"]); + Assert.Equal("GENERAL", result2.FlagMetadata?["errorCode"]); } // --------------------------------------------------------------------- diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/config/flags-v1.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/config/flags-v1.json new file mode 100644 index 000000000000..8c7c1c293082 --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/config/flags-v1.json @@ -0,0 +1,2898 @@ +{ + "data": { + "type": "universal-flag-configuration", + "id": "1", + "attributes": { + "createdAt": "2024-04-17T19:40:53.716Z", + "format": "SERVER", + "environment": { + "name": "Test" + }, + "flags": { + "empty_flag": { + "key": "empty_flag", + "enabled": true, + "variationType": "STRING", + "variations": {}, + "allocations": [] + }, + "disabled_flag": { + "key": "disabled_flag", + "enabled": false, + "variationType": "INTEGER", + "variations": {}, + "allocations": [] + }, + "no_allocations_flag": { + "key": "no_allocations_flag", + "enabled": true, + "variationType": "JSON", + "variations": { + "control": { + "key": "control", + "value": { "variant": "control" } + }, + "treatment": { + "key": "treatment", + "value": { "variant": "treatment" } + } + }, + "allocations": [] + }, + "numeric_flag": { + "key": "numeric_flag", + "enabled": true, + "variationType": "NUMERIC", + "variations": { + "e": { + "key": "e", + "value": 2.7182818 + }, + "pi": { + "key": "pi", + "value": 3.1415926 + } + }, + "allocations": [ + { + "key": "rollout", + "splits": [ + { + "variationKey": "pi", + "shards": [] + } + ], + "doLog": true + } + ] + }, + "regex-flag": { + "key": "regex-flag", + "enabled": true, + "variationType": "STRING", + "variations": { + "partial-example": { + "key": "partial-example", + "value": "partial-example" + }, + "test": { + "key": "test", + "value": "test" + } + }, + "allocations": [ + { + "key": "partial-example", + "rules": [ + { + "conditions": [ + { + "attribute": "email", + "operator": "MATCHES", + "value": "@example\\.com" + } + ] + } + ], + "splits": [ + { + "variationKey": "partial-example", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "test", + "rules": [ + { + "conditions": [ + { + "attribute": "email", + "operator": "MATCHES", + "value": ".*@test\\.com" + } + ] + } + ], + "splits": [ + { + "variationKey": "test", + "shards": [] + } + ], + "doLog": true + } + ] + }, + "numeric-one-of": { + "key": "numeric-one-of", + "enabled": true, + "variationType": "INTEGER", + "variations": { + "1": { + "key": "1", + "value": 1 + }, + "2": { + "key": "2", + "value": 2 + }, + "3": { + "key": "3", + "value": 3 + } + }, + "allocations": [ + { + "key": "1-for-1", + "rules": [ + { + "conditions": [ + { + "attribute": "number", + "operator": "ONE_OF", + "value": ["1"] + } + ] + } + ], + "splits": [ + { + "variationKey": "1", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "2-for-123456789", + "rules": [ + { + "conditions": [ + { + "attribute": "number", + "operator": "ONE_OF", + "value": ["123456789"] + } + ] + } + ], + "splits": [ + { + "variationKey": "2", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "3-for-not-2", + "rules": [ + { + "conditions": [ + { + "attribute": "number", + "operator": "NOT_ONE_OF", + "value": ["2"] + } + ] + } + ], + "splits": [ + { + "variationKey": "3", + "shards": [] + } + ], + "doLog": true + } + ] + }, + "boolean-one-of-matches": { + "key": "boolean-one-of-matches", + "enabled": true, + "variationType": "INTEGER", + "variations": { + "1": { + "key": "1", + "value": 1 + }, + "2": { + "key": "2", + "value": 2 + }, + "3": { + "key": "3", + "value": 3 + }, + "4": { + "key": "4", + "value": 4 + }, + "5": { + "key": "5", + "value": 5 + } + }, + "allocations": [ + { + "key": "1-for-one-of", + "rules": [ + { + "conditions": [ + { + "attribute": "one_of_flag", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "1", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "2-for-matches", + "rules": [ + { + "conditions": [ + { + "attribute": "matches_flag", + "operator": "MATCHES", + "value": "true" + } + ] + } + ], + "splits": [ + { + "variationKey": "2", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "3-for-not-one-of", + "rules": [ + { + "conditions": [ + { + "attribute": "not_one_of_flag", + "operator": "NOT_ONE_OF", + "value": ["false"] + } + ] + } + ], + "splits": [ + { + "variationKey": "3", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "4-for-not-matches", + "rules": [ + { + "conditions": [ + { + "attribute": "not_matches_flag", + "operator": "NOT_MATCHES", + "value": "false" + } + ] + } + ], + "splits": [ + { + "variationKey": "4", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "5-for-matches-null", + "rules": [ + { + "conditions": [ + { + "attribute": "null_flag", + "operator": "ONE_OF", + "value": ["null"] + } + ] + } + ], + "splits": [ + { + "variationKey": "5", + "shards": [] + } + ], + "doLog": true + } + ] + }, + "empty_string_flag": { + "key": "empty_string_flag", + "enabled": true, + "comment": "Testing the empty string as a variation value", + "variationType": "STRING", + "variations": { + "empty_string": { + "key": "empty_string", + "value": "" + }, + "non_empty": { + "key": "non_empty", + "value": "non_empty" + } + }, + "allocations": [ + { + "key": "allocation-empty", + "rules": [ + { + "conditions": [ + { + "attribute": "country", + "operator": "MATCHES", + "value": "US" + } + ] + } + ], + "splits": [ + { + "variationKey": "empty_string", + "shards": [ + { + "salt": "allocation-empty-shards", + "totalShards": 10000, + "ranges": [ + { + "start": 0, + "end": 10000 + } + ] + } + ] + } + ], + "doLog": true + }, + { + "key": "allocation-test", + "rules": [], + "splits": [ + { + "variationKey": "non_empty", + "shards": [ + { + "salt": "allocation-empty-shards", + "totalShards": 10000, + "ranges": [ + { + "start": 0, + "end": 10000 + } + ] + } + ] + } + ], + "doLog": true + } + ] + }, + "kill-switch": { + "key": "kill-switch", + "enabled": true, + "variationType": "BOOLEAN", + "variations": { + "on": { + "key": "on", + "value": true + }, + "off": { + "key": "off", + "value": false + } + }, + "allocations": [ + { + "key": "on-for-NA", + "rules": [ + { + "conditions": [ + { + "attribute": "country", + "operator": "ONE_OF", + "value": ["US", "Canada", "Mexico"] + } + ] + } + ], + "splits": [ + { + "variationKey": "on", + "shards": [ + { + "salt": "some-salt", + "totalShards": 10000, + "ranges": [ + { + "start": 0, + "end": 10000 + } + ] + } + ] + } + ], + "doLog": true + }, + { + "key": "on-for-age-50+", + "rules": [ + { + "conditions": [ + { + "attribute": "age", + "operator": "GTE", + "value": 50 + } + ] + } + ], + "splits": [ + { + "variationKey": "on", + "shards": [ + { + "salt": "some-salt", + "totalShards": 10000, + "ranges": [ + { + "start": 0, + "end": 10000 + } + ] + } + ] + } + ], + "doLog": true + }, + { + "key": "off-for-all", + "rules": [], + "splits": [ + { + "variationKey": "off", + "shards": [] + } + ], + "doLog": true + } + ] + }, + "comparator-operator-test": { + "key": "comparator-operator-test", + "enabled": true, + "variationType": "STRING", + "variations": { + "small": { + "key": "small", + "value": "small" + }, + "medium": { + "key": "medium", + "value": "medium" + }, + "large": { + "key": "large", + "value": "large" + } + }, + "allocations": [ + { + "key": "small-size", + "rules": [ + { + "conditions": [ + { + "attribute": "size", + "operator": "LT", + "value": 10 + } + ] + } + ], + "splits": [ + { + "variationKey": "small", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "medum-size", + "rules": [ + { + "conditions": [ + { + "attribute": "size", + "operator": "GTE", + "value": 10 + }, + { + "attribute": "size", + "operator": "LTE", + "value": 20 + } + ] + } + ], + "splits": [ + { + "variationKey": "medium", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "large-size", + "rules": [ + { + "conditions": [ + { + "attribute": "size", + "operator": "GT", + "value": 25 + } + ] + } + ], + "splits": [ + { + "variationKey": "large", + "shards": [] + } + ], + "doLog": true + } + ] + }, + "start-and-end-date-test": { + "key": "start-and-end-date-test", + "enabled": true, + "variationType": "STRING", + "variations": { + "old": { + "key": "old", + "value": "old" + }, + "current": { + "key": "current", + "value": "current" + }, + "new": { + "key": "new", + "value": "new" + } + }, + "allocations": [ + { + "key": "old-versions", + "splits": [ + { + "variationKey": "old", + "shards": [] + } + ], + "endAt": "2002-10-31T09:00:00.594Z", + "doLog": true + }, + { + "key": "future-versions", + "splits": [ + { + "variationKey": "new", + "shards": [] + } + ], + "startAt": "2052-10-31T09:00:00.594Z", + "doLog": true + }, + { + "key": "current-versions", + "splits": [ + { + "variationKey": "current", + "shards": [] + } + ], + "startAt": "2022-10-31T09:00:00.594Z", + "endAt": "2050-10-31T09:00:00.594Z", + "doLog": true + } + ] + }, + "null-operator-test": { + "key": "null-operator-test", + "enabled": true, + "variationType": "STRING", + "variations": { + "old": { + "key": "old", + "value": "old" + }, + "new": { + "key": "new", + "value": "new" + } + }, + "allocations": [ + { + "key": "null-operator", + "rules": [ + { + "conditions": [ + { + "attribute": "size", + "operator": "IS_NULL", + "value": true + } + ] + }, + { + "conditions": [ + { + "attribute": "size", + "operator": "LT", + "value": 10 + } + ] + } + ], + "splits": [ + { + "variationKey": "old", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "not-null-operator", + "rules": [ + { + "conditions": [ + { + "attribute": "size", + "operator": "IS_NULL", + "value": false + } + ] + } + ], + "splits": [ + { + "variationKey": "new", + "shards": [] + } + ], + "doLog": true + } + ] + }, + "new-user-onboarding": { + "key": "new-user-onboarding", + "enabled": true, + "variationType": "STRING", + "variations": { + "control": { + "key": "control", + "value": "control" + }, + "red": { + "key": "red", + "value": "red" + }, + "blue": { + "key": "blue", + "value": "blue" + }, + "green": { + "key": "green", + "value": "green" + }, + "yellow": { + "key": "yellow", + "value": "yellow" + }, + "purple": { + "key": "purple", + "value": "purple" + } + }, + "allocations": [ + { + "key": "id rule", + "rules": [ + { + "conditions": [ + { + "attribute": "id", + "operator": "MATCHES", + "value": "zach" + } + ] + } + ], + "splits": [ + { + "variationKey": "purple", + "shards": [] + } + ], + "doLog": false + }, + { + "key": "internal users", + "rules": [ + { + "conditions": [ + { + "attribute": "email", + "operator": "MATCHES", + "value": "@mycompany.com" + } + ] + } + ], + "splits": [ + { + "variationKey": "green", + "shards": [] + } + ], + "doLog": false + }, + { + "key": "experiment", + "rules": [ + { + "conditions": [ + { + "attribute": "country", + "operator": "NOT_ONE_OF", + "value": ["US", "Canada", "Mexico"] + } + ] + } + ], + "splits": [ + { + "variationKey": "control", + "shards": [ + { + "salt": "traffic-new-user-onboarding-experiment", + "totalShards": 10000, + "ranges": [ + { + "start": 0, + "end": 6000 + } + ] + }, + { + "salt": "split-new-user-onboarding-experiment", + "totalShards": 10000, + "ranges": [ + { + "start": 0, + "end": 5000 + } + ] + } + ] + }, + { + "variationKey": "red", + "shards": [ + { + "salt": "traffic-new-user-onboarding-experiment", + "totalShards": 10000, + "ranges": [ + { + "start": 0, + "end": 6000 + } + ] + }, + { + "salt": "split-new-user-onboarding-experiment", + "totalShards": 10000, + "ranges": [ + { + "start": 5000, + "end": 8000 + } + ] + } + ] + }, + { + "variationKey": "yellow", + "shards": [ + { + "salt": "traffic-new-user-onboarding-experiment", + "totalShards": 10000, + "ranges": [ + { + "start": 0, + "end": 6000 + } + ] + }, + { + "salt": "split-new-user-onboarding-experiment", + "totalShards": 10000, + "ranges": [ + { + "start": 8000, + "end": 10000 + } + ] + } + ] + } + ], + "doLog": true + }, + { + "key": "rollout", + "rules": [ + { + "conditions": [ + { + "attribute": "country", + "operator": "ONE_OF", + "value": ["US", "Canada", "Mexico"] + } + ] + } + ], + "splits": [ + { + "variationKey": "blue", + "shards": [ + { + "salt": "split-new-user-onboarding-rollout", + "totalShards": 10000, + "ranges": [ + { + "start": 0, + "end": 8000 + } + ] + } + ], + "extraLogging": { + "allocationvalue_type": "rollout", + "owner": "hippo" + } + } + ], + "doLog": true + } + ] + }, + "integer-flag": { + "key": "integer-flag", + "enabled": true, + "variationType": "INTEGER", + "variations": { + "one": { + "key": "one", + "value": 1 + }, + "two": { + "key": "two", + "value": 2 + }, + "three": { + "key": "three", + "value": 3 + } + }, + "allocations": [ + { + "key": "targeted allocation", + "rules": [ + { + "conditions": [ + { + "attribute": "country", + "operator": "ONE_OF", + "value": ["US", "Canada", "Mexico"] + } + ] + }, + { + "conditions": [ + { + "attribute": "email", + "operator": "MATCHES", + "value": ".*@example.com" + } + ] + } + ], + "splits": [ + { + "variationKey": "three", + "shards": [ + { + "salt": "full-range-salt", + "totalShards": 10000, + "ranges": [ + { + "start": 0, + "end": 10000 + } + ] + } + ] + } + ], + "doLog": true + }, + { + "key": "50/50 split", + "rules": [], + "splits": [ + { + "variationKey": "one", + "shards": [ + { + "salt": "split-numeric-flag-some-allocation", + "totalShards": 10000, + "ranges": [ + { + "start": 0, + "end": 5000 + } + ] + } + ] + }, + { + "variationKey": "two", + "shards": [ + { + "salt": "split-numeric-flag-some-allocation", + "totalShards": 10000, + "ranges": [ + { + "start": 5000, + "end": 10000 + } + ] + } + ] + } + ], + "doLog": true + } + ] + }, + "json-config-flag": { + "key": "json-config-flag", + "enabled": true, + "variationType": "JSON", + "variations": { + "one": { + "key": "one", + "value": { "integer": 1, "string": "one", "float": 1.0 } + }, + "two": { + "key": "two", + "value": { "integer": 2, "string": "two", "float": 2.0 } + }, + "empty": { + "key": "empty", + "value": {} + } + }, + "allocations": [ + { + "key": "Optionally Force Empty", + "rules": [ + { + "conditions": [ + { + "attribute": "Force Empty", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "empty", + "shards": [ + { + "salt": "full-range-salt", + "totalShards": 10000, + "ranges": [ + { + "start": 0, + "end": 10000 + } + ] + } + ] + } + ], + "doLog": true + }, + { + "key": "50/50 split", + "rules": [], + "splits": [ + { + "variationKey": "one", + "shards": [ + { + "salt": "traffic-json-flag", + "totalShards": 10000, + "ranges": [ + { + "start": 0, + "end": 10000 + } + ] + }, + { + "salt": "split-json-flag", + "totalShards": 10000, + "ranges": [ + { + "start": 0, + "end": 5000 + } + ] + } + ] + }, + { + "variationKey": "two", + "shards": [ + { + "salt": "traffic-json-flag", + "totalShards": 10000, + "ranges": [ + { + "start": 0, + "end": 10000 + } + ] + }, + { + "salt": "split-json-flag", + "totalShards": 10000, + "ranges": [ + { + "start": 5000, + "end": 10000 + } + ] + } + ] + } + ], + "doLog": true + } + ] + }, + "special-characters": { + "key": "special-characters", + "enabled": true, + "variationType": "JSON", + "variations": { + "de": { + "key": "de", + "value": { "a": "kümmert", "b": "schön" } + }, + "ua": { + "key": "ua", + "value": { "a": "піклуватися", "b": "любов" } + }, + "zh": { + "key": "zh", + "value": { "a": "照顾", "b": "漂亮" } + }, + "emoji": { + "key": "emoji", + "value": { "a": "🤗", "b": "🌸" } + } + }, + "allocations": [ + { + "key": "allocation-test", + "splits": [ + { + "variationKey": "de", + "shards": [ + { + "salt": "split-json-flag", + "totalShards": 10000, + "ranges": [ + { + "start": 0, + "end": 2500 + } + ] + } + ] + }, + { + "variationKey": "ua", + "shards": [ + { + "salt": "split-json-flag", + "totalShards": 10000, + "ranges": [ + { + "start": 2500, + "end": 5000 + } + ] + } + ] + }, + { + "variationKey": "zh", + "shards": [ + { + "salt": "split-json-flag", + "totalShards": 10000, + "ranges": [ + { + "start": 5000, + "end": 7500 + } + ] + } + ] + }, + { + "variationKey": "emoji", + "shards": [ + { + "salt": "split-json-flag", + "totalShards": 10000, + "ranges": [ + { + "start": 7500, + "end": 10000 + } + ] + } + ] + } + ], + "doLog": true + }, + { + "key": "allocation-default", + "splits": [ + { + "variationKey": "de", + "shards": [] + } + ], + "doLog": false + } + ] + }, + "string_flag_with_special_characters": { + "key": "string_flag_with_special_characters", + "enabled": true, + "comment": "Testing the string with special characters and spaces", + "variationType": "STRING", + "variations": { + "string_with_spaces": { + "key": "string_with_spaces", + "value": " a b c d e f " + }, + "string_with_only_one_space": { + "key": "string_with_only_one_space", + "value": " " + }, + "string_with_only_multiple_spaces": { + "key": "string_with_only_multiple_spaces", + "value": " " + }, + "string_with_dots": { + "key": "string_with_dots", + "value": ".a.b.c.d.e.f." + }, + "string_with_only_one_dot": { + "key": "string_with_only_one_dot", + "value": "." + }, + "string_with_only_multiple_dots": { + "key": "string_with_only_multiple_dots", + "value": "......." + }, + "string_with_comas": { + "key": "string_with_comas", + "value": ",a,b,c,d,e,f," + }, + "string_with_only_one_coma": { + "key": "string_with_only_one_coma", + "value": "," + }, + "string_with_only_multiple_comas": { + "key": "string_with_only_multiple_comas", + "value": ",,,,,,," + }, + "string_with_colons": { + "key": "string_with_colons", + "value": ":a:b:c:d:e:f:" + }, + "string_with_only_one_colon": { + "key": "string_with_only_one_colon", + "value": ":" + }, + "string_with_only_multiple_colons": { + "key": "string_with_only_multiple_colons", + "value": ":::::::" + }, + "string_with_semicolons": { + "key": "string_with_semicolons", + "value": ";a;b;c;d;e;f;" + }, + "string_with_only_one_semicolon": { + "key": "string_with_only_one_semicolon", + "value": ";" + }, + "string_with_only_multiple_semicolons": { + "key": "string_with_only_multiple_semicolons", + "value": ";;;;;;;" + }, + "string_with_slashes": { + "key": "string_with_slashes", + "value": "/a/b/c/d/e/f/" + }, + "string_with_only_one_slash": { + "key": "string_with_only_one_slash", + "value": "/" + }, + "string_with_only_multiple_slashes": { + "key": "string_with_only_multiple_slashes", + "value": "///////" + }, + "string_with_dashes": { + "key": "string_with_dashes", + "value": "-a-b-c-d-e-f-" + }, + "string_with_only_one_dash": { + "key": "string_with_only_one_dash", + "value": "-" + }, + "string_with_only_multiple_dashes": { + "key": "string_with_only_multiple_dashes", + "value": "-------" + }, + "string_with_underscores": { + "key": "string_with_underscores", + "value": "_a_b_c_d_e_f_" + }, + "string_with_only_one_underscore": { + "key": "string_with_only_one_underscore", + "value": "_" + }, + "string_with_only_multiple_underscores": { + "key": "string_with_only_multiple_underscores", + "value": "_______" + }, + "string_with_plus_signs": { + "key": "string_with_plus_signs", + "value": "+a+b+c+d+e+f+" + }, + "string_with_only_one_plus_sign": { + "key": "string_with_only_one_plus_sign", + "value": "+" + }, + "string_with_only_multiple_plus_signs": { + "key": "string_with_only_multiple_plus_signs", + "value": "+++++++" + }, + "string_with_equal_signs": { + "key": "string_with_equal_signs", + "value": "=a=b=c=d=e=f=" + }, + "string_with_only_one_equal_sign": { + "key": "string_with_only_one_equal_sign", + "value": "=" + }, + "string_with_only_multiple_equal_signs": { + "key": "string_with_only_multiple_equal_signs", + "value": "=======" + }, + "string_with_dollar_signs": { + "key": "string_with_dollar_signs", + "value": "$a$b$c$d$e$f$" + }, + "string_with_only_one_dollar_sign": { + "key": "string_with_only_one_dollar_sign", + "value": "$" + }, + "string_with_only_multiple_dollar_signs": { + "key": "string_with_only_multiple_dollar_signs", + "value": "$$$$$$$" + }, + "string_with_at_signs": { + "key": "string_with_at_signs", + "value": "@a@b@c@d@e@f@" + }, + "string_with_only_one_at_sign": { + "key": "string_with_only_one_at_sign", + "value": "@" + }, + "string_with_only_multiple_at_signs": { + "key": "string_with_only_multiple_at_signs", + "value": "@@@@@@@" + }, + "string_with_amp_signs": { + "key": "string_with_amp_signs", + "value": "&a&b&c&d&e&f&" + }, + "string_with_only_one_amp_sign": { + "key": "string_with_only_one_amp_sign", + "value": "&" + }, + "string_with_only_multiple_amp_signs": { + "key": "string_with_only_multiple_amp_signs", + "value": "&&&&&&&" + }, + "string_with_hash_signs": { + "key": "string_with_hash_signs", + "value": "#a#b#c#d#e#f#" + }, + "string_with_only_one_hash_sign": { + "key": "string_with_only_one_hash_sign", + "value": "#" + }, + "string_with_only_multiple_hash_signs": { + "key": "string_with_only_multiple_hash_signs", + "value": "#######" + }, + "string_with_percentage_signs": { + "key": "string_with_percentage_signs", + "value": "%a%b%c%d%e%f%" + }, + "string_with_only_one_percentage_sign": { + "key": "string_with_only_one_percentage_sign", + "value": "%" + }, + "string_with_only_multiple_percentage_signs": { + "key": "string_with_only_multiple_percentage_signs", + "value": "%%%%%%%" + }, + "string_with_tilde_signs": { + "key": "string_with_tilde_signs", + "value": "~a~b~c~d~e~f~" + }, + "string_with_only_one_tilde_sign": { + "key": "string_with_only_one_tilde_sign", + "value": "~" + }, + "string_with_only_multiple_tilde_signs": { + "key": "string_with_only_multiple_tilde_signs", + "value": "~~~~~~~" + }, + "string_with_asterix_signs": { + "key": "string_with_asterix_signs", + "value": "*a*b*c*d*e*f*" + }, + "string_with_only_one_asterix_sign": { + "key": "string_with_only_one_asterix_sign", + "value": "*" + }, + "string_with_only_multiple_asterix_signs": { + "key": "string_with_only_multiple_asterix_signs", + "value": "*******" + }, + "string_with_single_quotes": { + "key": "string_with_single_quotes", + "value": "'a'b'c'd'e'f'" + }, + "string_with_only_one_single_quote": { + "key": "string_with_only_one_single_quote", + "value": "'" + }, + "string_with_only_multiple_single_quotes": { + "key": "string_with_only_multiple_single_quotes", + "value": "'''''''" + }, + "string_with_question_marks": { + "key": "string_with_question_marks", + "value": "?a?b?c?d?e?f?" + }, + "string_with_only_one_question_mark": { + "key": "string_with_only_one_question_mark", + "value": "?" + }, + "string_with_only_multiple_question_marks": { + "key": "string_with_only_multiple_question_marks", + "value": "???????" + }, + "string_with_exclamation_marks": { + "key": "string_with_exclamation_marks", + "value": "!a!b!c!d!e!f!" + }, + "string_with_only_one_exclamation_mark": { + "key": "string_with_only_one_exclamation_mark", + "value": "!" + }, + "string_with_only_multiple_exclamation_marks": { + "key": "string_with_only_multiple_exclamation_marks", + "value": "!!!!!!!" + }, + "string_with_opening_parentheses": { + "key": "string_with_opening_parentheses", + "value": "(a(b(c(d(e(f(" + }, + "string_with_only_one_opening_parenthese": { + "key": "string_with_only_one_opening_parenthese", + "value": "(" + }, + "string_with_only_multiple_opening_parentheses": { + "key": "string_with_only_multiple_opening_parentheses", + "value": "(((((((" + }, + "string_with_closing_parentheses": { + "key": "string_with_closing_parentheses", + "value": ")a)b)c)d)e)f)" + }, + "string_with_only_one_closing_parenthese": { + "key": "string_with_only_one_closing_parenthese", + "value": ")" + }, + "string_with_only_multiple_closing_parentheses": { + "key": "string_with_only_multiple_closing_parentheses", + "value": ")))))))" + } + }, + "allocations": [ + { + "key": "allocation-test-string_with_spaces", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_spaces", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_spaces", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_space", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_space", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_space", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_spaces", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_spaces", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_spaces", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_dots", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_dots", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_dots", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_dot", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_dot", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_dot", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_dots", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_dots", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_dots", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_comas", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_comas", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_comas", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_coma", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_coma", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_coma", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_comas", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_comas", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_comas", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_colons", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_colons", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_colons", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_colon", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_colon", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_colon", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_colons", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_colons", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_colons", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_semicolons", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_semicolons", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_semicolons", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_semicolon", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_semicolon", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_semicolon", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_semicolons", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_semicolons", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_semicolons", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_slashes", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_slashes", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_slashes", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_slash", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_slash", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_slash", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_slashes", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_slashes", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_slashes", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_dashes", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_dashes", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_dashes", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_dash", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_dash", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_dash", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_dashes", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_dashes", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_dashes", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_underscores", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_underscores", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_underscores", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_underscore", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_underscore", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_underscore", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_underscores", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_underscores", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_underscores", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_plus_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_plus_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_plus_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_plus_sign", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_plus_sign", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_plus_sign", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_plus_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_plus_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_plus_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_equal_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_equal_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_equal_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_equal_sign", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_equal_sign", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_equal_sign", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_equal_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_equal_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_equal_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_dollar_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_dollar_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_dollar_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_dollar_sign", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_dollar_sign", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_dollar_sign", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_dollar_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_dollar_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_dollar_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_at_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_at_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_at_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_at_sign", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_at_sign", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_at_sign", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_at_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_at_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_at_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_amp_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_amp_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_amp_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_amp_sign", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_amp_sign", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_amp_sign", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_amp_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_amp_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_amp_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_hash_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_hash_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_hash_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_hash_sign", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_hash_sign", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_hash_sign", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_hash_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_hash_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_hash_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_percentage_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_percentage_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_percentage_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_percentage_sign", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_percentage_sign", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_percentage_sign", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_percentage_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_percentage_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_percentage_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_tilde_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_tilde_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_tilde_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_tilde_sign", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_tilde_sign", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_tilde_sign", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_tilde_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_tilde_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_tilde_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_asterix_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_asterix_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_asterix_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_asterix_sign", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_asterix_sign", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_asterix_sign", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_asterix_signs", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_asterix_signs", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_asterix_signs", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_single_quotes", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_single_quotes", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_single_quotes", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_single_quote", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_single_quote", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_single_quote", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_single_quotes", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_single_quotes", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_single_quotes", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_question_marks", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_question_marks", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_question_marks", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_question_mark", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_question_mark", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_question_mark", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_question_marks", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_question_marks", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_question_marks", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_exclamation_marks", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_exclamation_marks", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_exclamation_marks", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_exclamation_mark", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_exclamation_mark", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_exclamation_mark", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_exclamation_marks", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_exclamation_marks", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_exclamation_marks", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_opening_parentheses", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_opening_parentheses", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_opening_parentheses", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_opening_parenthese", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_opening_parenthese", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_opening_parenthese", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_opening_parentheses", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_opening_parentheses", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_opening_parentheses", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_closing_parentheses", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_closing_parentheses", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_closing_parentheses", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_one_closing_parenthese", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_one_closing_parenthese", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_one_closing_parenthese", + "shards": [] + } + ], + "doLog": true + }, + { + "key": "allocation-test-string_with_only_multiple_closing_parentheses", + "rules": [ + { + "conditions": [ + { + "attribute": "string_with_only_multiple_closing_parentheses", + "operator": "ONE_OF", + "value": ["true"] + } + ] + } + ], + "splits": [ + { + "variationKey": "string_with_only_multiple_closing_parentheses", + "shards": [] + } + ], + "doLog": true + } + ] + } + } + } + } +} diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-boolean-one-of-matches.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-boolean-one-of-matches.json new file mode 100644 index 000000000000..6bfbf0effad9 --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-boolean-one-of-matches.json @@ -0,0 +1,240 @@ +[ + { + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "alice", + "attributes": { + "one_of_flag": true + }, + "result": { + "value": 1, + "variant": "1", + "flagMetadata": { + "allocationKey": "1-for-one-of", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "bob", + "attributes": { + "one_of_flag": false + }, + "result": { + "value": 0 + } + }, + { + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "charlie", + "attributes": { + "one_of_flag": "True" + }, + "result": { + "value": 0 + } + }, + { + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "derek", + "attributes": { + "matches_flag": true + }, + "result": { + "value": 2, + "variant": "2", + "flagMetadata": { + "allocationKey": "2-for-matches", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "erica", + "attributes": { + "matches_flag": false + }, + "result": { + "value": 0 + } + }, + { + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "frank", + "attributes": { + "not_matches_flag": false + }, + "result": { + "value": 0 + } + }, + { + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "george", + "attributes": { + "not_matches_flag": true + }, + "result": { + "value": 4, + "variant": "4", + "flagMetadata": { + "allocationKey": "4-for-not-matches", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "haley", + "attributes": { + "not_matches_flag": "False" + }, + "result": { + "value": 4, + "variant": "4", + "flagMetadata": { + "allocationKey": "4-for-not-matches", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "ivy", + "attributes": { + "not_one_of_flag": true + }, + "result": { + "value": 3, + "variant": "3", + "flagMetadata": { + "allocationKey": "3-for-not-one-of", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "julia", + "attributes": { + "not_one_of_flag": false + }, + "result": { + "value": 0 + } + }, + { + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "kim", + "attributes": { + "not_one_of_flag": "False" + }, + "result": { + "value": 3, + "variant": "3", + "flagMetadata": { + "allocationKey": "3-for-not-one-of", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "lucas", + "attributes": { + "not_one_of_flag": "true" + }, + "result": { + "value": 3, + "variant": "3", + "flagMetadata": { + "allocationKey": "3-for-not-one-of", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "mike", + "attributes": { + "not_one_of_flag": "false" + }, + "result": { + "value": 0 + } + }, + { + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "nicole", + "attributes": { + "null_flag": "null" + }, + "result": { + "value": 5, + "variant": "5", + "flagMetadata": { + "allocationKey": "5-for-matches-null", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "owen", + "attributes": { + "null_flag": null + }, + "result": { + "value": 0 + } + }, + { + "flag": "boolean-one-of-matches", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "pete", + "attributes": {}, + "result": { + "value": 0 + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-comparator-operator-flag.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-comparator-operator-flag.json new file mode 100644 index 000000000000..a5c8ef07cd40 --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-comparator-operator-flag.json @@ -0,0 +1,82 @@ +[ + { + "flag": "comparator-operator-test", + "variationType": "STRING", + "defaultValue": "unknown", + "targetingKey": "alice", + "attributes": { + "size": 5, + "country": "US" + }, + "result": { + "value": "small", + "variant": "small", + "flagMetadata": { + "allocationKey": "small-size", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "comparator-operator-test", + "variationType": "STRING", + "defaultValue": "unknown", + "targetingKey": "bob", + "attributes": { + "size": 10, + "country": "Canada" + }, + "result": { + "value": "medium", + "variant": "medium", + "flagMetadata": { + "allocationKey": "medum-size", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "comparator-operator-test", + "variationType": "STRING", + "defaultValue": "unknown", + "targetingKey": "charlie", + "attributes": { + "size": 25 + }, + "result": { + "value": "unknown" + } + }, + { + "flag": "comparator-operator-test", + "variationType": "STRING", + "defaultValue": "unknown", + "targetingKey": "david", + "attributes": { + "size": 26 + }, + "result": { + "value": "large", + "variant": "large", + "flagMetadata": { + "allocationKey": "large-size", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "comparator-operator-test", + "variationType": "STRING", + "defaultValue": "unknown", + "targetingKey": "elize", + "attributes": { + "country": "UK" + }, + "result": { + "value": "unknown" + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-disabled-flag.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-disabled-flag.json new file mode 100644 index 000000000000..0da79189ade8 --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-disabled-flag.json @@ -0,0 +1,40 @@ +[ + { + "flag": "disabled_flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "alice", + "attributes": { + "email": "alice@mycompany.com", + "country": "US" + }, + "result": { + "value": 0 + } + }, + { + "flag": "disabled_flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "bob", + "attributes": { + "email": "bob@example.com", + "country": "Canada" + }, + "result": { + "value": 0 + } + }, + { + "flag": "disabled_flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "charlie", + "attributes": { + "age": 50 + }, + "result": { + "value": 0 + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-empty-flag.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-empty-flag.json new file mode 100644 index 000000000000..52100b1fe47d --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-empty-flag.json @@ -0,0 +1,40 @@ +[ + { + "flag": "empty_flag", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "alice", + "attributes": { + "email": "alice@mycompany.com", + "country": "US" + }, + "result": { + "value": "default_value" + } + }, + { + "flag": "empty_flag", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "bob", + "attributes": { + "email": "bob@example.com", + "country": "Canada" + }, + "result": { + "value": "default_value" + } + }, + { + "flag": "empty_flag", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "charlie", + "attributes": { + "age": 50 + }, + "result": { + "value": "default_value" + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-flag-with-empty-string.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-flag-with-empty-string.json new file mode 100644 index 000000000000..32a1c1febb7b --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-flag-with-empty-string.json @@ -0,0 +1,36 @@ +[ + { + "flag": "empty_string_flag", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "alice", + "attributes": { + "country": "US" + }, + "result": { + "value": "", + "variant": "empty_string", + "flagMetadata": { + "allocationKey": "allocation-empty", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "empty_string_flag", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "bob", + "attributes": {}, + "result": { + "value": "non_empty", + "variant": "non_empty", + "flagMetadata": { + "allocationKey": "allocation-test", + "variationType": "string", + "doLog": true + } + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-integer-flag.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-integer-flag.json new file mode 100644 index 000000000000..4a41d042f628 --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-integer-flag.json @@ -0,0 +1,382 @@ +[ + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "alice", + "attributes": { + "email": "alice@mycompany.com", + "country": "US" + }, + "result": { + "value": 3, + "variant": "three", + "flagMetadata": { + "allocationKey": "targeted allocation", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "bob", + "attributes": { + "email": "bob@example.com", + "country": "Canada" + }, + "result": { + "value": 3, + "variant": "three", + "flagMetadata": { + "allocationKey": "targeted allocation", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "charlie", + "attributes": { + "age": 50 + }, + "result": { + "value": 2, + "variant": "two", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "debra", + "attributes": { + "email": "test@test.com", + "country": "Mexico", + "age": 25 + }, + "result": { + "value": 3, + "variant": "three", + "flagMetadata": { + "allocationKey": "targeted allocation", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "1", + "attributes": {}, + "result": { + "value": 2, + "variant": "two", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "2", + "attributes": {}, + "result": { + "value": 2, + "variant": "two", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "3", + "attributes": {}, + "result": { + "value": 2, + "variant": "two", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "4", + "attributes": {}, + "result": { + "value": 2, + "variant": "two", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "5", + "attributes": {}, + "result": { + "value": 1, + "variant": "one", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "6", + "attributes": {}, + "result": { + "value": 2, + "variant": "two", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "7", + "attributes": {}, + "result": { + "value": 1, + "variant": "one", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "8", + "attributes": {}, + "result": { + "value": 1, + "variant": "one", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "9", + "attributes": {}, + "result": { + "value": 2, + "variant": "two", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "10", + "attributes": {}, + "result": { + "value": 2, + "variant": "two", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "11", + "attributes": {}, + "result": { + "value": 1, + "variant": "one", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "12", + "attributes": {}, + "result": { + "value": 1, + "variant": "one", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "13", + "attributes": {}, + "result": { + "value": 2, + "variant": "two", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "14", + "attributes": {}, + "result": { + "value": 1, + "variant": "one", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "15", + "attributes": {}, + "result": { + "value": 2, + "variant": "two", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "16", + "attributes": {}, + "result": { + "value": 2, + "variant": "two", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "17", + "attributes": {}, + "result": { + "value": 1, + "variant": "one", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "18", + "attributes": {}, + "result": { + "value": 1, + "variant": "one", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "integer-flag", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "19", + "attributes": {}, + "result": { + "value": 1, + "variant": "one", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "number", + "doLog": true + } + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-kill-switch-flag.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-kill-switch-flag.json new file mode 100644 index 000000000000..29e65ba5bb41 --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-kill-switch-flag.json @@ -0,0 +1,434 @@ +[ + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "alice", + "attributes": { + "email": "alice@mycompany.com", + "country": "US" + }, + "result": { + "value": true, + "variant": "on", + "flagMetadata": { + "allocationKey": "on-for-NA", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "bob", + "attributes": { + "email": "bob@example.com", + "country": "Canada" + }, + "result": { + "value": true, + "variant": "on", + "flagMetadata": { + "allocationKey": "on-for-NA", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "barbara", + "attributes": { + "email": "barbara@example.com", + "country": "canada" + }, + "result": { + "value": false, + "variant": "off", + "flagMetadata": { + "allocationKey": "off-for-all", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "charlie", + "attributes": { + "age": 40 + }, + "result": { + "value": false, + "variant": "off", + "flagMetadata": { + "allocationKey": "off-for-all", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "debra", + "attributes": { + "email": "test@test.com", + "country": "Mexico", + "age": 25 + }, + "result": { + "value": true, + "variant": "on", + "flagMetadata": { + "allocationKey": "on-for-NA", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "1", + "attributes": {}, + "result": { + "value": false, + "variant": "off", + "flagMetadata": { + "allocationKey": "off-for-all", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "2", + "attributes": { + "country": "Mexico" + }, + "result": { + "value": true, + "variant": "on", + "flagMetadata": { + "allocationKey": "on-for-NA", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "3", + "attributes": { + "country": "UK", + "age": 50 + }, + "result": { + "value": true, + "variant": "on", + "flagMetadata": { + "allocationKey": "on-for-age-50+", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "4", + "attributes": { + "country": "Germany" + }, + "result": { + "value": false, + "variant": "off", + "flagMetadata": { + "allocationKey": "off-for-all", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "5", + "attributes": { + "country": "Germany" + }, + "result": { + "value": false, + "variant": "off", + "flagMetadata": { + "allocationKey": "off-for-all", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "6", + "attributes": { + "country": "Germany" + }, + "result": { + "value": false, + "variant": "off", + "flagMetadata": { + "allocationKey": "off-for-all", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "7", + "attributes": { + "country": "US", + "age": 12 + }, + "result": { + "value": true, + "variant": "on", + "flagMetadata": { + "allocationKey": "on-for-NA", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "8", + "attributes": { + "country": "Italy", + "age": 60 + }, + "result": { + "value": true, + "variant": "on", + "flagMetadata": { + "allocationKey": "on-for-age-50+", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "9", + "attributes": { + "email": "email@email.com" + }, + "result": { + "value": false, + "variant": "off", + "flagMetadata": { + "allocationKey": "off-for-all", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "10", + "attributes": {}, + "result": { + "value": false, + "variant": "off", + "flagMetadata": { + "allocationKey": "off-for-all", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "11", + "attributes": {}, + "result": { + "value": false, + "variant": "off", + "flagMetadata": { + "allocationKey": "off-for-all", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "12", + "attributes": { + "country": "US" + }, + "result": { + "value": true, + "variant": "on", + "flagMetadata": { + "allocationKey": "on-for-NA", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "13", + "attributes": { + "country": "Canada" + }, + "result": { + "value": true, + "variant": "on", + "flagMetadata": { + "allocationKey": "on-for-NA", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "14", + "attributes": {}, + "result": { + "value": false, + "variant": "off", + "flagMetadata": { + "allocationKey": "off-for-all", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "15", + "attributes": { + "country": "Denmark" + }, + "result": { + "value": false, + "variant": "off", + "flagMetadata": { + "allocationKey": "off-for-all", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "16", + "attributes": { + "country": "Norway" + }, + "result": { + "value": false, + "variant": "off", + "flagMetadata": { + "allocationKey": "off-for-all", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "17", + "attributes": { + "country": "UK" + }, + "result": { + "value": false, + "variant": "off", + "flagMetadata": { + "allocationKey": "off-for-all", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "18", + "attributes": { + "country": "UK" + }, + "result": { + "value": false, + "variant": "off", + "flagMetadata": { + "allocationKey": "off-for-all", + "variationType": "boolean", + "doLog": true + } + } + }, + { + "flag": "kill-switch", + "variationType": "BOOLEAN", + "defaultValue": false, + "targetingKey": "19", + "attributes": { + "country": "UK" + }, + "result": { + "value": false, + "variant": "off", + "flagMetadata": { + "allocationKey": "off-for-all", + "variationType": "boolean", + "doLog": true + } + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-new-user-onboarding-flag.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-new-user-onboarding-flag.json new file mode 100644 index 000000000000..3845597270eb --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-new-user-onboarding-flag.json @@ -0,0 +1,420 @@ +[ + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "alice", + "attributes": { + "email": "alice@mycompany.com", + "country": "US" + }, + "result": { + "value": "green", + "variant": "green", + "flagMetadata": { + "allocationKey": "internal users", + "variationType": "string", + "doLog": false + } + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "bob", + "attributes": { + "email": "bob@example.com", + "country": "Canada" + }, + "result": { + "value": "default" + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "charlie", + "attributes": { + "age": 50 + }, + "result": { + "value": "default" + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "debra", + "attributes": { + "email": "test@test.com", + "country": "Mexico", + "age": 25 + }, + "result": { + "value": "blue", + "variant": "blue", + "flagMetadata": { + "allocationKey": "rollout", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "zach", + "attributes": { + "email": "test@test.com", + "country": "Mexico", + "age": 25 + }, + "result": { + "value": "purple", + "variant": "purple", + "flagMetadata": { + "allocationKey": "id rule", + "variationType": "string", + "doLog": false + } + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "zach", + "attributes": { + "id": "override-id", + "email": "test@test.com", + "country": "Mexico", + "age": 25 + }, + "result": { + "value": "blue", + "variant": "blue", + "flagMetadata": { + "allocationKey": "rollout", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "Zach", + "attributes": { + "email": "test@test.com", + "country": "Mexico", + "age": 25 + }, + "result": { + "value": "default" + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "1", + "attributes": {}, + "result": { + "value": "default" + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "2", + "attributes": { + "country": "Mexico" + }, + "result": { + "value": "blue", + "variant": "blue", + "flagMetadata": { + "allocationKey": "rollout", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "3", + "attributes": { + "country": "UK", + "age": 33 + }, + "result": { + "value": "control", + "variant": "control", + "flagMetadata": { + "allocationKey": "experiment", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "4", + "attributes": { + "country": "Germany" + }, + "result": { + "value": "red", + "variant": "red", + "flagMetadata": { + "allocationKey": "experiment", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "5", + "attributes": { + "country": "Germany" + }, + "result": { + "value": "yellow", + "variant": "yellow", + "flagMetadata": { + "allocationKey": "experiment", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "6", + "attributes": { + "country": "Germany" + }, + "result": { + "value": "yellow", + "variant": "yellow", + "flagMetadata": { + "allocationKey": "experiment", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "7", + "attributes": { + "country": "US" + }, + "result": { + "value": "blue", + "variant": "blue", + "flagMetadata": { + "allocationKey": "rollout", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "8", + "attributes": { + "country": "Italy" + }, + "result": { + "value": "red", + "variant": "red", + "flagMetadata": { + "allocationKey": "experiment", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "9", + "attributes": { + "email": "email@email.com" + }, + "result": { + "value": "default" + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "10", + "attributes": {}, + "result": { + "value": "default" + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "11", + "attributes": {}, + "result": { + "value": "default" + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "12", + "attributes": { + "country": "US" + }, + "result": { + "value": "blue", + "variant": "blue", + "flagMetadata": { + "allocationKey": "rollout", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "13", + "attributes": { + "country": "Canada" + }, + "result": { + "value": "blue", + "variant": "blue", + "flagMetadata": { + "allocationKey": "rollout", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "14", + "attributes": {}, + "result": { + "value": "default" + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "15", + "attributes": { + "country": "Denmark" + }, + "result": { + "value": "yellow", + "variant": "yellow", + "flagMetadata": { + "allocationKey": "experiment", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "16", + "attributes": { + "country": "Norway" + }, + "result": { + "value": "control", + "variant": "control", + "flagMetadata": { + "allocationKey": "experiment", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "17", + "attributes": { + "country": "UK" + }, + "result": { + "value": "control", + "variant": "control", + "flagMetadata": { + "allocationKey": "experiment", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "18", + "attributes": { + "country": "UK" + }, + "result": { + "value": "default" + } + }, + { + "flag": "new-user-onboarding", + "variationType": "STRING", + "defaultValue": "default", + "targetingKey": "19", + "attributes": { + "country": "UK" + }, + "result": { + "value": "red", + "variant": "red", + "flagMetadata": { + "allocationKey": "experiment", + "variationType": "string", + "doLog": true + } + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-no-allocations-flag.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-no-allocations-flag.json new file mode 100644 index 000000000000..132c39db32af --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-no-allocations-flag.json @@ -0,0 +1,52 @@ +[ + { + "flag": "no_allocations_flag", + "variationType": "JSON", + "defaultValue": { + "hello": "world" + }, + "targetingKey": "alice", + "attributes": { + "email": "alice@mycompany.com", + "country": "US" + }, + "result": { + "value": { + "hello": "world" + } + } + }, + { + "flag": "no_allocations_flag", + "variationType": "JSON", + "defaultValue": { + "hello": "world" + }, + "targetingKey": "bob", + "attributes": { + "email": "bob@example.com", + "country": "Canada" + }, + "result": { + "value": { + "hello": "world" + } + } + }, + { + "flag": "no_allocations_flag", + "variationType": "JSON", + "defaultValue": { + "hello": "world" + }, + "targetingKey": "charlie", + "attributes": { + "age": 50 + }, + "result": { + "value": { + "hello": "world" + } + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-null-operator-flag.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-null-operator-flag.json new file mode 100644 index 000000000000..dd5c687b893c --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-null-operator-flag.json @@ -0,0 +1,94 @@ +[ + { + "flag": "null-operator-test", + "variationType": "STRING", + "defaultValue": "default-null", + "targetingKey": "alice", + "attributes": { + "size": 5, + "country": "US" + }, + "result": { + "value": "old", + "variant": "old", + "flagMetadata": { + "allocationKey": "null-operator", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "null-operator-test", + "variationType": "STRING", + "defaultValue": "default-null", + "targetingKey": "bob", + "attributes": { + "size": 10, + "country": "Canada" + }, + "result": { + "value": "new", + "variant": "new", + "flagMetadata": { + "allocationKey": "not-null-operator", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "null-operator-test", + "variationType": "STRING", + "defaultValue": "default-null", + "targetingKey": "charlie", + "attributes": { + "size": null + }, + "result": { + "value": "old", + "variant": "old", + "flagMetadata": { + "allocationKey": "null-operator", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "null-operator-test", + "variationType": "STRING", + "defaultValue": "default-null", + "targetingKey": "david", + "attributes": { + "size": 26 + }, + "result": { + "value": "new", + "variant": "new", + "flagMetadata": { + "allocationKey": "not-null-operator", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "null-operator-test", + "variationType": "STRING", + "defaultValue": "default-null", + "targetingKey": "elize", + "attributes": { + "country": "UK" + }, + "result": { + "value": "old", + "variant": "old", + "flagMetadata": { + "allocationKey": "null-operator", + "variationType": "string", + "doLog": true + } + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-numeric-flag.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-numeric-flag.json new file mode 100644 index 000000000000..0e6ed8b1b3a3 --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-numeric-flag.json @@ -0,0 +1,58 @@ +[ + { + "flag": "numeric_flag", + "variationType": "NUMERIC", + "defaultValue": 0.0, + "targetingKey": "alice", + "attributes": { + "email": "alice@mycompany.com", + "country": "US" + }, + "result": { + "value": 3.1415926, + "variant": "pi", + "flagMetadata": { + "allocationKey": "rollout", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "numeric_flag", + "variationType": "NUMERIC", + "defaultValue": 0.0, + "targetingKey": "bob", + "attributes": { + "email": "bob@example.com", + "country": "Canada" + }, + "result": { + "value": 3.1415926, + "variant": "pi", + "flagMetadata": { + "allocationKey": "rollout", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "numeric_flag", + "variationType": "NUMERIC", + "defaultValue": 0.0, + "targetingKey": "charlie", + "attributes": { + "age": 50 + }, + "result": { + "value": 3.1415926, + "variant": "pi", + "flagMetadata": { + "allocationKey": "rollout", + "variationType": "number", + "doLog": true + } + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-numeric-one-of.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-numeric-one-of.json new file mode 100644 index 000000000000..5ab68af5196e --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-numeric-one-of.json @@ -0,0 +1,122 @@ +[ + { + "flag": "numeric-one-of", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "alice", + "attributes": { + "number": 1 + }, + "result": { + "value": 1, + "variant": "1", + "flagMetadata": { + "allocationKey": "1-for-1", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "numeric-one-of", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "bob", + "attributes": { + "number": 2 + }, + "result": { + "value": 0 + } + }, + { + "flag": "numeric-one-of", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "charlie", + "attributes": { + "number": 3 + }, + "result": { + "value": 3, + "variant": "3", + "flagMetadata": { + "allocationKey": "3-for-not-2", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "numeric-one-of", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "derek", + "attributes": { + "number": 4 + }, + "result": { + "value": 3, + "variant": "3", + "flagMetadata": { + "allocationKey": "3-for-not-2", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "numeric-one-of", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "erica", + "attributes": { + "number": "1" + }, + "result": { + "value": 1, + "variant": "1", + "flagMetadata": { + "allocationKey": "1-for-1", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "numeric-one-of", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "frank", + "attributes": { + "number": 1 + }, + "result": { + "value": 1, + "variant": "1", + "flagMetadata": { + "allocationKey": "1-for-1", + "variationType": "number", + "doLog": true + } + } + }, + { + "flag": "numeric-one-of", + "variationType": "INTEGER", + "defaultValue": 0, + "targetingKey": "george", + "attributes": { + "number": 123456789 + }, + "result": { + "value": 2, + "variant": "2", + "flagMetadata": { + "allocationKey": "2-for-123456789", + "variationType": "number", + "doLog": true + } + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-race-conditions.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-race-conditions.json new file mode 100644 index 000000000000..fa940c843b42 --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-race-conditions.json @@ -0,0 +1,10 @@ +[ + { + "flag": "numeric-one-of", + "variationType": "INTEGER", + "defaultValue": 0, + "result": { + "value": 0 + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-regex-flag.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-regex-flag.json new file mode 100644 index 000000000000..952a37aabcfa --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-regex-flag.json @@ -0,0 +1,65 @@ +[ + { + "flag": "regex-flag", + "variationType": "STRING", + "defaultValue": "none", + "targetingKey": "alice", + "attributes": { + "version": "1.15.0", + "email": "alice@example.com" + }, + "result": { + "value": "partial-example", + "variant": "partial-example", + "flagMetadata": { + "allocationKey": "partial-example", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "regex-flag", + "variationType": "STRING", + "defaultValue": "none", + "targetingKey": "bob", + "attributes": { + "version": "0.20.1", + "email": "bob@test.com" + }, + "result": { + "value": "test", + "variant": "test", + "flagMetadata": { + "allocationKey": "test", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "regex-flag", + "variationType": "STRING", + "defaultValue": "none", + "targetingKey": "charlie", + "attributes": { + "version": "2.1.13" + }, + "result": { + "value": "none" + } + }, + { + "flag": "regex-flag", + "variationType": "STRING", + "defaultValue": "none", + "targetingKey": "derek", + "attributes": { + "version": "2.1.13", + "email": "derek@gmail.com" + }, + "result": { + "value": "none" + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-start-and-end-date-flag.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-start-and-end-date-flag.json new file mode 100644 index 000000000000..caf805d14325 --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-case-start-and-end-date-flag.json @@ -0,0 +1,58 @@ +[ + { + "flag": "start-and-end-date-test", + "variationType": "STRING", + "defaultValue": "unknown", + "targetingKey": "alice", + "attributes": { + "version": "1.15.0", + "country": "US" + }, + "result": { + "value": "current", + "variant": "current", + "flagMetadata": { + "allocationKey": "current-versions", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "start-and-end-date-test", + "variationType": "STRING", + "defaultValue": "unknown", + "targetingKey": "bob", + "attributes": { + "version": "0.20.1", + "country": "Canada" + }, + "result": { + "value": "current", + "variant": "current", + "flagMetadata": { + "allocationKey": "current-versions", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "start-and-end-date-test", + "variationType": "STRING", + "defaultValue": "unknown", + "targetingKey": "charlie", + "attributes": { + "version": "2.1.13" + }, + "result": { + "value": "current", + "variant": "current", + "flagMetadata": { + "allocationKey": "current-versions", + "variationType": "string", + "doLog": true + } + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-flag-that-does-not-exist.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-flag-that-does-not-exist.json new file mode 100644 index 000000000000..7499bba1c506 --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-flag-that-does-not-exist.json @@ -0,0 +1,40 @@ +[ + { + "flag": "flag-that-does-not-exist", + "variationType": "NUMERIC", + "defaultValue": 0.0, + "targetingKey": "alice", + "attributes": { + "email": "alice@mycompany.com", + "country": "US" + }, + "result": { + "value": 0.0 + } + }, + { + "flag": "flag-that-does-not-exist", + "variationType": "NUMERIC", + "defaultValue": 0.0, + "targetingKey": "bob", + "attributes": { + "email": "bob@example.com", + "country": "Canada" + }, + "result": { + "value": 0.0 + } + }, + { + "flag": "flag-that-does-not-exist", + "variationType": "NUMERIC", + "defaultValue": 0.0, + "targetingKey": "charlie", + "attributes": { + "age": 50 + }, + "result": { + "value": 0.0 + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-json-config-flag.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-json-config-flag.json new file mode 100644 index 000000000000..3d4478ff7118 --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-json-config-flag.json @@ -0,0 +1,96 @@ +[ + { + "flag": "json-config-flag", + "variationType": "JSON", + "defaultValue": { + "foo": "bar" + }, + "targetingKey": "alice", + "attributes": { + "email": "alice@mycompany.com", + "country": "US" + }, + "result": { + "value": { + "integer": 1, + "string": "one", + "float": 1.0 + }, + "variant": "one", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "object", + "doLog": true + } + } + }, + { + "flag": "json-config-flag", + "variationType": "JSON", + "defaultValue": { + "foo": "bar" + }, + "targetingKey": "bob", + "attributes": { + "email": "bob@example.com", + "country": "Canada" + }, + "result": { + "value": { + "integer": 2, + "string": "two", + "float": 2.0 + }, + "variant": "two", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "object", + "doLog": true + } + } + }, + { + "flag": "json-config-flag", + "variationType": "JSON", + "defaultValue": { + "foo": "bar" + }, + "targetingKey": "charlie", + "attributes": { + "age": 50 + }, + "result": { + "value": { + "integer": 2, + "string": "two", + "float": 2.0 + }, + "variant": "two", + "flagMetadata": { + "allocationKey": "50/50 split", + "variationType": "object", + "doLog": true + } + } + }, + { + "flag": "json-config-flag", + "variationType": "JSON", + "defaultValue": { + "foo": "bar" + }, + "targetingKey": "diana", + "attributes": { + "Force Empty": true + }, + "result": { + "value": {}, + "variant": "empty", + "flagMetadata": { + "allocationKey": "Optionally Force Empty", + "variationType": "object", + "doLog": true + } + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-no-allocations-flag.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-no-allocations-flag.json new file mode 100644 index 000000000000..45867e5897cf --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-no-allocations-flag.json @@ -0,0 +1,52 @@ +[ + { + "flag": "no_allocations_flag", + "variationType": "JSON", + "defaultValue": { + "message": "Hello, world!" + }, + "targetingKey": "alice", + "attributes": { + "email": "alice@mycompany.com", + "country": "US" + }, + "result": { + "value": { + "message": "Hello, world!" + } + } + }, + { + "flag": "no_allocations_flag", + "variationType": "JSON", + "defaultValue": { + "message": "Hello, world!" + }, + "targetingKey": "bob", + "attributes": { + "email": "bob@example.com", + "country": "Canada" + }, + "result": { + "value": { + "message": "Hello, world!" + } + } + }, + { + "flag": "no_allocations_flag", + "variationType": "JSON", + "defaultValue": { + "message": "Hello, world!" + }, + "targetingKey": "charlie", + "attributes": { + "age": 50 + }, + "result": { + "value": { + "message": "Hello, world!" + } + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-special-characters.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-special-characters.json new file mode 100644 index 000000000000..59ef5cbe87d7 --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-special-characters.json @@ -0,0 +1,78 @@ +[ + { + "flag": "special-characters", + "variationType": "JSON", + "defaultValue": {}, + "targetingKey": "ash", + "attributes": {}, + "result": { + "value": { + "a": "kümmert", + "b": "schön" + }, + "variant": "de", + "flagMetadata": { + "allocationKey": "allocation-test", + "variationType": "object", + "doLog": true + } + } + }, + { + "flag": "special-characters", + "variationType": "JSON", + "defaultValue": {}, + "targetingKey": "ben", + "attributes": {}, + "result": { + "value": { + "a": "піклуватися", + "b": "любов" + }, + "variant": "ua", + "flagMetadata": { + "allocationKey": "allocation-test", + "variationType": "object", + "doLog": true + } + } + }, + { + "flag": "special-characters", + "variationType": "JSON", + "defaultValue": {}, + "targetingKey": "cameron", + "attributes": {}, + "result": { + "value": { + "a": "照顾", + "b": "漂亮" + }, + "variant": "zh", + "flagMetadata": { + "allocationKey": "allocation-test", + "variationType": "object", + "doLog": true + } + } + }, + { + "flag": "special-characters", + "variationType": "JSON", + "defaultValue": {}, + "targetingKey": "darryl", + "attributes": {}, + "result": { + "value": { + "a": "🤗", + "b": "🌸" + }, + "variant": "emoji", + "flagMetadata": { + "allocationKey": "allocation-test", + "variationType": "object", + "doLog": true + } + } + } +] diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-string-with-special-characters.json b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-string-with-special-characters.json new file mode 100644 index 000000000000..27d063122c00 --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/resources/data/test-string-with-special-characters.json @@ -0,0 +1,1190 @@ +[ + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_spaces", + "attributes": { + "string_with_spaces": true + }, + "result": { + "value": " a b c d e f ", + "variant": "string_with_spaces", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_spaces", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_space", + "attributes": { + "string_with_only_one_space": true + }, + "result": { + "value": " ", + "variant": "string_with_only_one_space", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_space", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_spaces", + "attributes": { + "string_with_only_multiple_spaces": true + }, + "result": { + "value": " ", + "variant": "string_with_only_multiple_spaces", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_spaces", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_dots", + "attributes": { + "string_with_dots": true + }, + "result": { + "value": ".a.b.c.d.e.f.", + "variant": "string_with_dots", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_dots", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_dot", + "attributes": { + "string_with_only_one_dot": true + }, + "result": { + "value": ".", + "variant": "string_with_only_one_dot", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_dot", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_dots", + "attributes": { + "string_with_only_multiple_dots": true + }, + "result": { + "value": ".......", + "variant": "string_with_only_multiple_dots", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_dots", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_comas", + "attributes": { + "string_with_comas": true + }, + "result": { + "value": ",a,b,c,d,e,f,", + "variant": "string_with_comas", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_comas", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_coma", + "attributes": { + "string_with_only_one_coma": true + }, + "result": { + "value": ",", + "variant": "string_with_only_one_coma", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_coma", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_comas", + "attributes": { + "string_with_only_multiple_comas": true + }, + "result": { + "value": ",,,,,,,", + "variant": "string_with_only_multiple_comas", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_comas", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_colons", + "attributes": { + "string_with_colons": true + }, + "result": { + "value": ":a:b:c:d:e:f:", + "variant": "string_with_colons", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_colons", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_colon", + "attributes": { + "string_with_only_one_colon": true + }, + "result": { + "value": ":", + "variant": "string_with_only_one_colon", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_colon", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_colons", + "attributes": { + "string_with_only_multiple_colons": true + }, + "result": { + "value": ":::::::", + "variant": "string_with_only_multiple_colons", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_colons", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_semicolons", + "attributes": { + "string_with_semicolons": true + }, + "result": { + "value": ";a;b;c;d;e;f;", + "variant": "string_with_semicolons", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_semicolons", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_semicolon", + "attributes": { + "string_with_only_one_semicolon": true + }, + "result": { + "value": ";", + "variant": "string_with_only_one_semicolon", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_semicolon", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_semicolons", + "attributes": { + "string_with_only_multiple_semicolons": true + }, + "result": { + "value": ";;;;;;;", + "variant": "string_with_only_multiple_semicolons", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_semicolons", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_slashes", + "attributes": { + "string_with_slashes": true + }, + "result": { + "value": "/a/b/c/d/e/f/", + "variant": "string_with_slashes", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_slashes", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_slash", + "attributes": { + "string_with_only_one_slash": true + }, + "result": { + "value": "/", + "variant": "string_with_only_one_slash", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_slash", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_slashes", + "attributes": { + "string_with_only_multiple_slashes": true + }, + "result": { + "value": "///////", + "variant": "string_with_only_multiple_slashes", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_slashes", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_dashes", + "attributes": { + "string_with_dashes": true + }, + "result": { + "value": "-a-b-c-d-e-f-", + "variant": "string_with_dashes", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_dashes", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_dash", + "attributes": { + "string_with_only_one_dash": true + }, + "result": { + "value": "-", + "variant": "string_with_only_one_dash", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_dash", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_dashes", + "attributes": { + "string_with_only_multiple_dashes": true + }, + "result": { + "value": "-------", + "variant": "string_with_only_multiple_dashes", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_dashes", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_underscores", + "attributes": { + "string_with_underscores": true + }, + "result": { + "value": "_a_b_c_d_e_f_", + "variant": "string_with_underscores", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_underscores", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_underscore", + "attributes": { + "string_with_only_one_underscore": true + }, + "result": { + "value": "_", + "variant": "string_with_only_one_underscore", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_underscore", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_underscores", + "attributes": { + "string_with_only_multiple_underscores": true + }, + "result": { + "value": "_______", + "variant": "string_with_only_multiple_underscores", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_underscores", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_plus_signs", + "attributes": { + "string_with_plus_signs": true + }, + "result": { + "value": "+a+b+c+d+e+f+", + "variant": "string_with_plus_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_plus_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_plus_sign", + "attributes": { + "string_with_only_one_plus_sign": true + }, + "result": { + "value": "+", + "variant": "string_with_only_one_plus_sign", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_plus_sign", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_plus_signs", + "attributes": { + "string_with_only_multiple_plus_signs": true + }, + "result": { + "value": "+++++++", + "variant": "string_with_only_multiple_plus_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_plus_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_equal_signs", + "attributes": { + "string_with_equal_signs": true + }, + "result": { + "value": "=a=b=c=d=e=f=", + "variant": "string_with_equal_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_equal_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_equal_sign", + "attributes": { + "string_with_only_one_equal_sign": true + }, + "result": { + "value": "=", + "variant": "string_with_only_one_equal_sign", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_equal_sign", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_equal_signs", + "attributes": { + "string_with_only_multiple_equal_signs": true + }, + "result": { + "value": "=======", + "variant": "string_with_only_multiple_equal_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_equal_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_dollar_signs", + "attributes": { + "string_with_dollar_signs": true + }, + "result": { + "value": "$a$b$c$d$e$f$", + "variant": "string_with_dollar_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_dollar_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_dollar_sign", + "attributes": { + "string_with_only_one_dollar_sign": true + }, + "result": { + "value": "$", + "variant": "string_with_only_one_dollar_sign", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_dollar_sign", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_dollar_signs", + "attributes": { + "string_with_only_multiple_dollar_signs": true + }, + "result": { + "value": "$$$$$$$", + "variant": "string_with_only_multiple_dollar_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_dollar_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_at_signs", + "attributes": { + "string_with_at_signs": true + }, + "result": { + "value": "@a@b@c@d@e@f@", + "variant": "string_with_at_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_at_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_at_sign", + "attributes": { + "string_with_only_one_at_sign": true + }, + "result": { + "value": "@", + "variant": "string_with_only_one_at_sign", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_at_sign", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_at_signs", + "attributes": { + "string_with_only_multiple_at_signs": true + }, + "result": { + "value": "@@@@@@@", + "variant": "string_with_only_multiple_at_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_at_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_amp_signs", + "attributes": { + "string_with_amp_signs": true + }, + "result": { + "value": "&a&b&c&d&e&f&", + "variant": "string_with_amp_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_amp_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_amp_sign", + "attributes": { + "string_with_only_one_amp_sign": true + }, + "result": { + "value": "&", + "variant": "string_with_only_one_amp_sign", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_amp_sign", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_amp_signs", + "attributes": { + "string_with_only_multiple_amp_signs": true + }, + "result": { + "value": "&&&&&&&", + "variant": "string_with_only_multiple_amp_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_amp_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_hash_signs", + "attributes": { + "string_with_hash_signs": true + }, + "result": { + "value": "#a#b#c#d#e#f#", + "variant": "string_with_hash_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_hash_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_hash_sign", + "attributes": { + "string_with_only_one_hash_sign": true + }, + "result": { + "value": "#", + "variant": "string_with_only_one_hash_sign", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_hash_sign", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_hash_signs", + "attributes": { + "string_with_only_multiple_hash_signs": true + }, + "result": { + "value": "#######", + "variant": "string_with_only_multiple_hash_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_hash_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_percentage_signs", + "attributes": { + "string_with_percentage_signs": true + }, + "result": { + "value": "%a%b%c%d%e%f%", + "variant": "string_with_percentage_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_percentage_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_percentage_sign", + "attributes": { + "string_with_only_one_percentage_sign": true + }, + "result": { + "value": "%", + "variant": "string_with_only_one_percentage_sign", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_percentage_sign", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_percentage_signs", + "attributes": { + "string_with_only_multiple_percentage_signs": true + }, + "result": { + "value": "%%%%%%%", + "variant": "string_with_only_multiple_percentage_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_percentage_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_tilde_signs", + "attributes": { + "string_with_tilde_signs": true + }, + "result": { + "value": "~a~b~c~d~e~f~", + "variant": "string_with_tilde_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_tilde_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_tilde_sign", + "attributes": { + "string_with_only_one_tilde_sign": true + }, + "result": { + "value": "~", + "variant": "string_with_only_one_tilde_sign", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_tilde_sign", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_tilde_signs", + "attributes": { + "string_with_only_multiple_tilde_signs": true + }, + "result": { + "value": "~~~~~~~", + "variant": "string_with_only_multiple_tilde_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_tilde_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_asterix_signs", + "attributes": { + "string_with_asterix_signs": true + }, + "result": { + "value": "*a*b*c*d*e*f*", + "variant": "string_with_asterix_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_asterix_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_asterix_sign", + "attributes": { + "string_with_only_one_asterix_sign": true + }, + "result": { + "value": "*", + "variant": "string_with_only_one_asterix_sign", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_asterix_sign", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_asterix_signs", + "attributes": { + "string_with_only_multiple_asterix_signs": true + }, + "result": { + "value": "*******", + "variant": "string_with_only_multiple_asterix_signs", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_asterix_signs", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_single_quotes", + "attributes": { + "string_with_single_quotes": true + }, + "result": { + "value": "'a'b'c'd'e'f'", + "variant": "string_with_single_quotes", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_single_quotes", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_single_quote", + "attributes": { + "string_with_only_one_single_quote": true + }, + "result": { + "value": "'", + "variant": "string_with_only_one_single_quote", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_single_quote", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_single_quotes", + "attributes": { + "string_with_only_multiple_single_quotes": true + }, + "result": { + "value": "'''''''", + "variant": "string_with_only_multiple_single_quotes", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_single_quotes", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_question_marks", + "attributes": { + "string_with_question_marks": true + }, + "result": { + "value": "?a?b?c?d?e?f?", + "variant": "string_with_question_marks", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_question_marks", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_question_mark", + "attributes": { + "string_with_only_one_question_mark": true + }, + "result": { + "value": "?", + "variant": "string_with_only_one_question_mark", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_question_mark", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_question_marks", + "attributes": { + "string_with_only_multiple_question_marks": true + }, + "result": { + "value": "???????", + "variant": "string_with_only_multiple_question_marks", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_question_marks", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_exclamation_marks", + "attributes": { + "string_with_exclamation_marks": true + }, + "result": { + "value": "!a!b!c!d!e!f!", + "variant": "string_with_exclamation_marks", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_exclamation_marks", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_exclamation_mark", + "attributes": { + "string_with_only_one_exclamation_mark": true + }, + "result": { + "value": "!", + "variant": "string_with_only_one_exclamation_mark", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_exclamation_mark", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_exclamation_marks", + "attributes": { + "string_with_only_multiple_exclamation_marks": true + }, + "result": { + "value": "!!!!!!!", + "variant": "string_with_only_multiple_exclamation_marks", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_exclamation_marks", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_opening_parentheses", + "attributes": { + "string_with_opening_parentheses": true + }, + "result": { + "value": "(a(b(c(d(e(f(", + "variant": "string_with_opening_parentheses", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_opening_parentheses", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_opening_parenthese", + "attributes": { + "string_with_only_one_opening_parenthese": true + }, + "result": { + "value": "(", + "variant": "string_with_only_one_opening_parenthese", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_opening_parenthese", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_opening_parentheses", + "attributes": { + "string_with_only_multiple_opening_parentheses": true + }, + "result": { + "value": "(((((((", + "variant": "string_with_only_multiple_opening_parentheses", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_opening_parentheses", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_closing_parentheses", + "attributes": { + "string_with_closing_parentheses": true + }, + "result": { + "value": ")a)b)c)d)e)f)", + "variant": "string_with_closing_parentheses", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_closing_parentheses", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_one_closing_parenthese", + "attributes": { + "string_with_only_one_closing_parenthese": true + }, + "result": { + "value": ")", + "variant": "string_with_only_one_closing_parenthese", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_one_closing_parenthese", + "variationType": "string", + "doLog": true + } + } + }, + { + "flag": "string_flag_with_special_characters", + "variationType": "STRING", + "defaultValue": "default_value", + "targetingKey": "string_with_only_multiple_closing_parentheses", + "attributes": { + "string_with_only_multiple_closing_parentheses": true + }, + "result": { + "value": ")))))))", + "variant": "string_with_only_multiple_closing_parentheses", + "flagMetadata": { + "allocationKey": "allocation-test-string_with_only_multiple_closing_parentheses", + "variationType": "string", + "doLog": true + } + } + } +] From 978be767a3ec14ab69c952549d4ed4915cb41fed Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Thu, 11 Dec 2025 23:44:57 +0100 Subject: [PATCH 12/54] Exposure reporting --- .../FeatureFlags/Exposure/ExposureApi.cs | 137 ++++++++++++++++++ .../Exposure/{ => Model}/Allocation.cs | 2 +- .../Exposure/{ => Model}/ExposureEvent.cs | 2 +- .../FeatureFlags/Exposure/{ => Model}/Flag.cs | 2 +- .../Exposure/{ => Model}/Subject.cs | 2 +- .../Exposure/{ => Model}/Variant.cs | 2 +- .../FeatureFlags/FeatureFlagsEvaluator.cs | 14 +- .../FeatureFlags/FeatureFlagsModule.cs | 7 +- .../FeatureFlagsEvaluatorTests.cs | 2 +- 9 files changed, 156 insertions(+), 14 deletions(-) create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs rename tracer/src/Datadog.Trace/FeatureFlags/Exposure/{ => Model}/Allocation.cs (94%) rename tracer/src/Datadog.Trace/FeatureFlags/Exposure/{ => Model}/ExposureEvent.cs (93%) rename tracer/src/Datadog.Trace/FeatureFlags/Exposure/{ => Model}/Flag.cs (90%) rename tracer/src/Datadog.Trace/FeatureFlags/Exposure/{ => Model}/Subject.cs (92%) rename tracer/src/Datadog.Trace/FeatureFlags/Exposure/{ => Model}/Variant.cs (90%) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs new file mode 100644 index 000000000000..e18475a2a13f --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs @@ -0,0 +1,137 @@ +// +// 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 System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading; +using System.Threading.Tasks; +using Datadog.Trace.Agent; +using Datadog.Trace.Agent.DiscoveryService; +using Datadog.Trace.Agent.Transports; +using Datadog.Trace.Configuration; +using Datadog.Trace.FeatureFlags.Exposure; +using Datadog.Trace.FeatureFlags.Exposure.Model; +using Datadog.Trace.HttpOverStreams; +using Datadog.Trace.Logging.TracerFlare; +using Datadog.Trace.VendoredMicrosoftCode.System.Reflection.Internal; +using Datadog.Trace.Vendors.Newtonsoft.Json; +using Datadog.Trace.Vendors.Serilog; +using static InlineIL.IL; + +namespace Datadog.Trace.Exposure +{ + internal class ExposureApi + { + public const string ExposurePath = "api/v2/exposure"; + private readonly TaskCompletionSource _processExit = new(); + private readonly IApiRequestFactory _apiRequestFactory; + private readonly Queue _exposures = new Queue(); + private readonly TimeSpan _sendInterval = TimeSpan.FromSeconds(15); + private readonly Dictionary _context = new Dictionary(); + private int _started = 0; + + private ExposureApi(IApiRequestFactory apiRequestFactory, TracerSettings tracerSettings) + { + _apiRequestFactory = apiRequestFactory; + _context["service"] = tracerSettings.ServiceName ?? "unknown"; + _context["env"] = tracerSettings.Environment ?? "unknown"; + _context["version"] = tracerSettings.ServiceVersion ?? "unknown"; + } + + public static ExposureApi Create(TracerSettings tracerSettings) + { + var apiRequestFactory = AgentTransportStrategy.Get( + tracerSettings.Exporter, + productName: "FeatureFlags exposure", + tcpTimeout: TimeSpan.FromSeconds(15), + AgentHttpHeaderNames.MinimalHeaders, + () => new MinimalAgentHeaderHelper(), + uri => uri); + + return new ExposureApi(apiRequestFactory, tracerSettings); + } + + public void Start() + { + _ = Task.Run(StartSendLoopAsync) + .ContinueWith(t => { Log.Error(t.Exception, "FeatureFlags Exposure send loop failed"); }, TaskContinuationOptions.OnlyOnFaulted); + } + + private async Task StartSendLoopAsync() + { + if (Interlocked.Exchange(ref _started, 1) != 0) + { + return; + } + + var uri = _apiRequestFactory.GetEndpoint($"evp_proxy/v2/{ExposurePath}"); + + while (!_processExit.Task.IsCompleted) + { + if (_exposures.Count > 0) + { + try + { + await SendBatchAsync(uri).ConfigureAwait(false); + } + catch (Exception ex) + { + Log.Error(ex, "Error while sending Feature Flags exposures to the agent"); + } + } + + try + { + await Task.WhenAny(_processExit.Task, Task.Delay(_sendInterval)).ConfigureAwait(false); + } + catch (OperationCanceledException) + { + // We are shutting down, so don't do anything about it + } + } + } + + private async Task SendBatchAsync(Uri uri) + { + var request = _apiRequestFactory.Create(uri); + var payload = GetPayload(); + using var response = await request.PostAsync(payload, MimeTypes.Json) + .ConfigureAwait(false); + } + + private ArraySegment GetPayload() + { + ExposuresRequest request; + lock (_exposures) + { + var exposures = _exposures.ToList(); + _exposures.Clear(); + request = new ExposuresRequest(_context, exposures); + } + + string json = JsonConvert.SerializeObject(request); + return new ArraySegment(Encoding.UTF8.GetBytes(json)); + } + + public void SendExposure(ExposureEvent exposure) + { + lock (_exposures) + { + _exposures.Enqueue(exposure); + Start(); + } + } + + private class ExposuresRequest(Dictionary context, List exposures) + { + public Dictionary Context { get; } = context; + + public List Exposures { get; } = exposures; + } + } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Allocation.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Allocation.cs similarity index 94% rename from tracer/src/Datadog.Trace/FeatureFlags/Exposure/Allocation.cs rename to tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Allocation.cs index bd1a60cbefa8..7a0152490a10 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Allocation.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Allocation.cs @@ -9,7 +9,7 @@ using System.Collections.Generic; using Datadog.Trace.ClrProfiler.AutoInstrumentation.Aerospike; -namespace Datadog.Trace.FeatureFlags.Exposure; +namespace Datadog.Trace.FeatureFlags.Exposure.Model; internal class Allocation(string key) { diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureEvent.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/ExposureEvent.cs similarity index 93% rename from tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureEvent.cs rename to tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/ExposureEvent.cs index b07f74bf174d..7bdf680cb21e 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureEvent.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/ExposureEvent.cs @@ -9,7 +9,7 @@ using System.Collections.Generic; using System.Security.Cryptography.X509Certificates; -namespace Datadog.Trace.FeatureFlags.Exposure; +namespace Datadog.Trace.FeatureFlags.Exposure.Model; internal class ExposureEvent(long timeStamp, Allocation allocation, Flag flag, Variant variant, Subject subject) { diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Flag.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Flag.cs similarity index 90% rename from tracer/src/Datadog.Trace/FeatureFlags/Exposure/Flag.cs rename to tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Flag.cs index 4778ba055f23..bd71969f4dc8 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Flag.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Flag.cs @@ -9,7 +9,7 @@ using System.Collections.Generic; using Datadog.Trace.ClrProfiler.AutoInstrumentation.Aerospike; -namespace Datadog.Trace.FeatureFlags.Exposure; +namespace Datadog.Trace.FeatureFlags.Exposure.Model; internal class Flag(string key) { diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Subject.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Subject.cs similarity index 92% rename from tracer/src/Datadog.Trace/FeatureFlags/Exposure/Subject.cs rename to tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Subject.cs index a234d5543d06..b92735a7d3b2 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Subject.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Subject.cs @@ -9,7 +9,7 @@ using System.Collections.Generic; using Datadog.Trace.ClrProfiler.AutoInstrumentation.Aerospike; -namespace Datadog.Trace.FeatureFlags.Exposure; +namespace Datadog.Trace.FeatureFlags.Exposure.Model; internal class Subject(string id, IDictionary attributes) { diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Variant.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Variant.cs similarity index 90% rename from tracer/src/Datadog.Trace/FeatureFlags/Exposure/Variant.cs rename to tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Variant.cs index 1c3e3b4621fe..b40a60aa38d8 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Variant.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Variant.cs @@ -9,7 +9,7 @@ using System.Collections.Generic; using Datadog.Trace.ClrProfiler.AutoInstrumentation.Aerospike; -namespace Datadog.Trace.FeatureFlags.Exposure; +namespace Datadog.Trace.FeatureFlags.Exposure.Model; internal class Variant(string key) { diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index d31c5ed1a987..37f27c4ba105 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -45,11 +45,11 @@ internal class FeatureFlagsEvaluator typeof(double), }; - private readonly Action? _onExposureEvent; + private readonly Action? _onExposureEvent; private readonly ServerConfiguration? _config; private readonly long _timeoutMs; - public FeatureFlagsEvaluator(Action? onExposureEvent, ServerConfiguration? config, long timeoutMs = 1000) + public FeatureFlagsEvaluator(Action? onExposureEvent, ServerConfiguration? config, long timeoutMs = 1000) { _onExposureEvent = onExposureEvent; _config = config; @@ -673,12 +673,12 @@ private void DispatchExposure( return; } - var evt = new Exposure.ExposureEvent( + var evt = new Exposure.Model.ExposureEvent( DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(), - new Exposure.Allocation(allocationKey), - new Exposure.Flag(flag), - new Exposure.Variant(variantKey), - new Exposure.Subject(context.TargetingKey, FlattenContext(context))); + new Exposure.Model.Allocation(allocationKey), + new Exposure.Model.Flag(flag), + new Exposure.Model.Variant(variantKey), + new Exposure.Model.Subject(context.TargetingKey, FlattenContext(context))); _onExposureEvent?.Invoke(evt); } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index 62f8795acd51..6dfad55d323b 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -15,7 +15,8 @@ using Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcAspNetCoreServer; using Datadog.Trace.Configuration; using Datadog.Trace.Debugger.Configurations; -using Datadog.Trace.FeatureFlags.Exposure; +using Datadog.Trace.Exposure; +using Datadog.Trace.FeatureFlags.Exposure.Model; using Datadog.Trace.FeatureFlags.Rcm; using Datadog.Trace.FeatureFlags.Rcm.Model; using Datadog.Trace.Logging; @@ -39,6 +40,7 @@ internal class FeatureFlagsModule private ISubscription? _rcmSubscription = null; private FfeProduct? _ffeProduct = null; private Action? _onNewConfigEventHander = null; + private ExposureApi? _exposureApi = null; private FeatureFlagsEvaluator? _evaluator = null; @@ -68,6 +70,8 @@ internal FeatureFlagsModule(TracerSettings settings, IRcmSubscriptionManager? rc _rcmSubscriptionManager.SubscribeToChanges(_rcmSubscription!); _rcmSubscriptionManager.SetCapability(RcmCapabilitiesIndices.FfeFlagConfigurationRules, true); } + + _exposureApi = ExposureApi.Create(settings); } } @@ -133,6 +137,7 @@ private void UpdateConfig(List> list) private void ReportExposure(ExposureEvent exposure) { + _exposureApi?.SendExposure(exposure); } } } diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs index dd7c9b6a6cb2..36adeb24a47d 100644 --- a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs @@ -319,7 +319,7 @@ public void EvaluateExposureFlagLogsExposureEvent() ["exposure-flag"] = FeatureFlagsHelpers.CreateExposureFlag() }; - List events = new List(); + List events = new List(); var evaluator = new FeatureFlagsEvaluator((e) => events.Add(e), new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user-123"); From 00896fccddb6560c3d7df2ee8c849a0c894b740e Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Fri, 12 Dec 2025 09:46:40 +0100 Subject: [PATCH 13/54] Exposure telemetry --- .../FeatureFlags/Exposure/ExposureApi.cs | 4 +- .../FeatureFlags/FeatureFlagsTests.cs | 46 ++++++++++-- .../Samples.FeatureFlags/Program.cs | 2 +- .../DataDogProvider.cs | 42 +++++++++++ .../Samples.OpenFeature-2.9/Program.cs | 75 ++++++++++++++++++- 5 files changed, 159 insertions(+), 10 deletions(-) create mode 100644 tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs index e18475a2a13f..96e5e09d827d 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs @@ -31,7 +31,7 @@ internal class ExposureApi private readonly TaskCompletionSource _processExit = new(); private readonly IApiRequestFactory _apiRequestFactory; private readonly Queue _exposures = new Queue(); - private readonly TimeSpan _sendInterval = TimeSpan.FromSeconds(15); + private readonly TimeSpan _sendInterval = TimeSpan.FromSeconds(10); private readonly Dictionary _context = new Dictionary(); private int _started = 0; @@ -48,7 +48,7 @@ public static ExposureApi Create(TracerSettings tracerSettings) var apiRequestFactory = AgentTransportStrategy.Get( tracerSettings.Exporter, productName: "FeatureFlags exposure", - tcpTimeout: TimeSpan.FromSeconds(15), + tcpTimeout: TimeSpan.FromSeconds(5), AgentHttpHeaderNames.MinimalHeaders, () => new MinimalAgentHeaderHelper(), uri => uri); diff --git a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs index 1a77bbab2f02..579c4362eca8 100644 --- a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs +++ b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs @@ -9,17 +9,23 @@ using System.Runtime.InteropServices; using System.Threading; using System.Threading.Tasks; +using Datadog.Trace.Agent.Transports; using Datadog.Trace.AppSec.Rcm.Models.AsmFeatures; +using Datadog.Trace.Ci; using Datadog.Trace.Configuration; using Datadog.Trace.FeatureFlags.Rcm.Model; using Datadog.Trace.RemoteConfigurationManagement; using Datadog.Trace.TestHelpers; +using Datadog.Trace.TestHelpers.Ci; +using Datadog.Trace.Vendors.Newtonsoft.Json; using FluentAssertions; using FluentAssertions.Execution; using VerifyXunit; using Xunit; using Xunit.Abstractions; +#pragma warning disable SA1402 // File may only contain a single type + namespace Datadog.Trace.ClrProfiler.IntegrationTests; #if NETFRAMEWORK @@ -27,21 +33,37 @@ namespace Datadog.Trace.ClrProfiler.IntegrationTests; // Include these tests in the ManualInstrumentation batch [Collection(nameof(ManualInstrumentationTests))] #endif -[UsesVerify] -public class FeatureFlagsTests : TestHelper +public class FeatureFlagsTests : FeatureFlagsTestsBase { public FeatureFlagsTests(ITestOutputHelper output) : base("FeatureFlags", output) { -#pragma warning disable CS0618 // Type or member is obsolete - EnableDebugMode(); -#pragma warning restore CS0618 // Type or member is obsolete + } +} + +#if NETFRAMEWORK +[Collection(nameof(ManualInstrumentationTests))] +#endif +public class OpenFeature_2_9_FeatureFlagsTests : FeatureFlagsTestsBase +{ + public OpenFeature_2_9_FeatureFlagsTests(ITestOutputHelper output) + : base("OpenFeature-2.9", output) + { + } +} + +public abstract class FeatureFlagsTestsBase : TestHelper +{ + public FeatureFlagsTestsBase(string sampleName, ITestOutputHelper output) + : base(sampleName, output) + { } [SkippableFact] [Trait("RunOnWindows", "True")] public async Task FfeEnabled() { + int eventsReceived = 0; using var agent = EnvironmentHelper.GetMockAgent(); var request1 = agent.SetupRcm( Output, @@ -54,6 +76,17 @@ public async Task FfeEnabled() nameof(FeatureFlagsTests)) ]); + agent.EventPlatformProxyPayloadReceived += (sender, e) => + { + if (e.Value.PathAndQuery.EndsWith("api/v2/exposure")) + { + eventsReceived++; + e.Value.Headers["Content-Encoding"].Should().Be(MimeTypes.Json); + var payload = JsonConvert.DeserializeObject(e.Value.BodyInJson); + return; + } + }; + var output = await RunTest(agent, enabled: true); Assert.NotNull(output); @@ -64,6 +97,7 @@ public async Task FfeEnabled() Assert.Contains("Eval (numeric-rule-flag) : 0); } [SkippableFact] @@ -88,3 +122,5 @@ private async Task RunTest(MockTracerAgent agent, bool enabled = true, b return process.StandardOutput.ToString(); } } + +#pragma warning restore SA1402 // File may only contain a single type diff --git a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs index 91b9b043a4f6..9933a7635bdd 100644 --- a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs +++ b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs @@ -41,11 +41,11 @@ private static void Main(string[] args) Thread.Sleep(1000); } + Evaluate("exposure-flag"); Evaluate("simple-string"); Evaluate("rule-based-flag"); Evaluate("numeric-rule-flag"); Evaluate("time-based-flag"); - Evaluate("exposure-flag"); IEvaluation? Evaluate(string key) { diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs new file mode 100644 index 000000000000..61c8b3904d59 --- /dev/null +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs @@ -0,0 +1,42 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using OpenFeature.Model; + +namespace Samples.OpenFeature_2._9 +{ + internal class DataDogProvider : OpenFeature.FeatureProvider + { + public override Metadata? GetMetadata() + { + throw new NotImplementedException(); + } + + public override Task> ResolveBooleanValueAsync(string flagKey, bool defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) + { + throw new NotImplementedException(); + } + + public override Task> ResolveDoubleValueAsync(string flagKey, double defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) + { + throw new NotImplementedException(); + } + + public override Task> ResolveIntegerValueAsync(string flagKey, int defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) + { + throw new NotImplementedException(); + } + + public override Task> ResolveStringValueAsync(string flagKey, string defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) + { + throw new NotImplementedException(); + } + + public override Task> ResolveStructureValueAsync(string flagKey, Value defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) + { + throw new NotImplementedException(); + } + } +} diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs index 3751555cbd32..4f0a100560f4 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs @@ -1,2 +1,73 @@ -// See https://aka.ms/new-console-template for more information -Console.WriteLine("Hello, World!"); +using System; +using System.Diagnostics; +using Datadog.Trace.FeatureFlags; + +namespace Samples.OpenFeature_2_9; + +class Program +{ + + private static void Main(string[] args) + { + // See https://aka.ms/new-console-template for more information + Console.WriteLine("OpenFeature 2.9 FeatureFlags SDK Sample"); + + if (!Datadog.Trace.FeatureFlags.FeatureFlagsSdk.IsAvailable()) + { + Console.WriteLine($""); + return; + } + + Console.WriteLine($""); + + var ev = Evaluate("nonexistent"); + if (ev != null && ev.Error is "FeatureFlagsSdk is disabled") + { + return; + } + + + int configUpdates = 0; + Datadog.Trace.FeatureFlags.FeatureFlagsSdk.RegisterOnNewConfigEventHandler(() => configUpdates++); + + int attempts = 5; + while (configUpdates == 0) + { + if (attempts-- == 0) + { + Console.WriteLine($"No RC received"); + return; + } + Console.WriteLine($"Waiting for RC..."); + Thread.Sleep(1000); + } + + Evaluate("exposure-flag"); + Evaluate("simple-string"); + Evaluate("rule-based-flag"); + Evaluate("numeric-rule-flag"); + Evaluate("time-based-flag"); + + IEvaluation? Evaluate(string key) + { + var context = new EvaluationContext(key); + var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, typeof(string), "Not found", context); + + if (evaluation is null) + { + Console.WriteLine($"Eval ({key}) : "); + } + else if (evaluation.Error is not null) + { + Console.WriteLine($"Eval ({key}) : "); + } + else + { + Console.WriteLine($"Eval ({key}) : "}>"); + } + + return evaluation; + } + + } +} From 0fa551c9130fa03af05dec1f4ee98b484167af3c Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Fri, 12 Dec 2025 18:19:57 +0100 Subject: [PATCH 14/54] Datadog OpenFeature Provider implementation --- .../Datadog.Trace/FeatureFlags/Evaluation.cs | 4 +- .../FeatureFlags/FeatureFlagsEvaluator.cs | 35 +++++--- .../FeatureFlags/FeatureFlagsModule.cs | 8 +- .../Datadog.Trace/FeatureFlags/IEvaluation.cs | 3 + .../FeatureFlags/FeatureFlagsTests.cs | 2 +- .../DataDogProvider.cs | 79 +++++++++++++++++-- .../Samples.OpenFeature-2.9/Program.cs | 18 +++-- 7 files changed, 116 insertions(+), 33 deletions(-) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs b/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs index 83a76f82571c..842942c1e583 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs @@ -14,9 +14,11 @@ namespace Datadog.Trace.FeatureFlags { - internal class Evaluation(object? value, EvaluationReason reason, string? variant = null, string? error = null, IDictionary? metadata = null) + internal class Evaluation(string flagKey, object? value, EvaluationReason reason, string? variant = null, string? error = null, IDictionary? metadata = null) : IEvaluation { + public string FlagKey { get; } = flagKey; + public object? Value { get; } = value; public EvaluationReason Reason { get; } = reason; diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index 37f27c4ba105..c87d33659a97 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -66,12 +66,12 @@ public FeatureFlagsEvaluator(Action? onExposureEve private delegate bool NumberEquality(double a, double b); - public Evaluation Evaluate(string key, T defaultValue, EvaluationContext context) + public Evaluation Evaluate(string flagKey, T defaultValue, EvaluationContext context) { - return Evaluate(key, typeof(T), defaultValue, context); + return Evaluate(flagKey, typeof(T), defaultValue, context); } - public Evaluation Evaluate(string key, Type resultType, object? defaultValue, IEvaluationContext context) + public Evaluation Evaluate(string flagKey, Type resultType, object? defaultValue, IEvaluationContext context) { try { @@ -79,6 +79,7 @@ public Evaluation Evaluate(string key, Type resultType, object? defaultValue, IE if (config == null) { return new Evaluation( + flagKey, defaultValue, EvaluationReason.ERROR, error: "PROVIDER_NOT_READY", @@ -91,6 +92,7 @@ public Evaluation Evaluate(string key, Type resultType, object? defaultValue, IE if (context == null) { return new Evaluation( + flagKey, defaultValue, EvaluationReason.ERROR, error: "INVALID_CONTEXT", @@ -103,6 +105,7 @@ public Evaluation Evaluate(string key, Type resultType, object? defaultValue, IE if (string.IsNullOrEmpty(context.TargetingKey)) { return new Evaluation( + flagKey, defaultValue, EvaluationReason.ERROR, error: "TARGETING_KEY_MISSING", @@ -112,9 +115,10 @@ public Evaluation Evaluate(string key, Type resultType, object? defaultValue, IE }); } - if (config.Flags is null || !config.Flags.TryGetValue(key, out var flag) || flag is null) + if (config.Flags is null || !config.Flags.TryGetValue(flagKey, out var flag) || flag is null) { return new Evaluation( + flagKey, defaultValue, EvaluationReason.ERROR, error: "FLAG_NOT_FOUND", @@ -127,6 +131,7 @@ public Evaluation Evaluate(string key, Type resultType, object? defaultValue, IE if (!flag.Enabled is true) { return new Evaluation( + flagKey, defaultValue, EvaluationReason.DISABLED); } @@ -134,6 +139,7 @@ public Evaluation Evaluate(string key, Type resultType, object? defaultValue, IE if (flag.Allocations is { Count: 0 }) { return new Evaluation( + flagKey, defaultValue, EvaluationReason.ERROR, error: "Missing allocations", @@ -168,7 +174,7 @@ public Evaluation Evaluate(string key, Type resultType, object? defaultValue, IE { if (split.Shards is { Count: 0 }) { - return ResolveVariant(key, resultType, defaultValue, flag, split.VariationKey ?? string.Empty, allocation, context); + return ResolveVariant(flagKey, resultType, defaultValue, flag, split.VariationKey ?? string.Empty, allocation, context); } var allShardsMatch = true; @@ -183,7 +189,7 @@ public Evaluation Evaluate(string key, Type resultType, object? defaultValue, IE if (allShardsMatch) { - return ResolveVariant(key, resultType, defaultValue, flag, split.VariationKey ?? string.Empty, allocation, context); + return ResolveVariant(flagKey, resultType, defaultValue, flag, split.VariationKey ?? string.Empty, allocation, context); } } } @@ -191,13 +197,15 @@ public Evaluation Evaluate(string key, Type resultType, object? defaultValue, IE // No allocation / split matched – use default return new Evaluation( + flagKey, defaultValue, EvaluationReason.DEFAULT); } catch (FormatException ex) { - Log.Debug(ex, "Evaluation failed for key {Key}", key); + Log.Debug(ex, "Evaluation failed for key {Key}", flagKey); return new Evaluation( + flagKey, defaultValue, EvaluationReason.ERROR, error: "TYPE_MISMATCH", @@ -208,8 +216,9 @@ public Evaluation Evaluate(string key, Type resultType, object? defaultValue, IE } catch (Exception ex) { - Log.Debug(ex, "Evaluation failed for key {Key}", key); + Log.Debug(ex, "Evaluation failed for key {Key}", flagKey); return new Evaluation( + flagKey, defaultValue, EvaluationReason.ERROR, error: ex.Message, @@ -615,7 +624,7 @@ private static double ParseDouble(object value) } private Evaluation ResolveVariant( - string key, + string flagKey, Type resultType, object? defaultValue, Flag flag, @@ -626,6 +635,7 @@ private Evaluation ResolveVariant( if (flag.Variations is null || !flag.Variations.TryGetValue(variationKey, out var variant) || variant == null) { return new Evaluation( + flagKey, defaultValue, EvaluationReason.ERROR, error: $"Variant not found for: {variationKey}", @@ -646,6 +656,7 @@ private Evaluation ResolveVariant( }; var evaluation = new Evaluation( + flagKey, mappedValue, EvaluationReason.TARGETING_MATCH, variant: variant.Key, @@ -654,14 +665,14 @@ private Evaluation ResolveVariant( var doLog = allocation.DoLog.HasValue && allocation.DoLog.Value; if (doLog) { - DispatchExposure(key, evaluation, context); + DispatchExposure(flagKey, evaluation, context); } return evaluation; } private void DispatchExposure( - string flag, + string flagKey, Evaluation evaluation, IEvaluationContext context) { @@ -676,7 +687,7 @@ private void DispatchExposure( var evt = new Exposure.Model.ExposureEvent( DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(), new Exposure.Model.Allocation(allocationKey), - new Exposure.Model.Flag(flag), + new Exposure.Model.Flag(flagKey), new Exposure.Model.Variant(variantKey), new Exposure.Model.Subject(context.TargetingKey, FlattenContext(context))); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index 6dfad55d323b..9fa6650b75a1 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -99,22 +99,22 @@ internal void RegisterOnNewConfigEventHandler(Action? onNewConfig) _onNewConfigEventHander = onNewConfig; } - internal Evaluation Evaluate(string key, Type resultType, object? defaultValue, IEvaluationContext context) + internal Evaluation Evaluate(string flagKey, Type resultType, object? defaultValue, IEvaluationContext context) { if (!_enabled) { Log.Debug("FeatureFlagsModule::Evaluate -> FeatureFlagsModule DISABLED"); - return new Evaluation(null, EvaluationReason.ERROR, null, "FeatureFlagsSdk is disabled"); + return new Evaluation(flagKey, null, EvaluationReason.ERROR, null, "FeatureFlagsSdk is disabled"); } if (_evaluator is null) { Log.Debug("FeatureFlagsModule::Evaluate -> Evaluator is null (no config received)"); - return new Evaluation(null, EvaluationReason.ERROR, null, "No config loaded"); + return new Evaluation(flagKey, null, EvaluationReason.ERROR, null, "No config loaded"); } Log.Debug("FeatureFlagsModule::Evaluate -> Returning Evaluation"); - return _evaluator.Evaluate(key, resultType, defaultValue, context); + return _evaluator.Evaluate(flagKey, resultType, defaultValue, context); } private void UpdateConfig(List> list) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluation.cs b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluation.cs index 34aaac7838e4..f1b4d3fbfadd 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluation.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluation.cs @@ -17,6 +17,9 @@ namespace Datadog.Trace.FeatureFlags; /// FeatureFlag Evaluation result. public partial interface IEvaluation { + /// Gets the flag key being evaluate + string FlagKey { get; } + /// Gets the evaluation result object? Value { get; } diff --git a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs index 579c4362eca8..7a51080d3bef 100644 --- a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs +++ b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs @@ -26,7 +26,7 @@ #pragma warning disable SA1402 // File may only contain a single type -namespace Datadog.Trace.ClrProfiler.IntegrationTests; +namespace Datadog.Trace.ClrProfiler.IntegrationTests.FeatureFlags; #if NETFRAMEWORK // The .NET Framework tests use NGEN which is a global thing, so make sure we don't parallelize diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs index 61c8b3904d59..4df6db651273 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs @@ -1,42 +1,105 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Reflection; using System.Text; using System.Threading.Tasks; +using OpenFeature.Constant; using OpenFeature.Model; namespace Samples.OpenFeature_2._9 { internal class DataDogProvider : OpenFeature.FeatureProvider { - public override Metadata? GetMetadata() - { - throw new NotImplementedException(); - } + Metadata _metadata = new Metadata("datadog-openfeature-provider"); + public override Metadata? GetMetadata() => _metadata; public override Task> ResolveBooleanValueAsync(string flagKey, bool defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { - throw new NotImplementedException(); + return Task.Run(() => + { + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(bool), defaultValue, GetContext(context)); + return GetResolutionDetails(res); + }, + cancellationToken); } public override Task> ResolveDoubleValueAsync(string flagKey, double defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { - throw new NotImplementedException(); + return Task.Run(() => + { + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(double), defaultValue, GetContext(context)); + return GetResolutionDetails(res); + }, + cancellationToken); } public override Task> ResolveIntegerValueAsync(string flagKey, int defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { - throw new NotImplementedException(); + return Task.Run(() => + { + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(int), defaultValue, GetContext(context)); + return GetResolutionDetails(res); + }, + cancellationToken); } public override Task> ResolveStringValueAsync(string flagKey, string defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { - throw new NotImplementedException(); + return Task.Run(() => + { + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(string), defaultValue, GetContext(context)); + return GetResolutionDetails(res); + }, + cancellationToken); } public override Task> ResolveStructureValueAsync(string flagKey, Value defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { throw new NotImplementedException(); } + + private static Datadog.Trace.FeatureFlags.IEvaluationContext? GetContext(EvaluationContext? context) + { + if (context == null) { return new Datadog.Trace.FeatureFlags.EvaluationContext(""); } + var values = context.AsDictionary().Select(p => new KeyValuePair(p.Key, ToObject(p.Value))).ToDictionary(p => p.Key, p => p.Value); + var res = new Datadog.Trace.FeatureFlags.EvaluationContext(context.TargetingKey!, values); + return res; + } + + private static object? ToObject(Value value) + { + if (value == null) { return null; } + else if (value.IsBoolean) { return value.AsBoolean; } + else if (value.IsString) { return value.AsString; } + else if (value.IsNumber) { return value.AsDouble; } + else { return value.AsObject; } + } + + private static ResolutionDetails GetResolutionDetails(Datadog.Trace.FeatureFlags.IEvaluation? evaluation) + { + if (evaluation == null) { return default!; } + var value = evaluation.Value ?? default(T); + var res = new ResolutionDetails( + evaluation.FlagKey, + (T)value!, + ToErrorType(evaluation.Reason), + evaluation.Reason.ToString(), + evaluation.Variant, + evaluation.Error, + ToMetadata(evaluation.FlagMetadata!) + ); + return res; + } + + private static ErrorType ToErrorType(Datadog.Trace.FeatureFlags.EvaluationReason reason) + { + return ErrorType.None; + } + + private static ImmutableMetadata ToMetadata(IDictionary metadata) + { + return default!; + } } } diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs index 4f0a100560f4..63c7ca53951a 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs @@ -1,6 +1,7 @@ using System; using System.Diagnostics; -using Datadog.Trace.FeatureFlags; +using OpenFeature.Model; +using Samples.OpenFeature_2._9; namespace Samples.OpenFeature_2_9; @@ -12,6 +13,9 @@ private static void Main(string[] args) // See https://aka.ms/new-console-template for more information Console.WriteLine("OpenFeature 2.9 FeatureFlags SDK Sample"); + OpenFeature.Api.Instance.SetProviderAsync(new DataDogProvider()).Wait(); + var client = OpenFeature.Api.Instance.GetClient(); + if (!Datadog.Trace.FeatureFlags.FeatureFlagsSdk.IsAvailable()) { Console.WriteLine($""); @@ -21,7 +25,7 @@ private static void Main(string[] args) Console.WriteLine($""); var ev = Evaluate("nonexistent"); - if (ev != null && ev.Error is "FeatureFlagsSdk is disabled") + if (ev != null && ev.ErrorMessage is "FeatureFlagsSdk is disabled") { return; } @@ -48,18 +52,18 @@ private static void Main(string[] args) Evaluate("numeric-rule-flag"); Evaluate("time-based-flag"); - IEvaluation? Evaluate(string key) + FlagEvaluationDetails? Evaluate(string key) { - var context = new EvaluationContext(key); - var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, typeof(string), "Not found", context); + var context = EvaluationContext.Builder().Set("targetingKey", key).Build(); + var evaluation = client.GetStringDetailsAsync(key, "Not found", context).Result; if (evaluation is null) { Console.WriteLine($"Eval ({key}) : "); } - else if (evaluation.Error is not null) + else if (evaluation.ErrorMessage is not null) { - Console.WriteLine($"Eval ({key}) : "); + Console.WriteLine($"Eval ({key}) : "); } else { From a2d272c516ef4cfc51bb8737f23962e9f59b108a Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Mon, 15 Dec 2025 12:32:52 +0100 Subject: [PATCH 15/54] OpenFeature DataProvider fix --- .../Samples.OpenFeature-2.9/DataDogProvider.cs | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs index 4df6db651273..3a92b5b5eca6 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs @@ -56,7 +56,12 @@ public override Task> ResolveStringValueAsync(string f public override Task> ResolveStructureValueAsync(string flagKey, Value defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { - throw new NotImplementedException(); + return Task.Run(() => + { + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(Value), defaultValue, GetContext(context)); + return GetResolutionDetails(res); + }, + cancellationToken); } private static Datadog.Trace.FeatureFlags.IEvaluationContext? GetContext(EvaluationContext? context) @@ -79,10 +84,9 @@ public override Task> ResolveStructureValueAsync(string private static ResolutionDetails GetResolutionDetails(Datadog.Trace.FeatureFlags.IEvaluation? evaluation) { if (evaluation == null) { return default!; } - var value = evaluation.Value ?? default(T); var res = new ResolutionDetails( evaluation.FlagKey, - (T)value!, + (T)(evaluation.Value ?? default(T)!), ToErrorType(evaluation.Reason), evaluation.Reason.ToString(), evaluation.Variant, @@ -94,12 +98,12 @@ private static ResolutionDetails GetResolutionDetails(Datadog.Trace.Featur private static ErrorType ToErrorType(Datadog.Trace.FeatureFlags.EvaluationReason reason) { - return ErrorType.None; + return ErrorType.None; // TODO: Map error types properly } private static ImmutableMetadata ToMetadata(IDictionary metadata) { - return default!; + return default!; // TODO: Map metadata properly } } } From 638ce85170ed0637cf6c26f72fc6aafb2c1dde48 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Mon, 15 Dec 2025 14:03:28 +0100 Subject: [PATCH 16/54] Rebase fix --- Datadog.Trace.Samples.g.sln | 4 ++++ Datadog.Trace.sln | 6 ++++++ .../build/Datadog.Trace.Trimming.xml | 3 --- .../Configuration/configuration_keys_mapping.json | 4 ++++ .../Configuration/supported-configurations-docs.yaml | 4 ++++ .../Configuration/supported-configurations.json | 12 ++++++++---- .../FeatureFlags/Exposure/ExposureApi.cs | 8 ++++---- .../ConfigurationKeys.FeatureFlags.g.cs | 5 +++++ .../ConfigurationKeys.FeatureFlags.g.cs | 5 +++++ .../ConfigurationKeys.FeatureFlags.g.cs | 5 +++++ .../ConfigurationKeys.FeatureFlags.g.cs | 5 +++++ 11 files changed, 50 insertions(+), 11 deletions(-) diff --git a/Datadog.Trace.Samples.g.sln b/Datadog.Trace.Samples.g.sln index 7a8c01fea6c3..6398c3a61484 100644 --- a/Datadog.Trace.Samples.g.sln +++ b/Datadog.Trace.Samples.g.sln @@ -681,6 +681,10 @@ Global {95613224-C1D7-4D4A-8926-F70DA26371CA}.Debug|Any CPU.Build.0 = Debug|Any CPU {95613224-C1D7-4D4A-8926-F70DA26371CA}.Release|Any CPU.ActiveCfg = Release|Any CPU {95613224-C1D7-4D4A-8926-F70DA26371CA}.Release|Any CPU.Build.0 = Release|Any CPU + {A1234567-C1D7-4D4A-8926-F70DA26371CA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A1234567-C1D7-4D4A-8926-F70DA26371CA}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A1234567-C1D7-4D4A-8926-F70DA26371CA}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A1234567-C1D7-4D4A-8926-F70DA26371CA}.Release|Any CPU.Build.0 = Release|Any CPU {BF1E5BA6-C0E5-4472-9D5D-2622231DD275}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {BF1E5BA6-C0E5-4472-9D5D-2622231DD275}.Debug|Any CPU.Build.0 = Debug|Any CPU {BF1E5BA6-C0E5-4472-9D5D-2622231DD275}.Release|Any CPU.ActiveCfg = Release|Any CPU diff --git a/Datadog.Trace.sln b/Datadog.Trace.sln index 39bc49be3033..779fe03a0421 100644 --- a/Datadog.Trace.sln +++ b/Datadog.Trace.sln @@ -951,6 +951,10 @@ Global {95613224-C1D7-4D4A-8926-F70DA26371CA}.Debug|Any CPU.Build.0 = Debug|Any CPU {95613224-C1D7-4D4A-8926-F70DA26371CA}.Release|Any CPU.ActiveCfg = Release|Any CPU {95613224-C1D7-4D4A-8926-F70DA26371CA}.Release|Any CPU.Build.0 = Release|Any CPU + {A1234567-C1D7-4D4A-8926-F70DA26371CA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A1234567-C1D7-4D4A-8926-F70DA26371CA}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A1234567-C1D7-4D4A-8926-F70DA26371CA}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A1234567-C1D7-4D4A-8926-F70DA26371CA}.Release|Any CPU.Build.0 = Release|Any CPU {78004AA7-26DD-44DB-A2C7-C287A5BBE5D6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {78004AA7-26DD-44DB-A2C7-C287A5BBE5D6}.Release|Any CPU.ActiveCfg = Release|Any CPU {BF1E5BA6-C0E5-4472-9D5D-2622231DD275}.Debug|Any CPU.ActiveCfg = Debug|Any CPU @@ -1834,6 +1838,7 @@ Global tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{536f1d82-d40c-4e33-b7fa-76a0f17bf672}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{560e1104-9a6e-41e7-ab3d-85ba2740a0f7}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{56de0d44-e9e5-48da-baea-2934b1e28d4e}*SharedItemsImports = 5 + tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{59a9edcd-6892-4817-8957-54de84bdcafb}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{5a806f4b-39e7-4f38-b36f-f5cfc4f8760a}*SharedItemsImports = 13 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{5c2829c2-ed0d-414c-b5a0-2bfdca07b493}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{5d2c6b9c-fce2-4e46-b4ed-bc3b11cfbb3c}*SharedItemsImports = 5 @@ -1876,6 +1881,7 @@ Global tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{959e9599-8d99-43bc-8038-b91f76179c1c}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{99a62ccf-8e7f-4d57-8383-d38c371c8087}*SharedItemsImports = 4 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{9d5935cb-2df2-46cb-a5e1-98be134cafcc}*SharedItemsImports = 5 + tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{a1234567-c1d7-4d4a-8926-f70da26371ca}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{a82eb6f8-d8d0-4763-b252-08ca3f39d153}*SharedItemsImports = 4 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{a996927a-9222-43f4-8552-810b69ff04df}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{aa88952e-9393-4a4b-85b5-cc7f03629ce1}*SharedItemsImports = 5 diff --git a/tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml b/tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml index a6bea9519727..e729b88100d6 100644 --- a/tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml +++ b/tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml @@ -231,7 +231,6 @@ - @@ -583,8 +582,6 @@ - - diff --git a/tracer/src/Datadog.Trace/Configuration/configuration_keys_mapping.json b/tracer/src/Datadog.Trace/Configuration/configuration_keys_mapping.json index 3feeb5979b85..a16abce52211 100644 --- a/tracer/src/Datadog.Trace/Configuration/configuration_keys_mapping.json +++ b/tracer/src/Datadog.Trace/Configuration/configuration_keys_mapping.json @@ -832,6 +832,10 @@ "env_var": "DD_TRACE_INJECT_CONTEXT_INTO_STORED_PROCEDURES_ENABLED", "const_name": "InjectContextIntoStoredProceduresEnabled" }, + { + "env_var": "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED", + "const_name": "FlaggingProviderEnabled" + }, { "env_var": "DD_TRACE_KAFKA_CREATE_CONSUMER_SCOPE_ENABLED", "const_name": "KafkaCreateConsumerScopeEnabled" diff --git a/tracer/src/Datadog.Trace/Configuration/supported-configurations-docs.yaml b/tracer/src/Datadog.Trace/Configuration/supported-configurations-docs.yaml index fed47608e486..9c8c3fa4b637 100644 --- a/tracer/src/Datadog.Trace/Configuration/supported-configurations-docs.yaml +++ b/tracer/src/Datadog.Trace/Configuration/supported-configurations-docs.yaml @@ -882,6 +882,10 @@ DD_TRACE_INJECT_CONTEXT_INTO_STORED_PROCEDURES_ENABLED: |
  • The stored procedure call does not have Output, InputOutput, or Return ADO.NET command parameters.
    • +DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED: | + Enables Feature Flags Provider (Experimental). + + DD_TRACE_KAFKA_CREATE_CONSUMER_SCOPE_ENABLED: | Configuration key to enable or disable the creation of a span context on exiting a successful Kafka Consumer.Consume() call, and closing the scope on entering Consumer.Consume(). diff --git a/tracer/src/Datadog.Trace/Configuration/supported-configurations.json b/tracer/src/Datadog.Trace/Configuration/supported-configurations.json index bb98a7992ce4..06a4299a8089 100644 --- a/tracer/src/Datadog.Trace/Configuration/supported-configurations.json +++ b/tracer/src/Datadog.Trace/Configuration/supported-configurations.json @@ -1193,6 +1193,12 @@ ], "product": "FeatureFlags" }, + "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED": { + "version": [ + "A" + ], + "product": "FeatureFlags" + }, "DD_TRACE_KAFKA_CREATE_CONSUMER_SCOPE_ENABLED": { "version": [ "A" @@ -1409,8 +1415,7 @@ ], "product": "OpenTelemetry" }, - "OTEL_EXPORTER_OTLP_LOGS_TIMEOUT": - { + "OTEL_EXPORTER_OTLP_LOGS_TIMEOUT": { "version": [ "A" ], @@ -1428,8 +1433,7 @@ ], "product": "OpenTelemetry" }, - "OTEL_EXPORTER_OTLP_LOGS_HEADERS": - { + "OTEL_EXPORTER_OTLP_LOGS_HEADERS": { "version": [ "A" ], diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs index 96e5e09d827d..932bb72df21d 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs @@ -38,15 +38,15 @@ internal class ExposureApi private ExposureApi(IApiRequestFactory apiRequestFactory, TracerSettings tracerSettings) { _apiRequestFactory = apiRequestFactory; - _context["service"] = tracerSettings.ServiceName ?? "unknown"; - _context["env"] = tracerSettings.Environment ?? "unknown"; - _context["version"] = tracerSettings.ServiceVersion ?? "unknown"; + _context["service"] = tracerSettings.Manager.InitialMutableSettings.ServiceName ?? "unknown"; + _context["env"] = tracerSettings.Manager.InitialMutableSettings.Environment ?? "unknown"; + _context["version"] = tracerSettings.Manager.InitialMutableSettings.ServiceVersion ?? "unknown"; } public static ExposureApi Create(TracerSettings tracerSettings) { var apiRequestFactory = AgentTransportStrategy.Get( - tracerSettings.Exporter, + tracerSettings.Manager.InitialExporterSettings, productName: "FeatureFlags exposure", tcpTimeout: TimeSpan.FromSeconds(5), AgentHttpHeaderNames.MinimalHeaders, diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs index 7c8a0b7fc263..c0f262891413 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs @@ -17,6 +17,11 @@ internal static partial class ConfigurationKeys { internal static class FeatureFlags { + /// + /// Enables Feature Flags Provider (Experimental). + /// + public const string FlaggingProviderEnabled = "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED"; + /// /// Enables support for collecting and exporting logs generated by the the OpenTelemetry Logs API. /// This feature is available starting with .NET 3.1 when using Microsoft.Extensions.Logging diff --git a/tracer/src/Datadog.Trace/Generated/net6.0/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs b/tracer/src/Datadog.Trace/Generated/net6.0/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs index 7c8a0b7fc263..c0f262891413 100644 --- a/tracer/src/Datadog.Trace/Generated/net6.0/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net6.0/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs @@ -17,6 +17,11 @@ internal static partial class ConfigurationKeys { internal static class FeatureFlags { + /// + /// Enables Feature Flags Provider (Experimental). + /// + public const string FlaggingProviderEnabled = "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED"; + /// /// Enables support for collecting and exporting logs generated by the the OpenTelemetry Logs API. /// This feature is available starting with .NET 3.1 when using Microsoft.Extensions.Logging diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs index 7c8a0b7fc263..c0f262891413 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs @@ -17,6 +17,11 @@ internal static partial class ConfigurationKeys { internal static class FeatureFlags { + /// + /// Enables Feature Flags Provider (Experimental). + /// + public const string FlaggingProviderEnabled = "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED"; + /// /// Enables support for collecting and exporting logs generated by the the OpenTelemetry Logs API. /// This feature is available starting with .NET 3.1 when using Microsoft.Extensions.Logging diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs index 7c8a0b7fc263..c0f262891413 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs @@ -17,6 +17,11 @@ internal static partial class ConfigurationKeys { internal static class FeatureFlags { + /// + /// Enables Feature Flags Provider (Experimental). + /// + public const string FlaggingProviderEnabled = "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED"; + /// /// Enables support for collecting and exporting logs generated by the the OpenTelemetry Logs API. /// This feature is available starting with .NET 3.1 when using Microsoft.Extensions.Logging From 9731aa1bf89c91ad0cba0bb8b8f5bdb97f9ee0ee Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Mon, 15 Dec 2025 16:08:22 +0100 Subject: [PATCH 17/54] Added multy target to sample apps --- .../feature-flags/Samples.FeatureFlags/Program.cs | 2 +- .../Samples.FeatureFlags/Samples.FeatureFlags.csproj | 7 +++---- .../Samples.OpenFeature-2.9/DataDogProvider.cs | 3 +-- .../feature-flags/Samples.OpenFeature-2.9/Program.cs | 3 +-- .../Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj | 7 +++---- 5 files changed, 9 insertions(+), 13 deletions(-) diff --git a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs index 9933a7635bdd..d93def529400 100644 --- a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs +++ b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs @@ -38,7 +38,7 @@ private static void Main(string[] args) return; } Console.WriteLine($"Waiting for RC..."); - Thread.Sleep(1000); + System.Threading.Thread.Sleep(1000); } Evaluate("exposure-flag"); diff --git a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Samples.FeatureFlags.csproj b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Samples.FeatureFlags.csproj index 13e433dae186..2c1d924f1d89 100644 --- a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Samples.FeatureFlags.csproj +++ b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Samples.FeatureFlags.csproj @@ -1,10 +1,9 @@  - Exe - net10.0 - Samples.FeatureFlags - enable + + false + false enable diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs index 3a92b5b5eca6..e10f8a36ef79 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs @@ -1,8 +1,7 @@ using System; using System.Collections.Generic; using System.Linq; -using System.Reflection; -using System.Text; +using System.Threading; using System.Threading.Tasks; using OpenFeature.Constant; using OpenFeature.Model; diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs index 63c7ca53951a..4604488dbf70 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs @@ -1,5 +1,4 @@ using System; -using System.Diagnostics; using OpenFeature.Model; using Samples.OpenFeature_2._9; @@ -43,7 +42,7 @@ private static void Main(string[] args) return; } Console.WriteLine($"Waiting for RC..."); - Thread.Sleep(1000); + System.Threading.Thread.Sleep(1000); } Evaluate("exposure-flag"); diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj index 4815b05d3828..1cc9efbbd7fe 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj @@ -1,10 +1,9 @@  - Exe - net10.0 - Samples.OpenFeature_2._9 - enable + + false + false enable From 760e987d6584828f7c2558e8b380ec3ade7fa6ea Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Tue, 16 Dec 2025 18:50:26 +0100 Subject: [PATCH 18/54] Fixed tests --- ...Manual.PublicApiHasNotChanged.verified.txt | 44 +++++++++++++++++++ .../Telemetry/config_norm_rules.json | 3 +- 2 files changed, 46 insertions(+), 1 deletion(-) diff --git a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt index 452fcd2588c0..b90279176f5c 100644 --- a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt +++ b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt @@ -485,4 +485,48 @@ namespace Datadog.Trace.ExtensionMethods { public static void SetTraceSamplingPriority(this Datadog.Trace.ISpan span, Datadog.Trace.SamplingPriority samplingPriority) { } } +} +namespace Datadog.Trace.FeatureFlags +{ + public class EvaluationContext : Datadog.Trace.FeatureFlags.IEvaluationContext + { + public EvaluationContext(string key, System.Collections.Generic.IDictionary? values = null, System.Func? convertValue = null) { } + public string TargetingKey { get; } + public System.Collections.Generic.IDictionary Values { get; } + public object? ConvertValue(object? value) { } + public object? GetValue(string key) { } + } + public enum EvaluationReason + { + DEFAULT = 0, + STATIC = 1, + TARGETING_MATCH = 2, + SPLIT = 3, + DISABLED = 4, + CACHED = 5, + UNKNOWN = 6, + ERROR = 7, + } + public static class FeatureFlagsSdk + { + public static Datadog.Trace.FeatureFlags.IEvaluation? Evaluate(string key, System.Type targetType, object? defaultValue, Datadog.Trace.FeatureFlags.IEvaluationContext? context) { } + public static bool IsAvailable() { } + public static void RegisterOnNewConfigEventHandler(System.Action onNewConfig) { } + } + public interface IEvaluation + { + string? Error { get; } + string FlagKey { get; } + System.Collections.Generic.IDictionary? FlagMetadata { get; } + Datadog.Trace.FeatureFlags.EvaluationReason Reason { get; } + object? Value { get; } + string? Variant { get; } + } + public interface IEvaluationContext + { + string TargetingKey { get; } + System.Collections.Generic.IDictionary Values { get; } + object? ConvertValue(object? value); + object? GetValue(string key); + } } \ No newline at end of file diff --git a/tracer/test/Datadog.Trace.Tests/Telemetry/config_norm_rules.json b/tracer/test/Datadog.Trace.Tests/Telemetry/config_norm_rules.json index f0609a8182e4..6100f3acf176 100644 --- a/tracer/test/Datadog.Trace.Tests/Telemetry/config_norm_rules.json +++ b/tracer/test/Datadog.Trace.Tests/Telemetry/config_norm_rules.json @@ -704,8 +704,9 @@ "DD_PROFILING_MANAGED_ACTIVATION_ENABLED": "trace_profiler_managed_activation_enabled", "DD_CALLSITE_MANAGED_ACTIVATION_ENABLED": "trace_callsite_managed_activation_enabled", "DD_TRACE_GRAPHQL_ERROR_EXTENSIONS": "trace_graphql_error_extensions", - "DD_APPLICATION_MONITORING_CONFIG_FILE_ENABLED":"application_monitoring_config_file_enabled", + "DD_APPLICATION_MONITORING_CONFIG_FILE_ENABLED": "application_monitoring_config_file_enabled", "DD_TRACE_AZURE_SERVICEBUS_BATCH_LINKS_ENABLED": "trace_azure_servicebus_batch_links_enabled", "DD_TRACE_AZURE_EVENTHUBS_BATCH_LINKS_ENABLED": "trace_azure_eventhubs_batch_links_enabled", + "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED": "experimental_flagging_provider_enabled", "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED": "experimental_propagate_process_tags_enabled" } From afcf2af0a8ba773b5a2b620be8afbc9b411ab19a Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Tue, 16 Dec 2025 18:57:58 +0100 Subject: [PATCH 19/54] Created Datadog.Trace.OpenFeature package --- Datadog.Trace.sln | 7 + docs/Datadog.Trace.OpenFeature/README.md | 82 ++++++++++ .../Datadog.Trace.OpenFeature.csproj | 46 ++++++ .../DatadogProvider.cs | 154 ++++++++++++++++++ .../DataDogProvider.cs | 108 ------------ .../Samples.OpenFeature-2.9/Program.cs | 3 +- .../Samples.OpenFeature-2.9.csproj | 2 +- 7 files changed, 291 insertions(+), 111 deletions(-) create mode 100644 docs/Datadog.Trace.OpenFeature/README.md create mode 100644 tracer/src/Datadog.Trace.OpenFeature/Datadog.Trace.OpenFeature.csproj create mode 100644 tracer/src/Datadog.Trace.OpenFeature/DatadogProvider.cs delete mode 100644 tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs diff --git a/Datadog.Trace.sln b/Datadog.Trace.sln index 779fe03a0421..7c6404960f3f 100644 --- a/Datadog.Trace.sln +++ b/Datadog.Trace.sln @@ -633,6 +633,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.OpenFeature-2.9", " EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Datadog.Trace.Tools.Analyzers.CodeFixes", "tracer\src\Datadog.Trace.Tools.Analyzers.CodeFixes\Datadog.Trace.Tools.Analyzers.CodeFixes.csproj", "{32521F0A-D52D-4DB1-86C4-3D72DEDA6E55}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Datadog.Trace.OpenFeature", "tracer\src\Datadog.Trace.OpenFeature\Datadog.Trace.OpenFeature.csproj", "{E40B79B5-F801-FD8B-901A-0B3CE8B5486C}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -1533,6 +1535,10 @@ Global {32521F0A-D52D-4DB1-86C4-3D72DEDA6E55}.Debug|Any CPU.Build.0 = Debug|Any CPU {32521F0A-D52D-4DB1-86C4-3D72DEDA6E55}.Release|Any CPU.ActiveCfg = Release|Any CPU {32521F0A-D52D-4DB1-86C4-3D72DEDA6E55}.Release|Any CPU.Build.0 = Release|Any CPU + {E40B79B5-F801-FD8B-901A-0B3CE8B5486C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E40B79B5-F801-FD8B-901A-0B3CE8B5486C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E40B79B5-F801-FD8B-901A-0B3CE8B5486C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E40B79B5-F801-FD8B-901A-0B3CE8B5486C}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -1783,6 +1789,7 @@ Global {D5A8ABB9-CB23-974E-F338-5D9172D96CD8} = {D0C69381-F696-4113-BE7E-BA43468F431C} {021D714E-1764-D76B-15B5-C9114FE934C2} = {D0C69381-F696-4113-BE7E-BA43468F431C} {32521F0A-D52D-4DB1-86C4-3D72DEDA6E55} = {9E5F0022-0A50-40BF-AC6A-C3078585ECAB} + {E40B79B5-F801-FD8B-901A-0B3CE8B5486C} = {9E5F0022-0A50-40BF-AC6A-C3078585ECAB} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {160A1D00-1F5B-40F8-A155-621B4459D78F} diff --git a/docs/Datadog.Trace.OpenFeature/README.md b/docs/Datadog.Trace.OpenFeature/README.md new file mode 100644 index 000000000000..d10c82882583 --- /dev/null +++ b/docs/Datadog.Trace.OpenFeature/README.md @@ -0,0 +1,82 @@ +# `Datadog.Trace.OpenFeature` NuGet package + +This package contains the Datadog .NET OpenFeature SDK + +## Should I install this package? + +Install this package if: + +- You intend to use the DataDog *FeatureFlags* tooling in your OpenFeature enabled app + +## What does Datadog.Trace.OpenFeature contain? + +Datadog.Trace.OpenFeature contains three things: + +- The **Datadog.Trace.OpenFeature.dll assembly** with the **DatadogProvider** compatible with **OpenFeature** from **V2.0.0 onwards**. +- A reference to the [Datadog.Trace NuGet package](https://www.nuget.org/packages/Datadog.Trace) for custom instrumentation. +- The native binaries required for automatic instrumentation, for the Continuous Profiler, and for ASM. + +These native binaries are identical to those installed by the MSI and Linux installer packages, so Datadog.Trace.OpenFeature should be considered an alternative deployment mechanism for automatic instrumentation. + +The main advantages of Datadog.Trace.OpenFeature over the MSI or Linux packages are: +- You can use it in locations where you cannot access the underlying host to install the MSI or Linux package. +- You can have multiple applications on the same host using different versions of Datadog.Trace.Bundle without issue. + +## Getting Started + +1. Configure the Datadog agent for APM [as described in our documentation](https://docs.datadoghq.com/tracing/setup_overview/setup/dotnet-core#configure-the-datadog-agent-for-apm). +2. Add the [Datadog.Trace.OpenFeature](https://www.nuget.org/packages/Datadog.Trace.OpenFeature) NuGet package to your project, using `dotnet add package Datadog.Trace.OpenFeature`, for example. +3. Configure the tracer on the server, as [described below](#configure-the-tracer) +4. Add an instance of the **DatadogProvider** to your **OpenFeature.Api.Instance** using `await OpenFeature.Api.Instance.SetProviderAsync(new Datadog.Trace.OpenFeature.DatadogProvider())` + +### Configure the environment + +After adding the NuGet package to your project, set the following **required** environment variables to enable automatic instrumentation of your application and restart the application. + +> **_NOTE:_** +The following are the mandatory variables. For further configuration options, see our public documentation for the [Tracer](https://docs.datadoghq.com/tracing/trace_collection/library_config/dotnet-core/?tab=environmentvariables) and the [Continuous Profiler](https://docs.datadoghq.com/profiler/enabling/dotnet/?tab=linux#configuration). + + +.NET Core: + +``` +CORECLR_ENABLE_PROFILING=1 +CORECLR_PROFILER={846F5F1C-F9AE-4B07-969E-05C26BC060D8} +CORECLR_PROFILER_PATH= +DD_DOTNET_TRACER_HOME=/datadog +``` + +.NET Framework: + +``` +COR_ENABLE_PROFILING=1 +COR_PROFILER={846F5F1C-F9AE-4B07-969E-05C26BC060D8} +COR_PROFILER_PATH= +DD_DOTNET_TRACER_HOME=/datadog +``` + +The value for the `` placeholder is the path to the directory containing the application’s .dll files. The value for the `CORECLR_PROFILER_PATH`/`COR_PROFILER_PATH` environment variable varies based on the system where the application is running: + +| OPERATING SYSTEM AND PROCESS ARCHITECTURE | CORECLR_PROFILER_PATH VALUE | +|-------------------------------------------|------------------------------------------------------------------------------| +| Alpine Linux x64 | /datadog/linux-musl-x64/Datadog.Trace.ClrProfiler.Native.so | +| Linux x64 | /datadog/linux-x64/Datadog.Trace.ClrProfiler.Native.so | +| Alpine Linux ARM64 | /datadog/linux-musl-arm64/Datadog.Trace.ClrProfiler.Native.so | +| Linux ARM64 | /datadog/linux-arm64/Datadog.Trace.ClrProfiler.Native.so | +| Windows x64 | \datadog\win-x64\Datadog.Trace.ClrProfiler.Native.dll | +| Windows x86 | \datadog\win-x86\Datadog.Trace.ClrProfiler.Native.dll | + +For Docker images running on Linux, configure the image to run the createLogPath.sh script: + +``` +RUN //datadog/createLogPath.sh +``` + +### Examples + +Docker examples are available [here](https://github.com/DataDog/dd-trace-dotnet/tree/master/tracer/samples/NugetDeployment) + +## Get in touch + +If you have questions, feedback, or feature requests, reach our [support](https://docs.datadoghq.com/help). + diff --git a/tracer/src/Datadog.Trace.OpenFeature/Datadog.Trace.OpenFeature.csproj b/tracer/src/Datadog.Trace.OpenFeature/Datadog.Trace.OpenFeature.csproj new file mode 100644 index 000000000000..caaa21a7ee4b --- /dev/null +++ b/tracer/src/Datadog.Trace.OpenFeature/Datadog.Trace.OpenFeature.csproj @@ -0,0 +1,46 @@ + + + + Datadog OpenFeature SDK + OpenFeature SDK for Datadog + false + true + README.md + + $(NoWarn);NU5100;NU5128;NU1901;NU1902;NU1903;NU1904 + bin\$(Configuration)\packages + False + + + + + + + + + Never + true + + + + + + Never + Never + + + + Never + Never + + + + + + + + + + + + diff --git a/tracer/src/Datadog.Trace.OpenFeature/DatadogProvider.cs b/tracer/src/Datadog.Trace.OpenFeature/DatadogProvider.cs new file mode 100644 index 000000000000..3522134a830c --- /dev/null +++ b/tracer/src/Datadog.Trace.OpenFeature/DatadogProvider.cs @@ -0,0 +1,154 @@ +// +// 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 System.Collections.Generic; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using OpenFeature.Constant; +using OpenFeature.Model; + +namespace Datadog.Trace.OpenFeature; + +/// +/// OpenFeature V2.0.0+ Provider for Datadog +/// +public class DatadogProvider : global::OpenFeature.FeatureProvider +{ + private Metadata _metadata = new Metadata("datadog-openfeature-provider"); + + /// Gets provider metadata + /// Returns provider metadata + public override Metadata? GetMetadata() => _metadata; + + /// Resolve flag as boolean + /// Requested flag + /// Default value + /// Evaluation context + /// Async cancelation token + /// Returns the evaluation result + public override Task> ResolveBooleanValueAsync(string flagKey, bool defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) + { + return Task.Run( + () => + { + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(bool), defaultValue, GetContext(context)); + return GetResolutionDetails(res); + }, + cancellationToken); + } + + /// Resolve flag as double + /// Requested flag + /// Default value + /// Evaluation context + /// Async cancelation token + /// Returns the evaluation result + public override Task> ResolveDoubleValueAsync(string flagKey, double defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) + { + return Task.Run( + () => + { + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(double), defaultValue, GetContext(context)); + return GetResolutionDetails(res); + }, + cancellationToken); + } + + /// Resolve flag as integer + /// Requested flag + /// Default value + /// Evaluation context + /// Async cancelation token + /// Returns the evaluation result + public override Task> ResolveIntegerValueAsync(string flagKey, int defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) + { + return Task.Run( + () => + { + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(int), defaultValue, GetContext(context)); + return GetResolutionDetails(res); + }, + cancellationToken); + } + + /// Resolve flag as string + /// Requested flag + /// Default value + /// Evaluation context + /// Async cancelation token + /// Returns the evaluation result + public override Task> ResolveStringValueAsync(string flagKey, string defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) + { + return Task.Run( + () => + { + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(string), defaultValue, GetContext(context)); + return GetResolutionDetails(res); + }, + cancellationToken); + } + + /// Resolve flag as Value + /// Requested flag + /// Default value + /// Evaluation context + /// Async cancelation token + /// Returns the evaluation result + public override Task> ResolveStructureValueAsync(string flagKey, Value defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) + { + return Task.Run( + () => + { + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(Value), defaultValue, GetContext(context)); + return GetResolutionDetails(res); + }, + cancellationToken); + } + + private static Datadog.Trace.FeatureFlags.IEvaluationContext? GetContext(EvaluationContext? context) + { + if (context == null) { return new Datadog.Trace.FeatureFlags.EvaluationContext(string.Empty); } + var values = context.AsDictionary().Select(p => new KeyValuePair(p.Key, ToObject(p.Value))).ToDictionary(p => p.Key, p => p.Value); + var res = new Datadog.Trace.FeatureFlags.EvaluationContext(context.TargetingKey!, values); + return res; + } + + private static object? ToObject(Value value) + { + if (value == null) { return null; } + else if (value.IsBoolean) { return value.AsBoolean; } + else if (value.IsString) { return value.AsString; } + else if (value.IsNumber) { return value.AsDouble; } + else { return value.AsObject; } + } + + private static ResolutionDetails GetResolutionDetails(Datadog.Trace.FeatureFlags.IEvaluation? evaluation) + { + if (evaluation == null) { return default!; } + var res = new ResolutionDetails( + evaluation.FlagKey, + (T)(evaluation.Value ?? default(T)!), + ToErrorType(evaluation.Reason), + evaluation.Reason.ToString(), + evaluation.Variant, + evaluation.Error, + ToMetadata(evaluation.FlagMetadata!)); + return res; + } + + private static ErrorType ToErrorType(Datadog.Trace.FeatureFlags.EvaluationReason reason) + { + return ErrorType.None; // TODO: Map error types properly + } + + private static ImmutableMetadata ToMetadata(IDictionary metadata) + { + return default!; // TODO: Map metadata properly + } +} diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs deleted file mode 100644 index e10f8a36ef79..000000000000 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DataDogProvider.cs +++ /dev/null @@ -1,108 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Threading; -using System.Threading.Tasks; -using OpenFeature.Constant; -using OpenFeature.Model; - -namespace Samples.OpenFeature_2._9 -{ - internal class DataDogProvider : OpenFeature.FeatureProvider - { - Metadata _metadata = new Metadata("datadog-openfeature-provider"); - public override Metadata? GetMetadata() => _metadata; - - public override Task> ResolveBooleanValueAsync(string flagKey, bool defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) - { - return Task.Run(() => - { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(bool), defaultValue, GetContext(context)); - return GetResolutionDetails(res); - }, - cancellationToken); - } - - public override Task> ResolveDoubleValueAsync(string flagKey, double defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) - { - return Task.Run(() => - { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(double), defaultValue, GetContext(context)); - return GetResolutionDetails(res); - }, - cancellationToken); - } - - public override Task> ResolveIntegerValueAsync(string flagKey, int defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) - { - return Task.Run(() => - { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(int), defaultValue, GetContext(context)); - return GetResolutionDetails(res); - }, - cancellationToken); - } - - public override Task> ResolveStringValueAsync(string flagKey, string defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) - { - return Task.Run(() => - { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(string), defaultValue, GetContext(context)); - return GetResolutionDetails(res); - }, - cancellationToken); - } - - public override Task> ResolveStructureValueAsync(string flagKey, Value defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) - { - return Task.Run(() => - { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(Value), defaultValue, GetContext(context)); - return GetResolutionDetails(res); - }, - cancellationToken); - } - - private static Datadog.Trace.FeatureFlags.IEvaluationContext? GetContext(EvaluationContext? context) - { - if (context == null) { return new Datadog.Trace.FeatureFlags.EvaluationContext(""); } - var values = context.AsDictionary().Select(p => new KeyValuePair(p.Key, ToObject(p.Value))).ToDictionary(p => p.Key, p => p.Value); - var res = new Datadog.Trace.FeatureFlags.EvaluationContext(context.TargetingKey!, values); - return res; - } - - private static object? ToObject(Value value) - { - if (value == null) { return null; } - else if (value.IsBoolean) { return value.AsBoolean; } - else if (value.IsString) { return value.AsString; } - else if (value.IsNumber) { return value.AsDouble; } - else { return value.AsObject; } - } - - private static ResolutionDetails GetResolutionDetails(Datadog.Trace.FeatureFlags.IEvaluation? evaluation) - { - if (evaluation == null) { return default!; } - var res = new ResolutionDetails( - evaluation.FlagKey, - (T)(evaluation.Value ?? default(T)!), - ToErrorType(evaluation.Reason), - evaluation.Reason.ToString(), - evaluation.Variant, - evaluation.Error, - ToMetadata(evaluation.FlagMetadata!) - ); - return res; - } - - private static ErrorType ToErrorType(Datadog.Trace.FeatureFlags.EvaluationReason reason) - { - return ErrorType.None; // TODO: Map error types properly - } - - private static ImmutableMetadata ToMetadata(IDictionary metadata) - { - return default!; // TODO: Map metadata properly - } - } -} diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs index 4604488dbf70..a9885e4a0650 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs @@ -1,6 +1,5 @@ using System; using OpenFeature.Model; -using Samples.OpenFeature_2._9; namespace Samples.OpenFeature_2_9; @@ -12,7 +11,7 @@ private static void Main(string[] args) // See https://aka.ms/new-console-template for more information Console.WriteLine("OpenFeature 2.9 FeatureFlags SDK Sample"); - OpenFeature.Api.Instance.SetProviderAsync(new DataDogProvider()).Wait(); + OpenFeature.Api.Instance.SetProviderAsync(new Datadog.Trace.OpenFeature.DatadogProvider()).Wait(); var client = OpenFeature.Api.Instance.GetClient(); if (!Datadog.Trace.FeatureFlags.FeatureFlagsSdk.IsAvailable()) diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj index 1cc9efbbd7fe..87e56e62f367 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj @@ -12,7 +12,7 @@ - + From bda4fba65f6b1cc93d63a2388158cda4259d6608 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Tue, 16 Dec 2025 19:06:55 +0100 Subject: [PATCH 20/54] Renamed Datadog.Trace.OpenFeature nuget package to Datadog.FeatureFlags.OpenFeature --- Datadog.Trace.sln | 2 +- .../README.md | 16 ++++++++-------- .../Datadog.FeatureFlags.OpenFeature.csproj} | 2 +- .../DatadogProvider.cs | 2 +- .../Samples.OpenFeature-2.9/Program.cs | 2 +- .../Samples.OpenFeature-2.9.csproj | 2 +- 6 files changed, 13 insertions(+), 13 deletions(-) rename docs/{Datadog.Trace.OpenFeature => Datadog.FeatureFlags.OpenFeature}/README.md (81%) rename tracer/src/{Datadog.Trace.OpenFeature/Datadog.Trace.OpenFeature.csproj => Datadog.FeatureFlags.OpenFeature/Datadog.FeatureFlags.OpenFeature.csproj} (93%) rename tracer/src/{Datadog.Trace.OpenFeature => Datadog.FeatureFlags.OpenFeature}/DatadogProvider.cs (99%) diff --git a/Datadog.Trace.sln b/Datadog.Trace.sln index 7c6404960f3f..ca68d466d1f9 100644 --- a/Datadog.Trace.sln +++ b/Datadog.Trace.sln @@ -633,7 +633,7 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.OpenFeature-2.9", " EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Datadog.Trace.Tools.Analyzers.CodeFixes", "tracer\src\Datadog.Trace.Tools.Analyzers.CodeFixes\Datadog.Trace.Tools.Analyzers.CodeFixes.csproj", "{32521F0A-D52D-4DB1-86C4-3D72DEDA6E55}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Datadog.Trace.OpenFeature", "tracer\src\Datadog.Trace.OpenFeature\Datadog.Trace.OpenFeature.csproj", "{E40B79B5-F801-FD8B-901A-0B3CE8B5486C}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Datadog.FeatureFlags.OpenFeature", "tracer\src\Datadog.FeatureFlags.OpenFeature\Datadog.FeatureFlags.OpenFeature.csproj", "{E40B79B5-F801-FD8B-901A-0B3CE8B5486C}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/docs/Datadog.Trace.OpenFeature/README.md b/docs/Datadog.FeatureFlags.OpenFeature/README.md similarity index 81% rename from docs/Datadog.Trace.OpenFeature/README.md rename to docs/Datadog.FeatureFlags.OpenFeature/README.md index d10c82882583..3bbed8b45821 100644 --- a/docs/Datadog.Trace.OpenFeature/README.md +++ b/docs/Datadog.FeatureFlags.OpenFeature/README.md @@ -1,4 +1,4 @@ -# `Datadog.Trace.OpenFeature` NuGet package +# `Datadog.FeatureFlags.OpenFeature` NuGet package This package contains the Datadog .NET OpenFeature SDK @@ -8,26 +8,26 @@ Install this package if: - You intend to use the DataDog *FeatureFlags* tooling in your OpenFeature enabled app -## What does Datadog.Trace.OpenFeature contain? +## What does Datadog.FeatureFlags.OpenFeature contain? -Datadog.Trace.OpenFeature contains three things: +Datadog.FeatureFlags.OpenFeature contains three things: -- The **Datadog.Trace.OpenFeature.dll assembly** with the **DatadogProvider** compatible with **OpenFeature** from **V2.0.0 onwards**. +- The **Datadog.FeatureFlags.OpenFeature.dll assembly** with the **DatadogProvider** compatible with **OpenFeature** from **V2.0.0 onwards**. - A reference to the [Datadog.Trace NuGet package](https://www.nuget.org/packages/Datadog.Trace) for custom instrumentation. - The native binaries required for automatic instrumentation, for the Continuous Profiler, and for ASM. -These native binaries are identical to those installed by the MSI and Linux installer packages, so Datadog.Trace.OpenFeature should be considered an alternative deployment mechanism for automatic instrumentation. +These native binaries are identical to those installed by the MSI and Linux installer packages, so Datadog.FeatureFlags.OpenFeature should be considered an alternative deployment mechanism for automatic instrumentation. -The main advantages of Datadog.Trace.OpenFeature over the MSI or Linux packages are: +The main advantages of Datadog.FeatureFlags.OpenFeature over the MSI or Linux packages are: - You can use it in locations where you cannot access the underlying host to install the MSI or Linux package. - You can have multiple applications on the same host using different versions of Datadog.Trace.Bundle without issue. ## Getting Started 1. Configure the Datadog agent for APM [as described in our documentation](https://docs.datadoghq.com/tracing/setup_overview/setup/dotnet-core#configure-the-datadog-agent-for-apm). -2. Add the [Datadog.Trace.OpenFeature](https://www.nuget.org/packages/Datadog.Trace.OpenFeature) NuGet package to your project, using `dotnet add package Datadog.Trace.OpenFeature`, for example. +2. Add the [Datadog.FeatureFlags.OpenFeature](https://www.nuget.org/packages/Datadog.FeatureFlags.OpenFeature) NuGet package to your project, using `dotnet add package Datadog.FeatureFlags.OpenFeature`, for example. 3. Configure the tracer on the server, as [described below](#configure-the-tracer) -4. Add an instance of the **DatadogProvider** to your **OpenFeature.Api.Instance** using `await OpenFeature.Api.Instance.SetProviderAsync(new Datadog.Trace.OpenFeature.DatadogProvider())` +4. Add an instance of the **DatadogProvider** to your **OpenFeature.Api.Instance** using `await OpenFeature.Api.Instance.SetProviderAsync(new Datadog.FeatureFlags.OpenFeature.DatadogProvider())` ### Configure the environment diff --git a/tracer/src/Datadog.Trace.OpenFeature/Datadog.Trace.OpenFeature.csproj b/tracer/src/Datadog.FeatureFlags.OpenFeature/Datadog.FeatureFlags.OpenFeature.csproj similarity index 93% rename from tracer/src/Datadog.Trace.OpenFeature/Datadog.Trace.OpenFeature.csproj rename to tracer/src/Datadog.FeatureFlags.OpenFeature/Datadog.FeatureFlags.OpenFeature.csproj index caaa21a7ee4b..c16b9c0da1fe 100644 --- a/tracer/src/Datadog.Trace.OpenFeature/Datadog.Trace.OpenFeature.csproj +++ b/tracer/src/Datadog.FeatureFlags.OpenFeature/Datadog.FeatureFlags.OpenFeature.csproj @@ -13,7 +13,7 @@ - + diff --git a/tracer/src/Datadog.Trace.OpenFeature/DatadogProvider.cs b/tracer/src/Datadog.FeatureFlags.OpenFeature/DatadogProvider.cs similarity index 99% rename from tracer/src/Datadog.Trace.OpenFeature/DatadogProvider.cs rename to tracer/src/Datadog.FeatureFlags.OpenFeature/DatadogProvider.cs index 3522134a830c..cd69d6f6cdbb 100644 --- a/tracer/src/Datadog.Trace.OpenFeature/DatadogProvider.cs +++ b/tracer/src/Datadog.FeatureFlags.OpenFeature/DatadogProvider.cs @@ -13,7 +13,7 @@ using OpenFeature.Constant; using OpenFeature.Model; -namespace Datadog.Trace.OpenFeature; +namespace Datadog.FeatureFlags.OpenFeature; /// /// OpenFeature V2.0.0+ Provider for Datadog diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs index a9885e4a0650..942417a435ba 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs @@ -11,7 +11,7 @@ private static void Main(string[] args) // See https://aka.ms/new-console-template for more information Console.WriteLine("OpenFeature 2.9 FeatureFlags SDK Sample"); - OpenFeature.Api.Instance.SetProviderAsync(new Datadog.Trace.OpenFeature.DatadogProvider()).Wait(); + OpenFeature.Api.Instance.SetProviderAsync(new Datadog.FeatureFlags.OpenFeature.DatadogProvider()).Wait(); var client = OpenFeature.Api.Instance.GetClient(); if (!Datadog.Trace.FeatureFlags.FeatureFlagsSdk.IsAvailable()) diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj index 87e56e62f367..66e11109800b 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj @@ -12,7 +12,7 @@ - + From 03264761735a070455e3122e5d24b81133a0774c Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Wed, 17 Dec 2025 10:04:43 +0100 Subject: [PATCH 21/54] PR Comments --- .../FeatureFlags/EvaluationContext.cs | 19 +--- .../FeatureFlags/FeatureFlagsEvaluator.cs | 93 ++++++++++--------- .../FeatureFlags/IEvaluationContext.cs | 11 +-- 3 files changed, 55 insertions(+), 68 deletions(-) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs index fb8b414428c0..ff1f1f00b62a 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs @@ -13,37 +13,26 @@ namespace Datadog.Trace.FeatureFlags /// Estandard implementation of a EvaluationContext /// Targeting Key /// Context optional parameters - /// Context optional convert value function - public class EvaluationContext(string key, IDictionary? values = null, Func? convertValue = null) + public class EvaluationContext(string key, IDictionary? values = null) : IEvaluationContext { - private readonly Func? _convertValue = convertValue; - /// Gets the Context Targeting Key public string TargetingKey { get; } = key; /// Gets the Context optional Values - public IDictionary Values { get; } = values ?? new Dictionary(); + public IDictionary Attributes { get; } = values ?? new Dictionary(); /// Get the Context value if existent /// Value key /// Returns Context Value or null - public object? GetValue(string key) + public object? GetAttribute(string key) { - if (Values is null || !Values.TryGetValue(key, out var res)) + if (Attributes is null || !Attributes.TryGetValue(key, out var res)) { return null; } return res; } - - /// Optional value conversion function - /// Value to convert - /// Converted value - public object? ConvertValue(object? value) - { - return _convertValue?.Invoke(value); - } } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index c87d33659a97..66e5e1545a0f 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -71,7 +71,7 @@ public Evaluation Evaluate(string flagKey, T defaultValue, EvaluationContext return Evaluate(flagKey, typeof(T), defaultValue, context); } - public Evaluation Evaluate(string flagKey, Type resultType, object? defaultValue, IEvaluationContext context) + public Evaluation Evaluate(string flagKey, Type resultType, object? defaultValue, IEvaluationContext? context) { try { @@ -89,29 +89,29 @@ public Evaluation Evaluate(string flagKey, Type resultType, object? defaultValue }); } - if (context == null) + if (string.IsNullOrEmpty(context?.TargetingKey)) { return new Evaluation( flagKey, defaultValue, EvaluationReason.ERROR, - error: "INVALID_CONTEXT", + error: "TARGETING_KEY_MISSING", metadata: new Dictionary { - ["errorCode"] = "INVALID_CONTEXT" + ["errorCode"] = "TARGETING_KEY_MISSING" }); } - if (string.IsNullOrEmpty(context.TargetingKey)) + if (!SupportedResolutionTypes.Contains(resultType)) { return new Evaluation( flagKey, defaultValue, EvaluationReason.ERROR, - error: "TARGETING_KEY_MISSING", + error: "TYPE_MISMATCH", metadata: new Dictionary { - ["errorCode"] = "TARGETING_KEY_MISSING" + ["errorCode"] = "TYPE_MISMATCH" }); } @@ -151,7 +151,7 @@ public Evaluation Evaluate(string flagKey, Type resultType, object? defaultValue } var now = DateTime.UtcNow; - var targetingKey = context.TargetingKey; + var targetingKey = context?.TargetingKey ?? string.Empty; foreach (var allocation in flag.Allocations!) { @@ -249,7 +249,7 @@ private static bool IsAllocationActive(Allocation allocation, DateTime now) return true; } - private static bool EvaluateRules(IEnumerable rules, IEvaluationContext context) + private static bool EvaluateRules(IEnumerable rules, IEvaluationContext? context) { foreach (var rule in rules) { @@ -277,7 +277,7 @@ private static bool EvaluateRules(IEnumerable rules, IEvaluationContext co return false; } - private static bool EvaluateCondition(ConditionConfiguration condition, IEvaluationContext context) + private static bool EvaluateCondition(ConditionConfiguration condition, IEvaluationContext? context) { if (condition.Operator is null) { @@ -467,21 +467,20 @@ private static string GetMd5Hash(string input) return null; } - private static object? ResolveAttribute(string? name, IEvaluationContext context) + private static object? ResolveAttribute(string? name, IEvaluationContext? context) { - if (name == null) + if (name == null || context is null) { return null; } // Special case "id": if not present, use targeting key - if (name == "id" && !context.Values.ContainsKey(name)) + if (name == "id" && !context.Attributes.ContainsKey(name)) { return context.TargetingKey; } - var resolved = context.GetValue(name); - return context.ConvertValue(resolved) ?? resolved; + return context.GetAttribute(name); } internal static object? MapValue(object? value) @@ -576,45 +575,47 @@ private static double ParseDouble(object value) return evaluation.FlagMetadata.TryGetValue("allocationKey", out var key) ? key : null; } - internal static IDictionary FlattenContext(IEvaluationContext context) + internal static IDictionary FlattenContext(IEvaluationContext? context) { - var keys = context.Values.Keys; var result = new Dictionary(); - var seen = new HashSet(); - - foreach (var key in keys) + if (context is not null) { - var stack = new Stack(); - stack.Push(new FlattenEntry(key, context.GetValue(key))); - - while (stack.Count > 0) + var seen = new HashSet(); + var keys = context.Attributes.Keys; + foreach (var key in keys) { - var entry = stack.Pop(); - var value = entry.Value; + var stack = new Stack(); + stack.Push(new FlattenEntry(key, context.GetAttribute(key))); - if (value == null || seen.Add(value)) + while (stack.Count > 0) { - if (value == null) - { - result[entry.Key] = null; - } - else if (value is IList list) + var entry = stack.Pop(); + var value = entry.Value; + + if (value == null || seen.Add(value)) { - for (var i = 0; i < list.Count; i++) + if (value == null) { - stack.Push(new FlattenEntry($"{entry.Key}[{i}]", list[i])); + result[entry.Key] = null; } - } - else if (value is IDictionary dict) - { - foreach (var pairKey in dict.Keys) + else if (value is IList list) { - stack.Push(new FlattenEntry($"{entry.Key}.{pairKey}", dict[pairKey!])); + for (var i = 0; i < list.Count; i++) + { + stack.Push(new FlattenEntry($"{entry.Key}[{i}]", list[i])); + } + } + else if (value is IDictionary dict) + { + foreach (var pairKey in dict.Keys) + { + stack.Push(new FlattenEntry($"{entry.Key}.{pairKey}", dict[pairKey!])); + } + } + else + { + result[entry.Key] = value; } - } - else - { - result[entry.Key] = context.ConvertValue(value) ?? value; } } } @@ -630,7 +631,7 @@ private Evaluation ResolveVariant( Flag flag, string variationKey, Allocation allocation, - IEvaluationContext context) + IEvaluationContext? context) { if (flag.Variations is null || !flag.Variations.TryGetValue(variationKey, out var variant) || variant == null) { @@ -674,7 +675,7 @@ private Evaluation ResolveVariant( private void DispatchExposure( string flagKey, Evaluation evaluation, - IEvaluationContext context) + IEvaluationContext? context) { var allocationKey = AllocationKey(evaluation); var variantKey = evaluation.Variant; @@ -689,7 +690,7 @@ private void DispatchExposure( new Exposure.Model.Allocation(allocationKey), new Exposure.Model.Flag(flagKey), new Exposure.Model.Variant(variantKey), - new Exposure.Model.Subject(context.TargetingKey, FlattenContext(context))); + new Exposure.Model.Subject(context?.TargetingKey ?? string.Empty, FlattenContext(context))); _onExposureEvent?.Invoke(evt); } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs index 21adb64c26e1..6ca092cd1aa5 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs @@ -15,14 +15,11 @@ public partial interface IEvaluationContext /// Gets the tareting key. string TargetingKey { get; } - /// Gets context values. - public IDictionary Values { get; } + /// Gets context attributes. + public IDictionary Attributes { get; } - /// Get the Context value if existent + /// Get the Context attribute if existent /// Value key /// Returns Context Value or null - object? GetValue(string key); - - /// Custom value converter. - object? ConvertValue(object? value); + object? GetAttribute(string key); } From 9dcf85ffea009309aad9475fde5675f08f8d67a0 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Wed, 17 Dec 2025 11:04:51 +0100 Subject: [PATCH 22/54] Fix public api test --- ....Trace.Manual.PublicApiHasNotChanged.verified.txt | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt index b90279176f5c..64c70d55c50a 100644 --- a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt +++ b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt @@ -490,11 +490,10 @@ namespace Datadog.Trace.FeatureFlags { public class EvaluationContext : Datadog.Trace.FeatureFlags.IEvaluationContext { - public EvaluationContext(string key, System.Collections.Generic.IDictionary? values = null, System.Func? convertValue = null) { } + public EvaluationContext(string key, System.Collections.Generic.IDictionary? values = null) { } + public System.Collections.Generic.IDictionary Attributes { get; } public string TargetingKey { get; } - public System.Collections.Generic.IDictionary Values { get; } - public object? ConvertValue(object? value) { } - public object? GetValue(string key) { } + public object? GetAttribute(string key) { } } public enum EvaluationReason { @@ -524,9 +523,8 @@ namespace Datadog.Trace.FeatureFlags } public interface IEvaluationContext { + System.Collections.Generic.IDictionary Attributes { get; } string TargetingKey { get; } - System.Collections.Generic.IDictionary Values { get; } - object? ConvertValue(object? value); - object? GetValue(string key); + object? GetAttribute(string key); } } \ No newline at end of file From 219baa6c0e6ec11651e8650eecfc748edf57ad98 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Wed, 17 Dec 2025 12:38:41 +0100 Subject: [PATCH 23/54] Added support for Json evaluation types --- tracer/build/supported_calltargets.g.json | 2 +- .../DatadogProvider.cs | 10 +- .../Datadog.Trace.Manual.csproj | 8 +- .../FeatureFlags/FeatureFlagsSdk.cs | 2 +- .../FeatureFlagsSdkEvaluateIntegration.cs | 8 +- .../FeatureFlags/EvaluationType.cs | 27 + .../FeatureFlags/FeatureFlagsEvaluator.cs | 66 +- .../FeatureFlags/FeatureFlagsModule.cs | 2 +- .../Generated/generated_calltargets.g.cpp | 1551 +++++++++-------- .../FeatureFlagsEvaluatorTests.Bundle.cs | 47 +- .../FeatureFlagsEvaluatorTests.cs | 32 +- .../Samples.FeatureFlags/Program.cs | 2 +- 12 files changed, 895 insertions(+), 862 deletions(-) create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/EvaluationType.cs diff --git a/tracer/build/supported_calltargets.g.json b/tracer/build/supported_calltargets.g.json index f91d394b9dca..55ab81dbce82 100644 --- a/tracer/build/supported_calltargets.g.json +++ b/tracer/build/supported_calltargets.g.json @@ -6690,7 +6690,7 @@ "TargetReturnType": "Datadog.Trace.FeatureFlags.IEvaluation", "TargetParameterTypes": [ "System.String", - "System.Type", + "Datadog.Trace.FeatureFlags.EvaluationType", "System.Object", "Datadog.Trace.FeatureFlags.IEvaluationContext" ], diff --git a/tracer/src/Datadog.FeatureFlags.OpenFeature/DatadogProvider.cs b/tracer/src/Datadog.FeatureFlags.OpenFeature/DatadogProvider.cs index cd69d6f6cdbb..2b61b151c396 100644 --- a/tracer/src/Datadog.FeatureFlags.OpenFeature/DatadogProvider.cs +++ b/tracer/src/Datadog.FeatureFlags.OpenFeature/DatadogProvider.cs @@ -37,7 +37,7 @@ public override Task> ResolveBooleanValueAsync(string fl return Task.Run( () => { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(bool), defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.EvaluationType.BOOLEAN, defaultValue, GetContext(context)); return GetResolutionDetails(res); }, cancellationToken); @@ -54,7 +54,7 @@ public override Task> ResolveDoubleValueAsync(string f return Task.Run( () => { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(double), defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.EvaluationType.NUMERIC, defaultValue, GetContext(context)); return GetResolutionDetails(res); }, cancellationToken); @@ -71,7 +71,7 @@ public override Task> ResolveIntegerValueAsync(string fla return Task.Run( () => { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(int), defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.EvaluationType.INTEGER, defaultValue, GetContext(context)); return GetResolutionDetails(res); }, cancellationToken); @@ -88,7 +88,7 @@ public override Task> ResolveStringValueAsync(string f return Task.Run( () => { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(string), defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.EvaluationType.STRING, defaultValue, GetContext(context)); return GetResolutionDetails(res); }, cancellationToken); @@ -105,7 +105,7 @@ public override Task> ResolveStructureValueAsync(string return Task.Run( () => { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, typeof(Value), defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.EvaluationType.JSON, defaultValue, GetContext(context)); return GetResolutionDetails(res); }, cancellationToken); diff --git a/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj b/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj index a189c2dbd734..1701063f5159 100644 --- a/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj +++ b/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj @@ -24,13 +24,13 @@ - - - + + + + diff --git a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs index 0b01a200ab05..f6dbad0f620b 100644 --- a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs +++ b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs @@ -39,7 +39,7 @@ public static void RegisterOnNewConfigEventHandler(Action onNewConfig) /// The evaluation context [Instrumented] [MethodImpl(MethodImplOptions.NoInlining)] - public static IEvaluation? Evaluate(string key, Type targetType, object? defaultValue, IEvaluationContext? context) + public static IEvaluation? Evaluate(string key, EvaluationType targetType, object? defaultValue, IEvaluationContext? context) { return null; } diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs index 8426a240bc9d..4a194a1ae8ec 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs @@ -23,7 +23,7 @@ namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual; TypeName = "Datadog.Trace.FeatureFlags.FeatureFlagsSdk", MethodName = "Evaluate", ReturnTypeName = "Datadog.Trace.FeatureFlags.IEvaluation", - ParameterTypeNames = [ClrNames.String, ClrNames.Type, ClrNames.Object, "Datadog.Trace.FeatureFlags.IEvaluationContext"], + ParameterTypeNames = [ClrNames.String, "Datadog.Trace.FeatureFlags.EvaluationType", ClrNames.Object, "Datadog.Trace.FeatureFlags.IEvaluationContext"], MinimumVersion = "3.31.0", MaximumVersion = "3.*.*", IntegrationName = nameof(IntegrationId.DatadogTraceManual))] @@ -31,9 +31,9 @@ namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual; [EditorBrowsable(EditorBrowsableState.Never)] public class FeatureFlagsSdkEvaluateIntegration { - internal static CallTargetState OnMethodBegin(ref string key, ref Type targetType, ref object? defaultValue, ref TContext? context) + internal static CallTargetState OnMethodBegin(ref string? key, ref TTargetType targetType, ref object? defaultValue, ref TContext? context) { - return new CallTargetState(null, new State(key, targetType, defaultValue, context)); + return new CallTargetState(null, new State(key, (EvaluationType)(Convert.ToInt32(targetType)), defaultValue, context)); } internal static CallTargetReturn OnMethodEnd(TReturn? returnValue, Exception? exception, in CallTargetState state) @@ -43,7 +43,7 @@ internal static CallTargetState OnMethodBegin(ref string key, return new CallTargetReturn(res.DuckCast()); } - private record struct State(string? Key, Type TargetType, object? DefaultValue, object? Context) + private record struct State(string? Key, EvaluationType TargetType, object? DefaultValue, object? Context) { } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationType.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationType.cs new file mode 100644 index 000000000000..06e2e4b65845 --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationType.cs @@ -0,0 +1,27 @@ +// +// 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 + +namespace Datadog.Trace.FeatureFlags; + +/// Evaluation result reason +public enum EvaluationType +{ + /// Integer numeric value + INTEGER, + + /// Float numeric value + NUMERIC, + + /// Simple string + STRING, + + /// Bool value + BOOLEAN, + + /// Json string value + JSON +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index 66e5e1545a0f..d4c122dd0939 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -6,6 +6,7 @@ #nullable enable using System; +using System.CodeDom; using System.Collections; using System.Collections.Generic; using System.Globalization; @@ -14,8 +15,12 @@ using System.Security.Cryptography; using System.Text; using System.Text.RegularExpressions; +using Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SDK; +using Datadog.Trace.Debugger.Expressions; using Datadog.Trace.FeatureFlags.Rcm.Model; using Datadog.Trace.Logging; +using Datadog.Trace.Vendors.Newtonsoft.Json; +using Datadog.Trace.Vendors.Newtonsoft.Json.Linq; namespace Datadog.Trace.FeatureFlags { @@ -35,16 +40,6 @@ internal class FeatureFlagsEvaluator "MM-dd-yyyy'T'HH:mm:ss'Z'", }; - private static readonly HashSet SupportedResolutionTypes = - new() - { - typeof(string), - typeof(bool), - typeof(int), - typeof(long), - typeof(double), - }; - private readonly Action? _onExposureEvent; private readonly ServerConfiguration? _config; private readonly long _timeoutMs; @@ -66,12 +61,7 @@ public FeatureFlagsEvaluator(Action? onExposureEve private delegate bool NumberEquality(double a, double b); - public Evaluation Evaluate(string flagKey, T defaultValue, EvaluationContext context) - { - return Evaluate(flagKey, typeof(T), defaultValue, context); - } - - public Evaluation Evaluate(string flagKey, Type resultType, object? defaultValue, IEvaluationContext? context) + public Evaluation Evaluate(string flagKey, EvaluationType resultType, object? defaultValue, IEvaluationContext? context) { try { @@ -102,6 +92,7 @@ public Evaluation Evaluate(string flagKey, Type resultType, object? defaultValue }); } +/* if (!SupportedResolutionTypes.Contains(resultType)) { return new Evaluation( @@ -114,6 +105,7 @@ public Evaluation Evaluate(string flagKey, Type resultType, object? defaultValue ["errorCode"] = "TYPE_MISMATCH" }); } +*/ if (config.Flags is null || !config.Flags.TryGetValue(flagKey, out var flag) || flag is null) { @@ -483,34 +475,19 @@ private static string GetMd5Hash(string input) return context.GetAttribute(name); } - internal static object? MapValue(object? value) - { - return MapValue(typeof(T), value); - } - - internal static object? MapValue(Type target, object? value) + internal static object? MapValue(EvaluationType target, object? value) { if (value is null) { return default!; } - if (!SupportedResolutionTypes.Contains(target)) - { - throw new ArgumentException($"Type not supported: {target}"); - } - - if (target.IsInstanceOfType(value)) - { - return Convert.ChangeType(value, target); - } - - if (target == typeof(string)) + if (target == EvaluationType.STRING) { return Convert.ToString(value, CultureInfo.InvariantCulture); } - if (target == typeof(bool)) + if (target == EvaluationType.BOOLEAN) { if (value is IConvertible) { @@ -525,25 +502,30 @@ private static string GetMd5Hash(string input) return bool.Parse(value.ToString()!); } - if (target == typeof(int)) + if (target == EvaluationType.INTEGER) { var number = ParseDouble(value); return (int)number; } - if (target == typeof(long)) + if (target == EvaluationType.NUMERIC) { var number = ParseDouble(value); - return (long)number; + return (double)number; } - if (target == typeof(double)) + if (target == EvaluationType.JSON) { - var number = ParseDouble(value); - return (double)number; + if (value is JObject) + { + return value.ToString(); + } + + var json = JsonConvert.SerializeObject(value); + return json; } - return default!; + throw new ArgumentException($"Type not supported: {target}"); } private static double ParseDouble(object value) @@ -626,7 +608,7 @@ private static double ParseDouble(object value) private Evaluation ResolveVariant( string flagKey, - Type resultType, + EvaluationType resultType, object? defaultValue, Flag flag, string variationKey, diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index 9fa6650b75a1..f10b990dd9ca 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -99,7 +99,7 @@ internal void RegisterOnNewConfigEventHandler(Action? onNewConfig) _onNewConfigEventHander = onNewConfig; } - internal Evaluation Evaluate(string flagKey, Type resultType, object? defaultValue, IEvaluationContext context) + internal Evaluation Evaluate(string flagKey, EvaluationType resultType, object? defaultValue, IEvaluationContext context) { if (!_enabled) { diff --git a/tracer/src/Datadog.Tracer.Native/Generated/generated_calltargets.g.cpp b/tracer/src/Datadog.Tracer.Native/Generated/generated_calltargets.g.cpp index 9b84733f54f9..77e32ea5992a 100644 --- a/tracer/src/Datadog.Tracer.Native/Generated/generated_calltargets.g.cpp +++ b/tracer/src/Datadog.Tracer.Native/Generated/generated_calltargets.g.cpp @@ -76,209 +76,209 @@ WCHAR* sig057[]={(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationS WCHAR* sig058[]={(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettings"),(WCHAR*)WStr("System.String"),}; WCHAR* sig059[]={(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettingsCollection"),}; WCHAR* sig060[]={(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),}; -WCHAR* sig061[]={(WCHAR*)WStr("Datadog.Trace.IScope"),}; -WCHAR* sig062[]={(WCHAR*)WStr("Datadog.Trace.IScope"),(WCHAR*)WStr("System.String"),}; -WCHAR* sig063[]={(WCHAR*)WStr("Datadog.Trace.IScope"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.ISpanContext"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Nullable`1[System.DateTimeOffset]"),(WCHAR*)WStr("System.Nullable`1[System.Boolean]"),}; -WCHAR* sig064[]={(WCHAR*)WStr("Datadog.Trace.IScope"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.SpanCreationSettings"),}; -WCHAR* sig065[]={(WCHAR*)WStr("Datadog.Trace.ISpan"),(WCHAR*)WStr("Datadog.Trace.ISpan"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Nullable`1[System.Double]"),}; -WCHAR* sig066[]={(WCHAR*)WStr("Datadog.Trace.ISpan"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.ISpanContext"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Nullable`1[System.DateTimeOffset]"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig067[]={(WCHAR*)WStr("Datadog.Trace.ISpanContext"),(WCHAR*)WStr("!!0"),(WCHAR*)WStr("System.Func`3[!!0,System.String,System.Collections.Generic.IEnumerable`1[System.String]]"),}; -WCHAR* sig068[]={(WCHAR*)WStr("Datadog.Trace.ISpanContext"),(WCHAR*)WStr("!!0"),(WCHAR*)WStr("System.Func`3[!!0,System.String,System.Collections.Generic.IEnumerable`1[System.String]]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),}; -WCHAR* sig069[]={(WCHAR*)WStr("Elasticsearch.Net.ElasticsearchResponse`1[!0]"),(WCHAR*)WStr("Elasticsearch.Net.RequestData"),}; -WCHAR* sig070[]={(WCHAR*)WStr("GraphQL.Validation.IValidationResult"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("GraphQL.Types.ISchema"),(WCHAR*)WStr("GraphQL.Language.AST.Document"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[GraphQL.Validation.IValidationRule]"),(WCHAR*)WStr("_"),(WCHAR*)WStr("GraphQL.Inputs"),}; -WCHAR* sig071[]={(WCHAR*)WStr("Grpc.Core.CallInvocationDetails`2[!!0,!!1]"),(WCHAR*)WStr("Grpc.Core.Method`2[!!0,!!1]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Grpc.Core.CallOptions"),}; -WCHAR* sig072[]={(WCHAR*)WStr("Grpc.Core.Internal.MetadataArraySafeHandle"),(WCHAR*)WStr("Grpc.Core.Metadata"),}; -WCHAR* sig073[]={(WCHAR*)WStr("log4net.Appender.IAppender[]"),}; -WCHAR* sig074[]={(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),}; -WCHAR* sig075[]={(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.DirectoryBrowserOptions"),}; -WCHAR* sig076[]={(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.PathString"),(WCHAR*)WStr("System.Action`1[Microsoft.AspNetCore.Builder.IApplicationBuilder]"),}; -WCHAR* sig077[]={(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.PathString"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Action`1[Microsoft.AspNetCore.Builder.IApplicationBuilder]"),}; -WCHAR* sig078[]={(WCHAR*)WStr("Microsoft.AspNetCore.Http.RequestDelegate"),}; -WCHAR* sig079[]={(WCHAR*)WStr("Microsoft.Azure.Cosmos.FeedIterator`1"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.QueryDefinition"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.QueryRequestOptions"),}; -WCHAR* sig080[]={(WCHAR*)WStr("Microsoft.Azure.Cosmos.FeedIterator`1"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.QueryRequestOptions"),}; -WCHAR* sig081[]={(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),}; -WCHAR* sig082[]={(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; -WCHAR* sig083[]={(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),}; -WCHAR* sig084[]={(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; -WCHAR* sig085[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.RunCleanupResult"),}; -WCHAR* sig086[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodInfo"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.TestMethod"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.Interface.ITestContext"),}; -WCHAR* sig087[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodInfo"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.TestMethod"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.Interface.ITestContext"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig088[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.UnitTestResult[]"),}; -WCHAR* sig089[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.UnitTestResult[]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.TestMethod"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; -WCHAR* sig090[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestResult"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.ITestMethod"),}; -WCHAR* sig091[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestResult[]"),}; -WCHAR* sig092[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestResult[]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodInfo"),}; -WCHAR* sig093[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestResult[]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.TestMethod"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging.IMessageLogger"),}; -WCHAR* sig094[]={(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),}; -WCHAR* sig095[]={(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; -WCHAR* sig096[]={(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),}; -WCHAR* sig097[]={(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; -WCHAR* sig098[]={(WCHAR*)WStr("NLog.Config.LoggingConfiguration"),(WCHAR*)WStr("NLog.LogFactory"),(WCHAR*)WStr("System.String"),}; -WCHAR* sig099[]={(WCHAR*)WStr("NLog.Internal.TargetWithFilterChain[]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.List`1[NLog.Config.LoggingRule]"),}; -WCHAR* sig100[]={(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),}; -WCHAR* sig101[]={(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; -WCHAR* sig102[]={(WCHAR*)WStr("NUnit.Framework.Internal.Commands.SkipCommand"),(WCHAR*)WStr("NUnit.Framework.Internal.Test"),}; -WCHAR* sig103[]={(WCHAR*)WStr("NUnit.Framework.Internal.Commands.TestCommand"),}; -WCHAR* sig104[]={(WCHAR*)WStr("NUnit.Framework.Internal.Commands.TestCommand"),(WCHAR*)WStr("NUnit.Framework.Internal.TestMethod"),}; -WCHAR* sig105[]={(WCHAR*)WStr("OpenQA.Selenium.Remote.Response"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.Dictionary`2[System.String,System.Object]"),}; -WCHAR* sig106[]={(WCHAR*)WStr("OpenQA.Selenium.Response"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.Dictionary`2[System.String,System.Object]"),}; -WCHAR* sig107[]={(WCHAR*)WStr("OpenTelemetry.Trace.TelemetrySpan"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("OpenTelemetry.Trace.SpanKind"),(WCHAR*)WStr("OpenTelemetry.Trace.SpanAttributes"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[OpenTelemetry.Trace.Link]"),(WCHAR*)WStr("System.DateTimeOffset"),}; -WCHAR* sig108[]={(WCHAR*)WStr("OpenTelemetry.Trace.TelemetrySpan"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("OpenTelemetry.Trace.SpanKind"),(WCHAR*)WStr("OpenTelemetry.Trace.SpanContext&"),(WCHAR*)WStr("OpenTelemetry.Trace.SpanAttributes"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[OpenTelemetry.Trace.Link]"),(WCHAR*)WStr("System.DateTimeOffset"),}; -WCHAR* sig109[]={(WCHAR*)WStr("OpenTelemetry.Trace.TracerProvider"),(WCHAR*)WStr("OpenTelemetry.Trace.TracerProviderBuilder"),}; -WCHAR* sig110[]={(WCHAR*)WStr("OpenTracing.ITracer"),(WCHAR*)WStr("Datadog.Trace.Tracer"),}; -WCHAR* sig111[]={(WCHAR*)WStr("OpenTracing.ITracer"),(WCHAR*)WStr("System.Uri"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig112[]={(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),}; -WCHAR* sig113[]={(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; -WCHAR* sig114[]={(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),}; -WCHAR* sig115[]={(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; -WCHAR* sig116[]={(WCHAR*)WStr("RabbitMQ.Client.BasicGetResult"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig117[]={(WCHAR*)WStr("RabbitMQ.Client.BasicProperties"),(WCHAR*)WStr("!!0"),(WCHAR*)WStr("System.Diagnostics.Activity"),(WCHAR*)WStr("System.UInt64"),}; -WCHAR* sig118[]={(WCHAR*)WStr("Serilog.Core.Logger"),}; -WCHAR* sig119[]={(WCHAR*)WStr("StackExchange.Redis.ServerEndPoint"),(WCHAR*)WStr("StackExchange.Redis.Message"),}; -WCHAR* sig120[]={(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig121[]={(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Azure.Messaging.EventHubs.EventData"),}; -WCHAR* sig122[]={(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusMessage"),}; -WCHAR* sig123[]={(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.IAsyncResult"),}; -WCHAR* sig124[]={(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.ServiceModel.Channels.RequestContext"),(WCHAR*)WStr("System.ServiceModel.OperationContext"),}; -WCHAR* sig125[]={(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Xunit.Abstractions.ITestCase"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Xunit.Sdk.IMessageBus"),}; -WCHAR* sig126[]={(WCHAR*)WStr("System.Byte[]"),(WCHAR*)WStr("System.Byte[]"),}; -WCHAR* sig127[]={(WCHAR*)WStr("System.Byte[]"),(WCHAR*)WStr("System.Byte[]"),(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("System.Int32"),}; -WCHAR* sig128[]={(WCHAR*)WStr("System.Byte[]"),(WCHAR*)WStr("System.IO.Stream"),}; -WCHAR* sig129[]={(WCHAR*)WStr("System.Collections.Generic.HashSet`1[System.String]"),}; -WCHAR* sig130[]={(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Object&"),}; -WCHAR* sig131[]={(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; -WCHAR* sig132[]={(WCHAR*)WStr("System.Collections.Generic.IList`1[Confluent.Kafka.TopicPartitionOffset]"),}; -WCHAR* sig133[]={(WCHAR*)WStr("System.Collections.Generic.IReadOnlyDictionary`2[System.String,System.String]"),}; -WCHAR* sig134[]={(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; -WCHAR* sig135[]={(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),}; -WCHAR* sig136[]={(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; -WCHAR* sig137[]={(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),}; -WCHAR* sig138[]={(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; -WCHAR* sig139[]={(WCHAR*)WStr("System.Diagnostics.Process"),}; -WCHAR* sig140[]={(WCHAR*)WStr("System.Diagnostics.Process"),(WCHAR*)WStr("System.Diagnostics.ProcessStartInfo"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig141[]={(WCHAR*)WStr("System.Double"),}; -WCHAR* sig142[]={(WCHAR*)WStr("System.IAsyncResult"),(WCHAR*)WStr("System.AsyncCallback"),(WCHAR*)WStr("System.Object"),}; -WCHAR* sig143[]={(WCHAR*)WStr("System.IAsyncResult"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Object[]"),(WCHAR*)WStr("System.AsyncCallback"),(WCHAR*)WStr("System.Object"),}; -WCHAR* sig144[]={(WCHAR*)WStr("System.IAsyncResult"),(WCHAR*)WStr("System.Web.Mvc.ControllerContext"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.AsyncCallback"),(WCHAR*)WStr("System.Object"),}; -WCHAR* sig145[]={(WCHAR*)WStr("System.Int32"),}; -WCHAR* sig146[]={(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("log4net.Core.LoggingEvent"),}; -WCHAR* sig147[]={(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; -WCHAR* sig148[]={(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("System.String[]"),}; -WCHAR* sig149[]={(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("System.String[]"),(WCHAR*)WStr("System.Collections.Generic.List`1[Microsoft.VisualStudio.TestPlatform.CommandLine.Processors.IArgumentProcessor]&"),}; -WCHAR* sig150[]={(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("_"),}; -WCHAR* sig151[]={(WCHAR*)WStr("System.IO.Stream"),}; -WCHAR* sig152[]={(WCHAR*)WStr("System.Messaging.Message"),(WCHAR*)WStr("System.TimeSpan"),(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("System.Messaging.Interop.CursorHandle"),(WCHAR*)WStr("System.Messaging.MessagePropertyFilter"),(WCHAR*)WStr("System.Messaging.MessageQueueTransaction"),(WCHAR*)WStr("System.Messaging.MessageQueueTransactionType"),}; -WCHAR* sig153[]={(WCHAR*)WStr("System.Net.Http.HttpResponseMessage"),(WCHAR*)WStr("System.Net.Http.HttpRequestMessage"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig154[]={(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders"),(WCHAR*)WStr("System.IO.Stream"),}; -WCHAR* sig155[]={(WCHAR*)WStr("System.Net.WebResponse"),}; -WCHAR* sig156[]={(WCHAR*)WStr("System.Net.WebResponse"),(WCHAR*)WStr("System.IAsyncResult"),}; -WCHAR* sig157[]={(WCHAR*)WStr("System.Nullable`1[System.Boolean]"),}; -WCHAR* sig158[]={(WCHAR*)WStr("System.Nullable`1[System.Double]"),}; -WCHAR* sig159[]={(WCHAR*)WStr("System.Object"),}; -WCHAR* sig160[]={(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; -WCHAR* sig161[]={(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Int32"),}; -WCHAR* sig162[]={(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Object[]"),(WCHAR*)WStr("System.Object[]&"),}; -WCHAR* sig163[]={(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Object[]&"),(WCHAR*)WStr("System.IAsyncResult"),}; -WCHAR* sig164[]={(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Reflection.MethodInfo"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Object[]"),}; -WCHAR* sig165[]={(WCHAR*)WStr("System.Runtime.Remoting.Channels.ServerProcessing"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.IServerChannelSinkStack"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders"),(WCHAR*)WStr("System.IO.Stream"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage&"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; -WCHAR* sig166[]={(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),}; -WCHAR* sig167[]={(WCHAR*)WStr("System.String"),}; -WCHAR* sig168[]={(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Int32"),}; -WCHAR* sig169[]={(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.ReadOnlySpan`1[System.Byte]&"),(WCHAR*)WStr("Google.Protobuf.ParserInternalState&"),(WCHAR*)WStr("System.Int32"),}; -WCHAR* sig170[]={(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),}; -WCHAR* sig171[]={(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("RabbitMQ.Client.IBasicConsumer"),}; -WCHAR* sig172[]={(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Text.Encoding"),}; -WCHAR* sig173[]={(WCHAR*)WStr("System.String"),(WCHAR*)WStr("_"),}; -WCHAR* sig174[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),}; -WCHAR* sig175[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Azure.Messaging.EventHubs.Producer.EventDataBatch"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig176[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusMessageBatch"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig177[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusReceivedMessage"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig178[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Couchbase.Core.IO.Connections.IConnection"),(WCHAR*)WStr("Couchbase.Core.IO.Operations.IOperation"),(WCHAR*)WStr("Couchbase.Core.IO.Operations.CancellationTokenPair"),}; -WCHAR* sig179[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Couchbase.Core.IO.Connections.IConnection"),(WCHAR*)WStr("Couchbase.Core.IO.Operations.IOperation"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig180[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Couchbase.Core.IO.Operations.IOperation"),(WCHAR*)WStr("Couchbase.Core.IO.Operations.CancellationTokenPair"),}; -WCHAR* sig181[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Couchbase.Core.IO.Operations.IOperation"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig182[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Couchbase.Core.IO.Operations.IOperation"),(WCHAR*)WStr("System.Threading.CancellationToken"),(WCHAR*)WStr("System.TimeSpan"),}; -WCHAR* sig183[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Couchbase.IO.Operations.IOperation"),}; -WCHAR* sig184[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Couchbase.IO.Operations.IOperation`1[!!0]"),}; -WCHAR* sig185[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Couchbase.IO.Operations.IOperation`1[!!0]"),(WCHAR*)WStr("Couchbase.IO.IConnection"),}; -WCHAR* sig186[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Grpc.Core.Internal.ServerRpcNew"),(WCHAR*)WStr("Grpc.Core.Internal.CompletionQueueSafeHandle"),}; -WCHAR* sig187[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Grpc.Core.Metadata"),}; -WCHAR* sig188[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Grpc.Core.Status"),(WCHAR*)WStr("Grpc.Core.Metadata"),(WCHAR*)WStr("System.Nullable`1[ResponseWithFlags[!0,!1]]"),}; -WCHAR* sig189[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics.ErrorContext"),}; -WCHAR* sig190[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Microsoft.AspNetCore.Hosting.Server.IHttpApplication`1[!!0]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig191[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.HttpContext"),}; -WCHAR* sig192[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.HttpContext"),(WCHAR*)WStr("System.Exception"),}; -WCHAR* sig193[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.HttpContext"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Security.Claims.ClaimsPrincipal"),(WCHAR*)WStr("Microsoft.AspNetCore.Authentication.AuthenticationProperties"),}; -WCHAR* sig194[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Microsoft.Azure.Functions.Worker.FunctionContext"),}; -WCHAR* sig195[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("MongoDB.Driver.Core.Connections.IConnection"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig196[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig197[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Azure.Messaging.EventHubs.EventData]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig198[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Azure.Messaging.ServiceBus.ServiceBusMessage]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig199[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.IO.Stream"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig200[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.Net.Http.HttpRequestMessage"),(WCHAR*)WStr("System.Nullable`1[System.TimeSpan]"),}; -WCHAR* sig201[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.Security.Claims.ClaimsPrincipal"),}; -WCHAR* sig202[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig203[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig204[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.UInt64"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("RabbitMQ.Client.IBasicProperties"),(WCHAR*)WStr("_"),}; -WCHAR* sig205[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.UInt64"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("RabbitMQ.Client.IReadOnlyBasicProperties"),(WCHAR*)WStr("System.ReadOnlyMemory`1[System.Byte]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig206[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("_"),}; -WCHAR* sig207[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1"),(WCHAR*)WStr("StackExchange.Redis.Message"),(WCHAR*)WStr("StackExchange.Redis.ResultProcessor`1[!!0]"),(WCHAR*)WStr("!!0"),(WCHAR*)WStr("StackExchange.Redis.ServerEndPoint"),}; -WCHAR* sig208[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1"),(WCHAR*)WStr("StackExchange.Redis.Message"),(WCHAR*)WStr("StackExchange.Redis.ResultProcessor`1[!!0]"),(WCHAR*)WStr("StackExchange.Redis.ServerEndPoint"),}; -WCHAR* sig209[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1"),(WCHAR*)WStr("GraphQL.Execution.ExecutionContext"),}; -WCHAR* sig210[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1"),}; -WCHAR* sig211[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!!0]"),(WCHAR*)WStr("StackExchange.Redis.Message"),(WCHAR*)WStr("StackExchange.Redis.ResultProcessor`1[!!0]"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("StackExchange.Redis.ServerEndPoint"),}; -WCHAR* sig212[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!!0]"),(WCHAR*)WStr("StackExchange.Redis.Message"),(WCHAR*)WStr("StackExchange.Redis.ResultProcessor`1[!!0]"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("StackExchange.Redis.ServerEndPoint"),(WCHAR*)WStr("!!0"),}; -WCHAR* sig213[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!0]"),(WCHAR*)WStr("Amazon.Runtime.IExecutionContext"),}; -WCHAR* sig214[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!0]"),(WCHAR*)WStr("Elasticsearch.Net.HttpMethod"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Threading.CancellationToken"),(WCHAR*)WStr("Elasticsearch.Net.PostData"),(WCHAR*)WStr("Elasticsearch.Net.IRequestParameters"),}; -WCHAR* sig215[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!0]"),(WCHAR*)WStr("Elasticsearch.Net.RequestData"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig216[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!0]"),(WCHAR*)WStr("GraphQL.Types.ISchema"),(WCHAR*)WStr("GraphQL.Language.AST.Document"),(WCHAR*)WStr("GraphQL.Language.AST.VariableDefinitions"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[GraphQL.Validation.IValidationRule]"),(WCHAR*)WStr("_"),(WCHAR*)WStr("GraphQL.Inputs"),}; -WCHAR* sig217[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!0]"),(WCHAR*)WStr("GraphQL.Validation.ValidationContext"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[GraphQL.Validation.IValidationRule]"),}; -WCHAR* sig218[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!0]"),(WCHAR*)WStr("MongoDB.Driver.Core.Connections.IConnection"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig219[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!0]"),(WCHAR*)WStr("MongoDB.Driver.OperationContext"),(WCHAR*)WStr("MongoDB.Driver.Core.Connections.IConnection"),}; -WCHAR* sig220[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!0]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("GraphQL.Types.ISchema"),(WCHAR*)WStr("GraphQL.Language.AST.Document"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[GraphQL.Validation.IValidationRule]"),(WCHAR*)WStr("_"),(WCHAR*)WStr("GraphQL.Inputs"),}; -WCHAR* sig221[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.DynamoDBv2.Model.BatchGetItemResponse]"),(WCHAR*)WStr("Amazon.DynamoDBv2.Model.BatchGetItemRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig222[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.DynamoDBv2.Model.BatchWriteItemResponse]"),(WCHAR*)WStr("Amazon.DynamoDBv2.Model.BatchWriteItemRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig223[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.DynamoDBv2.Model.DeleteItemResponse]"),(WCHAR*)WStr("Amazon.DynamoDBv2.Model.DeleteItemRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig224[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.DynamoDBv2.Model.GetItemResponse]"),(WCHAR*)WStr("Amazon.DynamoDBv2.Model.GetItemRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig225[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.DynamoDBv2.Model.PutItemResponse]"),(WCHAR*)WStr("Amazon.DynamoDBv2.Model.PutItemRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig226[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.DynamoDBv2.Model.ScanResponse]"),(WCHAR*)WStr("Amazon.DynamoDBv2.Model.ScanRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig227[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.DynamoDBv2.Model.UpdateItemResponse]"),(WCHAR*)WStr("Amazon.DynamoDBv2.Model.UpdateItemRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig228[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.EventBridge.Model.PutEventsResponse]"),(WCHAR*)WStr("Amazon.EventBridge.Model.PutEventsRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig229[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.Kinesis.Model.GetRecordsResponse]"),(WCHAR*)WStr("Amazon.Kinesis.Model.GetRecordsRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig230[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.Kinesis.Model.PutRecordResponse]"),(WCHAR*)WStr("Amazon.Kinesis.Model.PutRecordRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig231[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.Kinesis.Model.PutRecordsResponse]"),(WCHAR*)WStr("Amazon.Kinesis.Model.PutRecordsRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig232[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.CompleteMultipartUploadResponse]"),(WCHAR*)WStr("Amazon.S3.Model.CompleteMultipartUploadRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig233[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.CopyObjectResponse]"),(WCHAR*)WStr("Amazon.S3.Model.CopyObjectRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig234[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.DeleteBucketResponse]"),(WCHAR*)WStr("Amazon.S3.Model.DeleteBucketRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig235[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.DeleteObjectResponse]"),(WCHAR*)WStr("Amazon.S3.Model.DeleteObjectRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig236[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.DeleteObjectsResponse]"),(WCHAR*)WStr("Amazon.S3.Model.DeleteObjectsRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig237[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.GetObjectResponse]"),(WCHAR*)WStr("Amazon.S3.Model.GetObjectRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig238[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.InitiateMultipartUploadResponse]"),(WCHAR*)WStr("Amazon.S3.Model.InitiateMultipartUploadRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig239[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.ListBucketsResponse]"),(WCHAR*)WStr("Amazon.S3.Model.ListBucketsRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig240[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.ListObjectsV2Response]"),(WCHAR*)WStr("Amazon.S3.Model.ListObjectsV2Request"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig241[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.PutBucketResponse]"),(WCHAR*)WStr("Amazon.S3.Model.PutBucketRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig242[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.PutObjectResponse]"),(WCHAR*)WStr("Amazon.S3.Model.PutObjectRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig243[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.UploadPartResponse]"),(WCHAR*)WStr("Amazon.S3.Model.UploadPartRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig244[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SimpleNotificationService.Model.PublishBatchResponse]"),(WCHAR*)WStr("Amazon.SimpleNotificationService.Model.PublishBatchRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig245[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SimpleNotificationService.Model.PublishResponse]"),(WCHAR*)WStr("Amazon.SimpleNotificationService.Model.PublishRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig246[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SQS.Model.CreateQueueResponse]"),(WCHAR*)WStr("Amazon.SQS.Model.CreateQueueRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig247[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SQS.Model.DeleteMessageBatchResponse]"),(WCHAR*)WStr("Amazon.SQS.Model.DeleteMessageBatchRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig248[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SQS.Model.DeleteMessageResponse]"),(WCHAR*)WStr("Amazon.SQS.Model.DeleteMessageRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig249[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SQS.Model.DeleteQueueResponse]"),(WCHAR*)WStr("Amazon.SQS.Model.DeleteQueueRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig250[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SQS.Model.ReceiveMessageResponse]"),(WCHAR*)WStr("Amazon.SQS.Model.ReceiveMessageRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig251[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SQS.Model.SendMessageBatchResponse]"),(WCHAR*)WStr("Amazon.SQS.Model.SendMessageBatchRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig252[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SQS.Model.SendMessageResponse]"),(WCHAR*)WStr("Amazon.SQS.Model.SendMessageRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig253[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Confluent.Kafka.DeliveryReport`2[!0,!1]]"),(WCHAR*)WStr("Confluent.Kafka.TopicPartition"),(WCHAR*)WStr("Confluent.Kafka.Message`2[!0,!1]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig254[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Elasticsearch.Net.ElasticsearchResponse`1[!0]]"),(WCHAR*)WStr("Elasticsearch.Net.RequestData"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig255[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[HotChocolate.Execution.IExecutionResult]"),(WCHAR*)WStr("HotChocolate.Execution.IOperationRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig256[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[HotChocolate.Execution.IExecutionResult]"),(WCHAR*)WStr("HotChocolate.Execution.IQueryRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig257[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[HotChocolate.Execution.IExecutionResult]"),(WCHAR*)WStr("HotChocolate.Execution.Processing.IOperationContext"),}; -WCHAR* sig258[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[HotChocolate.Execution.IOperationResult]"),(WCHAR*)WStr("HotChocolate.Execution.Processing.OperationContext"),}; -WCHAR* sig259[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[HotChocolate.Execution.IQueryResult]"),(WCHAR*)WStr("HotChocolate.Execution.Processing.OperationContext"),}; -WCHAR* sig260[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.AspNetCore.Identity.IdentityResult]"),(WCHAR*)WStr("!0"),}; -WCHAR* sig261[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.AspNetCore.Identity.SignInResult]"),(WCHAR*)WStr("!0"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig262[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.AspNetCore.Identity.SignInResult]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig263[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Azure.Cosmos.ResponseMessage]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Microsoft.Azure.Documents.ResourceType"),(WCHAR*)WStr("Microsoft.Azure.Documents.OperationType"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.RequestOptions"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.ContainerInternal"),(WCHAR*)WStr("_"),(WCHAR*)WStr("System.IO.Stream"),(WCHAR*)WStr("System.Action`1[Microsoft.Azure.Cosmos.RequestMessage]"),(WCHAR*)WStr("_"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig061[]={(WCHAR*)WStr("Datadog.Trace.FeatureFlags.IEvaluation"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.EvaluationType"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.IEvaluationContext"),}; +WCHAR* sig062[]={(WCHAR*)WStr("Datadog.Trace.IScope"),}; +WCHAR* sig063[]={(WCHAR*)WStr("Datadog.Trace.IScope"),(WCHAR*)WStr("System.String"),}; +WCHAR* sig064[]={(WCHAR*)WStr("Datadog.Trace.IScope"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.ISpanContext"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Nullable`1[System.DateTimeOffset]"),(WCHAR*)WStr("System.Nullable`1[System.Boolean]"),}; +WCHAR* sig065[]={(WCHAR*)WStr("Datadog.Trace.IScope"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.SpanCreationSettings"),}; +WCHAR* sig066[]={(WCHAR*)WStr("Datadog.Trace.ISpan"),(WCHAR*)WStr("Datadog.Trace.ISpan"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Nullable`1[System.Double]"),}; +WCHAR* sig067[]={(WCHAR*)WStr("Datadog.Trace.ISpan"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.ISpanContext"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Nullable`1[System.DateTimeOffset]"),(WCHAR*)WStr("System.Boolean"),}; +WCHAR* sig068[]={(WCHAR*)WStr("Datadog.Trace.ISpanContext"),(WCHAR*)WStr("!!0"),(WCHAR*)WStr("System.Func`3[!!0,System.String,System.Collections.Generic.IEnumerable`1[System.String]]"),}; +WCHAR* sig069[]={(WCHAR*)WStr("Datadog.Trace.ISpanContext"),(WCHAR*)WStr("!!0"),(WCHAR*)WStr("System.Func`3[!!0,System.String,System.Collections.Generic.IEnumerable`1[System.String]]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),}; +WCHAR* sig070[]={(WCHAR*)WStr("Elasticsearch.Net.ElasticsearchResponse`1[!0]"),(WCHAR*)WStr("Elasticsearch.Net.RequestData"),}; +WCHAR* sig071[]={(WCHAR*)WStr("GraphQL.Validation.IValidationResult"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("GraphQL.Types.ISchema"),(WCHAR*)WStr("GraphQL.Language.AST.Document"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[GraphQL.Validation.IValidationRule]"),(WCHAR*)WStr("_"),(WCHAR*)WStr("GraphQL.Inputs"),}; +WCHAR* sig072[]={(WCHAR*)WStr("Grpc.Core.CallInvocationDetails`2[!!0,!!1]"),(WCHAR*)WStr("Grpc.Core.Method`2[!!0,!!1]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Grpc.Core.CallOptions"),}; +WCHAR* sig073[]={(WCHAR*)WStr("Grpc.Core.Internal.MetadataArraySafeHandle"),(WCHAR*)WStr("Grpc.Core.Metadata"),}; +WCHAR* sig074[]={(WCHAR*)WStr("log4net.Appender.IAppender[]"),}; +WCHAR* sig075[]={(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),}; +WCHAR* sig076[]={(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.DirectoryBrowserOptions"),}; +WCHAR* sig077[]={(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.PathString"),(WCHAR*)WStr("System.Action`1[Microsoft.AspNetCore.Builder.IApplicationBuilder]"),}; +WCHAR* sig078[]={(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.PathString"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Action`1[Microsoft.AspNetCore.Builder.IApplicationBuilder]"),}; +WCHAR* sig079[]={(WCHAR*)WStr("Microsoft.AspNetCore.Http.RequestDelegate"),}; +WCHAR* sig080[]={(WCHAR*)WStr("Microsoft.Azure.Cosmos.FeedIterator`1"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.QueryDefinition"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.QueryRequestOptions"),}; +WCHAR* sig081[]={(WCHAR*)WStr("Microsoft.Azure.Cosmos.FeedIterator`1"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.QueryRequestOptions"),}; +WCHAR* sig082[]={(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),}; +WCHAR* sig083[]={(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; +WCHAR* sig084[]={(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),}; +WCHAR* sig085[]={(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; +WCHAR* sig086[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.RunCleanupResult"),}; +WCHAR* sig087[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodInfo"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.TestMethod"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.Interface.ITestContext"),}; +WCHAR* sig088[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodInfo"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.TestMethod"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.Interface.ITestContext"),(WCHAR*)WStr("System.Boolean"),}; +WCHAR* sig089[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.UnitTestResult[]"),}; +WCHAR* sig090[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.UnitTestResult[]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.TestMethod"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; +WCHAR* sig091[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestResult"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.ITestMethod"),}; +WCHAR* sig092[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestResult[]"),}; +WCHAR* sig093[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestResult[]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodInfo"),}; +WCHAR* sig094[]={(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestResult[]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.TestMethod"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging.IMessageLogger"),}; +WCHAR* sig095[]={(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),}; +WCHAR* sig096[]={(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; +WCHAR* sig097[]={(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),}; +WCHAR* sig098[]={(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; +WCHAR* sig099[]={(WCHAR*)WStr("NLog.Config.LoggingConfiguration"),(WCHAR*)WStr("NLog.LogFactory"),(WCHAR*)WStr("System.String"),}; +WCHAR* sig100[]={(WCHAR*)WStr("NLog.Internal.TargetWithFilterChain[]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.List`1[NLog.Config.LoggingRule]"),}; +WCHAR* sig101[]={(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),}; +WCHAR* sig102[]={(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; +WCHAR* sig103[]={(WCHAR*)WStr("NUnit.Framework.Internal.Commands.SkipCommand"),(WCHAR*)WStr("NUnit.Framework.Internal.Test"),}; +WCHAR* sig104[]={(WCHAR*)WStr("NUnit.Framework.Internal.Commands.TestCommand"),}; +WCHAR* sig105[]={(WCHAR*)WStr("NUnit.Framework.Internal.Commands.TestCommand"),(WCHAR*)WStr("NUnit.Framework.Internal.TestMethod"),}; +WCHAR* sig106[]={(WCHAR*)WStr("OpenQA.Selenium.Remote.Response"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.Dictionary`2[System.String,System.Object]"),}; +WCHAR* sig107[]={(WCHAR*)WStr("OpenQA.Selenium.Response"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.Dictionary`2[System.String,System.Object]"),}; +WCHAR* sig108[]={(WCHAR*)WStr("OpenTelemetry.Trace.TelemetrySpan"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("OpenTelemetry.Trace.SpanKind"),(WCHAR*)WStr("OpenTelemetry.Trace.SpanAttributes"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[OpenTelemetry.Trace.Link]"),(WCHAR*)WStr("System.DateTimeOffset"),}; +WCHAR* sig109[]={(WCHAR*)WStr("OpenTelemetry.Trace.TelemetrySpan"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("OpenTelemetry.Trace.SpanKind"),(WCHAR*)WStr("OpenTelemetry.Trace.SpanContext&"),(WCHAR*)WStr("OpenTelemetry.Trace.SpanAttributes"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[OpenTelemetry.Trace.Link]"),(WCHAR*)WStr("System.DateTimeOffset"),}; +WCHAR* sig110[]={(WCHAR*)WStr("OpenTelemetry.Trace.TracerProvider"),(WCHAR*)WStr("OpenTelemetry.Trace.TracerProviderBuilder"),}; +WCHAR* sig111[]={(WCHAR*)WStr("OpenTracing.ITracer"),(WCHAR*)WStr("Datadog.Trace.Tracer"),}; +WCHAR* sig112[]={(WCHAR*)WStr("OpenTracing.ITracer"),(WCHAR*)WStr("System.Uri"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),}; +WCHAR* sig113[]={(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),}; +WCHAR* sig114[]={(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; +WCHAR* sig115[]={(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),}; +WCHAR* sig116[]={(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; +WCHAR* sig117[]={(WCHAR*)WStr("RabbitMQ.Client.BasicGetResult"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),}; +WCHAR* sig118[]={(WCHAR*)WStr("RabbitMQ.Client.BasicProperties"),(WCHAR*)WStr("!!0"),(WCHAR*)WStr("System.Diagnostics.Activity"),(WCHAR*)WStr("System.UInt64"),}; +WCHAR* sig119[]={(WCHAR*)WStr("Serilog.Core.Logger"),}; +WCHAR* sig120[]={(WCHAR*)WStr("StackExchange.Redis.ServerEndPoint"),(WCHAR*)WStr("StackExchange.Redis.Message"),}; +WCHAR* sig121[]={(WCHAR*)WStr("System.Boolean"),}; +WCHAR* sig122[]={(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Azure.Messaging.EventHubs.EventData"),}; +WCHAR* sig123[]={(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusMessage"),}; +WCHAR* sig124[]={(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.IAsyncResult"),}; +WCHAR* sig125[]={(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.ServiceModel.Channels.RequestContext"),(WCHAR*)WStr("System.ServiceModel.OperationContext"),}; +WCHAR* sig126[]={(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Xunit.Abstractions.ITestCase"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Xunit.Sdk.IMessageBus"),}; +WCHAR* sig127[]={(WCHAR*)WStr("System.Byte[]"),(WCHAR*)WStr("System.Byte[]"),}; +WCHAR* sig128[]={(WCHAR*)WStr("System.Byte[]"),(WCHAR*)WStr("System.Byte[]"),(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("System.Int32"),}; +WCHAR* sig129[]={(WCHAR*)WStr("System.Byte[]"),(WCHAR*)WStr("System.IO.Stream"),}; +WCHAR* sig130[]={(WCHAR*)WStr("System.Collections.Generic.HashSet`1[System.String]"),}; +WCHAR* sig131[]={(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Object&"),}; +WCHAR* sig132[]={(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; +WCHAR* sig133[]={(WCHAR*)WStr("System.Collections.Generic.IList`1[Confluent.Kafka.TopicPartitionOffset]"),}; +WCHAR* sig134[]={(WCHAR*)WStr("System.Collections.Generic.IReadOnlyDictionary`2[System.String,System.String]"),}; +WCHAR* sig135[]={(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; +WCHAR* sig136[]={(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),}; +WCHAR* sig137[]={(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; +WCHAR* sig138[]={(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),}; +WCHAR* sig139[]={(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; +WCHAR* sig140[]={(WCHAR*)WStr("System.Diagnostics.Process"),}; +WCHAR* sig141[]={(WCHAR*)WStr("System.Diagnostics.Process"),(WCHAR*)WStr("System.Diagnostics.ProcessStartInfo"),(WCHAR*)WStr("System.Boolean"),}; +WCHAR* sig142[]={(WCHAR*)WStr("System.Double"),}; +WCHAR* sig143[]={(WCHAR*)WStr("System.IAsyncResult"),(WCHAR*)WStr("System.AsyncCallback"),(WCHAR*)WStr("System.Object"),}; +WCHAR* sig144[]={(WCHAR*)WStr("System.IAsyncResult"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Object[]"),(WCHAR*)WStr("System.AsyncCallback"),(WCHAR*)WStr("System.Object"),}; +WCHAR* sig145[]={(WCHAR*)WStr("System.IAsyncResult"),(WCHAR*)WStr("System.Web.Mvc.ControllerContext"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.AsyncCallback"),(WCHAR*)WStr("System.Object"),}; +WCHAR* sig146[]={(WCHAR*)WStr("System.Int32"),}; +WCHAR* sig147[]={(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("log4net.Core.LoggingEvent"),}; +WCHAR* sig148[]={(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; +WCHAR* sig149[]={(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("System.String[]"),}; +WCHAR* sig150[]={(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("System.String[]"),(WCHAR*)WStr("System.Collections.Generic.List`1[Microsoft.VisualStudio.TestPlatform.CommandLine.Processors.IArgumentProcessor]&"),}; +WCHAR* sig151[]={(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("_"),}; +WCHAR* sig152[]={(WCHAR*)WStr("System.IO.Stream"),}; +WCHAR* sig153[]={(WCHAR*)WStr("System.Messaging.Message"),(WCHAR*)WStr("System.TimeSpan"),(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("System.Messaging.Interop.CursorHandle"),(WCHAR*)WStr("System.Messaging.MessagePropertyFilter"),(WCHAR*)WStr("System.Messaging.MessageQueueTransaction"),(WCHAR*)WStr("System.Messaging.MessageQueueTransactionType"),}; +WCHAR* sig154[]={(WCHAR*)WStr("System.Net.Http.HttpResponseMessage"),(WCHAR*)WStr("System.Net.Http.HttpRequestMessage"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig155[]={(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders"),(WCHAR*)WStr("System.IO.Stream"),}; +WCHAR* sig156[]={(WCHAR*)WStr("System.Net.WebResponse"),}; +WCHAR* sig157[]={(WCHAR*)WStr("System.Net.WebResponse"),(WCHAR*)WStr("System.IAsyncResult"),}; +WCHAR* sig158[]={(WCHAR*)WStr("System.Nullable`1[System.Boolean]"),}; +WCHAR* sig159[]={(WCHAR*)WStr("System.Nullable`1[System.Double]"),}; +WCHAR* sig160[]={(WCHAR*)WStr("System.Object"),}; +WCHAR* sig161[]={(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; +WCHAR* sig162[]={(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Int32"),}; +WCHAR* sig163[]={(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Object[]"),(WCHAR*)WStr("System.Object[]&"),}; +WCHAR* sig164[]={(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Object[]&"),(WCHAR*)WStr("System.IAsyncResult"),}; +WCHAR* sig165[]={(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Reflection.MethodInfo"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Object[]"),}; +WCHAR* sig166[]={(WCHAR*)WStr("System.Runtime.Remoting.Channels.ServerProcessing"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.IServerChannelSinkStack"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders"),(WCHAR*)WStr("System.IO.Stream"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage&"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; +WCHAR* sig167[]={(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),}; +WCHAR* sig168[]={(WCHAR*)WStr("System.String"),}; +WCHAR* sig169[]={(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Int32"),}; +WCHAR* sig170[]={(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.ReadOnlySpan`1[System.Byte]&"),(WCHAR*)WStr("Google.Protobuf.ParserInternalState&"),(WCHAR*)WStr("System.Int32"),}; +WCHAR* sig171[]={(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),}; +WCHAR* sig172[]={(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("RabbitMQ.Client.IBasicConsumer"),}; +WCHAR* sig173[]={(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Text.Encoding"),}; +WCHAR* sig174[]={(WCHAR*)WStr("System.String"),(WCHAR*)WStr("_"),}; +WCHAR* sig175[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),}; +WCHAR* sig176[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Azure.Messaging.EventHubs.Producer.EventDataBatch"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig177[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusMessageBatch"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig178[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusReceivedMessage"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig179[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Couchbase.Core.IO.Connections.IConnection"),(WCHAR*)WStr("Couchbase.Core.IO.Operations.IOperation"),(WCHAR*)WStr("Couchbase.Core.IO.Operations.CancellationTokenPair"),}; +WCHAR* sig180[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Couchbase.Core.IO.Connections.IConnection"),(WCHAR*)WStr("Couchbase.Core.IO.Operations.IOperation"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig181[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Couchbase.Core.IO.Operations.IOperation"),(WCHAR*)WStr("Couchbase.Core.IO.Operations.CancellationTokenPair"),}; +WCHAR* sig182[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Couchbase.Core.IO.Operations.IOperation"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig183[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Couchbase.Core.IO.Operations.IOperation"),(WCHAR*)WStr("System.Threading.CancellationToken"),(WCHAR*)WStr("System.TimeSpan"),}; +WCHAR* sig184[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Couchbase.IO.Operations.IOperation"),}; +WCHAR* sig185[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Couchbase.IO.Operations.IOperation`1[!!0]"),}; +WCHAR* sig186[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Couchbase.IO.Operations.IOperation`1[!!0]"),(WCHAR*)WStr("Couchbase.IO.IConnection"),}; +WCHAR* sig187[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Grpc.Core.Internal.ServerRpcNew"),(WCHAR*)WStr("Grpc.Core.Internal.CompletionQueueSafeHandle"),}; +WCHAR* sig188[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Grpc.Core.Metadata"),}; +WCHAR* sig189[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Grpc.Core.Status"),(WCHAR*)WStr("Grpc.Core.Metadata"),(WCHAR*)WStr("System.Nullable`1[ResponseWithFlags[!0,!1]]"),}; +WCHAR* sig190[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics.ErrorContext"),}; +WCHAR* sig191[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Microsoft.AspNetCore.Hosting.Server.IHttpApplication`1[!!0]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig192[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.HttpContext"),}; +WCHAR* sig193[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.HttpContext"),(WCHAR*)WStr("System.Exception"),}; +WCHAR* sig194[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.HttpContext"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Security.Claims.ClaimsPrincipal"),(WCHAR*)WStr("Microsoft.AspNetCore.Authentication.AuthenticationProperties"),}; +WCHAR* sig195[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("Microsoft.Azure.Functions.Worker.FunctionContext"),}; +WCHAR* sig196[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("MongoDB.Driver.Core.Connections.IConnection"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig197[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),}; +WCHAR* sig198[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Azure.Messaging.EventHubs.EventData]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig199[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Azure.Messaging.ServiceBus.ServiceBusMessage]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig200[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.IO.Stream"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig201[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.Net.Http.HttpRequestMessage"),(WCHAR*)WStr("System.Nullable`1[System.TimeSpan]"),}; +WCHAR* sig202[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.Security.Claims.ClaimsPrincipal"),}; +WCHAR* sig203[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig204[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig205[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.UInt64"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("RabbitMQ.Client.IBasicProperties"),(WCHAR*)WStr("_"),}; +WCHAR* sig206[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.UInt64"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("RabbitMQ.Client.IReadOnlyBasicProperties"),(WCHAR*)WStr("System.ReadOnlyMemory`1[System.Byte]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig207[]={(WCHAR*)WStr("System.Threading.Tasks.Task"),(WCHAR*)WStr("_"),}; +WCHAR* sig208[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1"),(WCHAR*)WStr("StackExchange.Redis.Message"),(WCHAR*)WStr("StackExchange.Redis.ResultProcessor`1[!!0]"),(WCHAR*)WStr("!!0"),(WCHAR*)WStr("StackExchange.Redis.ServerEndPoint"),}; +WCHAR* sig209[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1"),(WCHAR*)WStr("StackExchange.Redis.Message"),(WCHAR*)WStr("StackExchange.Redis.ResultProcessor`1[!!0]"),(WCHAR*)WStr("StackExchange.Redis.ServerEndPoint"),}; +WCHAR* sig210[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1"),(WCHAR*)WStr("GraphQL.Execution.ExecutionContext"),}; +WCHAR* sig211[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1"),}; +WCHAR* sig212[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!!0]"),(WCHAR*)WStr("StackExchange.Redis.Message"),(WCHAR*)WStr("StackExchange.Redis.ResultProcessor`1[!!0]"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("StackExchange.Redis.ServerEndPoint"),}; +WCHAR* sig213[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!!0]"),(WCHAR*)WStr("StackExchange.Redis.Message"),(WCHAR*)WStr("StackExchange.Redis.ResultProcessor`1[!!0]"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("StackExchange.Redis.ServerEndPoint"),(WCHAR*)WStr("!!0"),}; +WCHAR* sig214[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!0]"),(WCHAR*)WStr("Amazon.Runtime.IExecutionContext"),}; +WCHAR* sig215[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!0]"),(WCHAR*)WStr("Elasticsearch.Net.HttpMethod"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Threading.CancellationToken"),(WCHAR*)WStr("Elasticsearch.Net.PostData"),(WCHAR*)WStr("Elasticsearch.Net.IRequestParameters"),}; +WCHAR* sig216[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!0]"),(WCHAR*)WStr("Elasticsearch.Net.RequestData"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig217[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!0]"),(WCHAR*)WStr("GraphQL.Types.ISchema"),(WCHAR*)WStr("GraphQL.Language.AST.Document"),(WCHAR*)WStr("GraphQL.Language.AST.VariableDefinitions"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[GraphQL.Validation.IValidationRule]"),(WCHAR*)WStr("_"),(WCHAR*)WStr("GraphQL.Inputs"),}; +WCHAR* sig218[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!0]"),(WCHAR*)WStr("GraphQL.Validation.ValidationContext"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[GraphQL.Validation.IValidationRule]"),}; +WCHAR* sig219[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!0]"),(WCHAR*)WStr("MongoDB.Driver.Core.Connections.IConnection"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig220[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!0]"),(WCHAR*)WStr("MongoDB.Driver.OperationContext"),(WCHAR*)WStr("MongoDB.Driver.Core.Connections.IConnection"),}; +WCHAR* sig221[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[!0]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("GraphQL.Types.ISchema"),(WCHAR*)WStr("GraphQL.Language.AST.Document"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[GraphQL.Validation.IValidationRule]"),(WCHAR*)WStr("_"),(WCHAR*)WStr("GraphQL.Inputs"),}; +WCHAR* sig222[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.DynamoDBv2.Model.BatchGetItemResponse]"),(WCHAR*)WStr("Amazon.DynamoDBv2.Model.BatchGetItemRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig223[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.DynamoDBv2.Model.BatchWriteItemResponse]"),(WCHAR*)WStr("Amazon.DynamoDBv2.Model.BatchWriteItemRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig224[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.DynamoDBv2.Model.DeleteItemResponse]"),(WCHAR*)WStr("Amazon.DynamoDBv2.Model.DeleteItemRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig225[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.DynamoDBv2.Model.GetItemResponse]"),(WCHAR*)WStr("Amazon.DynamoDBv2.Model.GetItemRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig226[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.DynamoDBv2.Model.PutItemResponse]"),(WCHAR*)WStr("Amazon.DynamoDBv2.Model.PutItemRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig227[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.DynamoDBv2.Model.ScanResponse]"),(WCHAR*)WStr("Amazon.DynamoDBv2.Model.ScanRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig228[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.DynamoDBv2.Model.UpdateItemResponse]"),(WCHAR*)WStr("Amazon.DynamoDBv2.Model.UpdateItemRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig229[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.EventBridge.Model.PutEventsResponse]"),(WCHAR*)WStr("Amazon.EventBridge.Model.PutEventsRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig230[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.Kinesis.Model.GetRecordsResponse]"),(WCHAR*)WStr("Amazon.Kinesis.Model.GetRecordsRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig231[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.Kinesis.Model.PutRecordResponse]"),(WCHAR*)WStr("Amazon.Kinesis.Model.PutRecordRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig232[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.Kinesis.Model.PutRecordsResponse]"),(WCHAR*)WStr("Amazon.Kinesis.Model.PutRecordsRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig233[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.CompleteMultipartUploadResponse]"),(WCHAR*)WStr("Amazon.S3.Model.CompleteMultipartUploadRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig234[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.CopyObjectResponse]"),(WCHAR*)WStr("Amazon.S3.Model.CopyObjectRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig235[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.DeleteBucketResponse]"),(WCHAR*)WStr("Amazon.S3.Model.DeleteBucketRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig236[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.DeleteObjectResponse]"),(WCHAR*)WStr("Amazon.S3.Model.DeleteObjectRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig237[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.DeleteObjectsResponse]"),(WCHAR*)WStr("Amazon.S3.Model.DeleteObjectsRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig238[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.GetObjectResponse]"),(WCHAR*)WStr("Amazon.S3.Model.GetObjectRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig239[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.InitiateMultipartUploadResponse]"),(WCHAR*)WStr("Amazon.S3.Model.InitiateMultipartUploadRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig240[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.ListBucketsResponse]"),(WCHAR*)WStr("Amazon.S3.Model.ListBucketsRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig241[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.ListObjectsV2Response]"),(WCHAR*)WStr("Amazon.S3.Model.ListObjectsV2Request"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig242[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.PutBucketResponse]"),(WCHAR*)WStr("Amazon.S3.Model.PutBucketRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig243[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.PutObjectResponse]"),(WCHAR*)WStr("Amazon.S3.Model.PutObjectRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig244[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.S3.Model.UploadPartResponse]"),(WCHAR*)WStr("Amazon.S3.Model.UploadPartRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig245[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SimpleNotificationService.Model.PublishBatchResponse]"),(WCHAR*)WStr("Amazon.SimpleNotificationService.Model.PublishBatchRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig246[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SimpleNotificationService.Model.PublishResponse]"),(WCHAR*)WStr("Amazon.SimpleNotificationService.Model.PublishRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig247[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SQS.Model.CreateQueueResponse]"),(WCHAR*)WStr("Amazon.SQS.Model.CreateQueueRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig248[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SQS.Model.DeleteMessageBatchResponse]"),(WCHAR*)WStr("Amazon.SQS.Model.DeleteMessageBatchRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig249[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SQS.Model.DeleteMessageResponse]"),(WCHAR*)WStr("Amazon.SQS.Model.DeleteMessageRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig250[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SQS.Model.DeleteQueueResponse]"),(WCHAR*)WStr("Amazon.SQS.Model.DeleteQueueRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig251[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SQS.Model.ReceiveMessageResponse]"),(WCHAR*)WStr("Amazon.SQS.Model.ReceiveMessageRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig252[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SQS.Model.SendMessageBatchResponse]"),(WCHAR*)WStr("Amazon.SQS.Model.SendMessageBatchRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig253[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Amazon.SQS.Model.SendMessageResponse]"),(WCHAR*)WStr("Amazon.SQS.Model.SendMessageRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig254[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Confluent.Kafka.DeliveryReport`2[!0,!1]]"),(WCHAR*)WStr("Confluent.Kafka.TopicPartition"),(WCHAR*)WStr("Confluent.Kafka.Message`2[!0,!1]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig255[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Elasticsearch.Net.ElasticsearchResponse`1[!0]]"),(WCHAR*)WStr("Elasticsearch.Net.RequestData"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig256[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[HotChocolate.Execution.IExecutionResult]"),(WCHAR*)WStr("HotChocolate.Execution.IOperationRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig257[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[HotChocolate.Execution.IExecutionResult]"),(WCHAR*)WStr("HotChocolate.Execution.IQueryRequest"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig258[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[HotChocolate.Execution.IExecutionResult]"),(WCHAR*)WStr("HotChocolate.Execution.Processing.IOperationContext"),}; +WCHAR* sig259[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[HotChocolate.Execution.IOperationResult]"),(WCHAR*)WStr("HotChocolate.Execution.Processing.OperationContext"),}; +WCHAR* sig260[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[HotChocolate.Execution.IQueryResult]"),(WCHAR*)WStr("HotChocolate.Execution.Processing.OperationContext"),}; +WCHAR* sig261[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.AspNetCore.Identity.IdentityResult]"),(WCHAR*)WStr("!0"),}; +WCHAR* sig262[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.AspNetCore.Identity.SignInResult]"),(WCHAR*)WStr("!0"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),}; +WCHAR* sig263[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.AspNetCore.Identity.SignInResult]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),}; WCHAR* sig264[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Azure.WebJobs.Host.Executors.IDelayedException]"),(WCHAR*)WStr("Microsoft.Azure.WebJobs.Host.Executors.IFunctionInstance"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; WCHAR* sig265[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Azure.WebJobs.Script.Grpc.Messages.TypedData]"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.HttpRequest"),(WCHAR*)WStr("Microsoft.Extensions.Logging.ILogger"),(WCHAR*)WStr("Microsoft.Azure.WebJobs.Script.Grpc.GrpcCapabilities"),}; WCHAR* sig266[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Data.SqlClient.SqlDataReader]"),}; @@ -354,661 +354,664 @@ WCHAR* sig335[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("NUnit.Framework.Inter WCHAR* sig336[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("NUnit.Framework.Internal.TestMethod"),(WCHAR*)WStr("NUnit.Framework.Interfaces.ITestFilter"),(WCHAR*)WStr("NUnit.Framework.Internal.Abstractions.IDebugger"),}; WCHAR* sig337[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("OpenQA.Selenium.Remote.SendingRemoteHttpRequestEventArgs"),}; WCHAR* sig338[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Serilog.Events.LogEvent"),}; -WCHAR* sig339[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Action`2[System.Object,!!0]"),(WCHAR*)WStr("!!0"),}; -WCHAR* sig340[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig341[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Grpc.Core.Internal.ClientSideStatus"),}; -WCHAR* sig342[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Grpc.Core.Internal.ClientSideStatus"),(WCHAR*)WStr("Grpc.Core.Internal.IBufferReader"),(WCHAR*)WStr("Grpc.Core.Metadata"),}; -WCHAR* sig343[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.Dictionary`2[System.String,System.Object]"),}; -WCHAR* sig344[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.Dictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig345[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.ICollection`1[System.Reflection.MethodInfo]"),(WCHAR*)WStr("System.Func`1[System.IDisposable]"),}; -WCHAR* sig346[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String&"),(WCHAR*)WStr("System.String&"),}; -WCHAR* sig347[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; -WCHAR* sig348[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Confluent.Kafka.TopicPartitionOffset]"),}; -WCHAR* sig349[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),}; -WCHAR* sig350[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),}; -WCHAR* sig351[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.IExternalScopeProvider"),}; -WCHAR* sig352[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.ILogEnricher]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.IStaticLogEnricher]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggingSampler"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.IExternalScopeProvider"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerEnrichmentOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerRedactionOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Compliance.Redaction.IRedactorProvider"),}; -WCHAR* sig353[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.ILogEnricher]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.IStaticLogEnricher]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggingSampler"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.IExternalScopeProvider"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerEnrichmentOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerRedactionOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Compliance.Redaction.IRedactorProvider"),(WCHAR*)WStr("Microsoft.Extensions.Diagnostics.Buffering.LogBuffer"),}; -WCHAR* sig354[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.ILogEnricher]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.IStaticLogEnricher]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.IExternalScopeProvider"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerEnrichmentOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerRedactionOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Compliance.Redaction.IRedactorProvider"),}; -WCHAR* sig355[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.UnitTestElement]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter.ITestCaseDiscoverySink"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter.IDiscoveryContext"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging.IMessageLogger"),}; -WCHAR* sig356[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[System.String]"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),}; -WCHAR* sig357[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[System.String]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[System.String]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[System.String]"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),}; -WCHAR* sig358[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Exception"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig359[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Net.Http.HttpRequestMessage"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Diagnostics.Activity"),(WCHAR*)WStr("Grpc.Core.Status"),}; -WCHAR* sig360[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Net.Http.HttpRequestMessage"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Diagnostics.Activity"),(WCHAR*)WStr("System.Nullable`1[Grpc.Core.Status]"),}; -WCHAR* sig361[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Net.HttpWebResponse"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; -WCHAR* sig362[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Net.WebException"),(WCHAR*)WStr("System.Net.HttpWebResponse&"),}; -WCHAR* sig363[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Collections.Generic.Dictionary`2[System.String,System.Object]"),}; -WCHAR* sig364[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Messaging.MessageQueueTransaction"),(WCHAR*)WStr("System.Messaging.MessageQueueTransactionType"),}; -WCHAR* sig365[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.IServerResponseChannelSinkStack"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; -WCHAR* sig366[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.IServerResponseChannelSinkStack"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; -WCHAR* sig367[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders"),(WCHAR*)WStr("System.IO.Stream"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; -WCHAR* sig368[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.MessageRpc&"),}; -WCHAR* sig369[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.MessageRpc&"),(WCHAR*)WStr("System.Exception&"),(WCHAR*)WStr("System.Boolean&"),}; -WCHAR* sig370[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),}; -WCHAR* sig371[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("!0"),(WCHAR*)WStr("!1"),(WCHAR*)WStr("System.Action`1[Confluent.Kafka.DeliveryReport`2[!0,!1]]"),}; -WCHAR* sig372[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.UserDetails"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; -WCHAR* sig373[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("NLog.Config.LoggingConfiguration"),}; -WCHAR* sig374[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig375[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Datadog.Trace.UserDetails"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; -WCHAR* sig376[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; -WCHAR* sig377[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; -WCHAR* sig378[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; -WCHAR* sig379[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; -WCHAR* sig380[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.UnitTestElement]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter.ITestCaseDiscoverySink"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter.IDiscoveryContext"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging.IMessageLogger"),}; -WCHAR* sig381[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("RabbitMQ.Client.IBasicProperties"),(WCHAR*)WStr("_"),}; -WCHAR* sig382[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; -WCHAR* sig383[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; -WCHAR* sig384[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; -WCHAR* sig385[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.UInt64"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("RabbitMQ.Client.IBasicProperties"),(WCHAR*)WStr("_"),}; -WCHAR* sig386[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.TimeSpan"),}; -WCHAR* sig387[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Type"),(WCHAR*)WStr("NLog.Internal.TargetWithFilterChain"),(WCHAR*)WStr("NLog.LogEventInfo"),(WCHAR*)WStr("NLog.LogFactory"),}; -WCHAR* sig388[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Xunit.v3.IXunitTestMethod"),(WCHAR*)WStr("System.Collections.Generic.IReadOnlyCollection`1[Xunit.v3.IXunitTestCase]"),(WCHAR*)WStr("Xunit.Sdk.ExplicitOption"),(WCHAR*)WStr("Xunit.v3.IMessageBus"),(WCHAR*)WStr("Xunit.v3.ExceptionAggregator"),(WCHAR*)WStr("System.Threading.CancellationTokenSource"),(WCHAR*)WStr("System.Object[]"),}; -WCHAR* sig389[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Yarp.ReverseProxy.Forwarder.ForwarderHttpClientContext"),(WCHAR*)WStr("System.Net.Http.SocketsHttpHandler"),}; -WCHAR* sig390[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("_"),}; -WCHAR* sig391[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("_"),(WCHAR*)WStr("_"),}; -WCHAR* sig392[]={(WCHAR*)WStr("System.Web.Mvc.ActionResult"),(WCHAR*)WStr("System.Web.Mvc.ControllerContext"),(WCHAR*)WStr("System.Web.Mvc.ActionDescriptor"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; -WCHAR* sig393[]={(WCHAR*)WStr("_"),(WCHAR*)WStr("_"),}; -WCHAR* sig394[]={(WCHAR*)WStr("_"),(WCHAR*)WStr("_"),(WCHAR*)WStr("_"),}; +WCHAR* sig339[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Action"),}; +WCHAR* sig340[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Action`2[System.Object,!!0]"),(WCHAR*)WStr("!!0"),}; +WCHAR* sig341[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Boolean"),}; +WCHAR* sig342[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Grpc.Core.Internal.ClientSideStatus"),}; +WCHAR* sig343[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Grpc.Core.Internal.ClientSideStatus"),(WCHAR*)WStr("Grpc.Core.Internal.IBufferReader"),(WCHAR*)WStr("Grpc.Core.Metadata"),}; +WCHAR* sig344[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.Dictionary`2[System.String,System.Object]"),}; +WCHAR* sig345[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.Dictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.Boolean"),}; +WCHAR* sig346[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.ICollection`1[System.Reflection.MethodInfo]"),(WCHAR*)WStr("System.Func`1[System.IDisposable]"),}; +WCHAR* sig347[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String&"),(WCHAR*)WStr("System.String&"),}; +WCHAR* sig348[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; +WCHAR* sig349[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Confluent.Kafka.TopicPartitionOffset]"),}; +WCHAR* sig350[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),}; +WCHAR* sig351[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),}; +WCHAR* sig352[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.IExternalScopeProvider"),}; +WCHAR* sig353[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.ILogEnricher]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.IStaticLogEnricher]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggingSampler"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.IExternalScopeProvider"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerEnrichmentOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerRedactionOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Compliance.Redaction.IRedactorProvider"),}; +WCHAR* sig354[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.ILogEnricher]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.IStaticLogEnricher]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggingSampler"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.IExternalScopeProvider"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerEnrichmentOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerRedactionOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Compliance.Redaction.IRedactorProvider"),(WCHAR*)WStr("Microsoft.Extensions.Diagnostics.Buffering.LogBuffer"),}; +WCHAR* sig355[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.ILogEnricher]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.IStaticLogEnricher]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.IExternalScopeProvider"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerEnrichmentOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerRedactionOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Compliance.Redaction.IRedactorProvider"),}; +WCHAR* sig356[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.UnitTestElement]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter.ITestCaseDiscoverySink"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter.IDiscoveryContext"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging.IMessageLogger"),}; +WCHAR* sig357[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[System.String]"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),}; +WCHAR* sig358[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[System.String]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[System.String]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[System.String]"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),}; +WCHAR* sig359[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Exception"),(WCHAR*)WStr("System.Boolean"),}; +WCHAR* sig360[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Net.Http.HttpRequestMessage"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Diagnostics.Activity"),(WCHAR*)WStr("Grpc.Core.Status"),}; +WCHAR* sig361[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Net.Http.HttpRequestMessage"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Diagnostics.Activity"),(WCHAR*)WStr("System.Nullable`1[Grpc.Core.Status]"),}; +WCHAR* sig362[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Net.HttpWebResponse"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; +WCHAR* sig363[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Net.WebException"),(WCHAR*)WStr("System.Net.HttpWebResponse&"),}; +WCHAR* sig364[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Collections.Generic.Dictionary`2[System.String,System.Object]"),}; +WCHAR* sig365[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Messaging.MessageQueueTransaction"),(WCHAR*)WStr("System.Messaging.MessageQueueTransactionType"),}; +WCHAR* sig366[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.IServerResponseChannelSinkStack"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; +WCHAR* sig367[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.IServerResponseChannelSinkStack"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; +WCHAR* sig368[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders"),(WCHAR*)WStr("System.IO.Stream"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; +WCHAR* sig369[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.MessageRpc&"),}; +WCHAR* sig370[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.MessageRpc&"),(WCHAR*)WStr("System.Exception&"),(WCHAR*)WStr("System.Boolean&"),}; +WCHAR* sig371[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),}; +WCHAR* sig372[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("!0"),(WCHAR*)WStr("!1"),(WCHAR*)WStr("System.Action`1[Confluent.Kafka.DeliveryReport`2[!0,!1]]"),}; +WCHAR* sig373[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.UserDetails"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; +WCHAR* sig374[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("NLog.Config.LoggingConfiguration"),}; +WCHAR* sig375[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),}; +WCHAR* sig376[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Datadog.Trace.UserDetails"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; +WCHAR* sig377[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; +WCHAR* sig378[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; +WCHAR* sig379[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; +WCHAR* sig380[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; +WCHAR* sig381[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.UnitTestElement]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter.ITestCaseDiscoverySink"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter.IDiscoveryContext"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging.IMessageLogger"),}; +WCHAR* sig382[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("RabbitMQ.Client.IBasicProperties"),(WCHAR*)WStr("_"),}; +WCHAR* sig383[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; +WCHAR* sig384[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; +WCHAR* sig385[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; +WCHAR* sig386[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.UInt64"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("RabbitMQ.Client.IBasicProperties"),(WCHAR*)WStr("_"),}; +WCHAR* sig387[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.TimeSpan"),}; +WCHAR* sig388[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Type"),(WCHAR*)WStr("NLog.Internal.TargetWithFilterChain"),(WCHAR*)WStr("NLog.LogEventInfo"),(WCHAR*)WStr("NLog.LogFactory"),}; +WCHAR* sig389[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Xunit.v3.IXunitTestMethod"),(WCHAR*)WStr("System.Collections.Generic.IReadOnlyCollection`1[Xunit.v3.IXunitTestCase]"),(WCHAR*)WStr("Xunit.Sdk.ExplicitOption"),(WCHAR*)WStr("Xunit.v3.IMessageBus"),(WCHAR*)WStr("Xunit.v3.ExceptionAggregator"),(WCHAR*)WStr("System.Threading.CancellationTokenSource"),(WCHAR*)WStr("System.Object[]"),}; +WCHAR* sig390[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Yarp.ReverseProxy.Forwarder.ForwarderHttpClientContext"),(WCHAR*)WStr("System.Net.Http.SocketsHttpHandler"),}; +WCHAR* sig391[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("_"),}; +WCHAR* sig392[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("_"),(WCHAR*)WStr("_"),}; +WCHAR* sig393[]={(WCHAR*)WStr("System.Web.Mvc.ActionResult"),(WCHAR*)WStr("System.Web.Mvc.ControllerContext"),(WCHAR*)WStr("System.Web.Mvc.ActionDescriptor"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; +WCHAR* sig394[]={(WCHAR*)WStr("_"),(WCHAR*)WStr("_"),}; +WCHAR* sig395[]={(WCHAR*)WStr("_"),(WCHAR*)WStr("_"),(WCHAR*)WStr("_"),}; std::vector callTargets = { -{(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig134,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig145,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteScalar"),sig159,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Close"),sig310,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetString"),sig168,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetValue"),sig161,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Read"),sig120,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetString"),sig169,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Read"),sig121,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig134,2,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig145,1,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteScalar"),sig159,1,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Close"),sig310,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Close"),sig310,1,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetString"),sig168,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetString"),sig168,2,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetValue"),sig161,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetValue"),sig161,2,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Read"),sig120,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Read"),sig120,1,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetString"),sig169,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetString"),sig169,2,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Read"),sig121,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Read"),sig121,1,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig134,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig145,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteScalar"),sig159,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Close"),sig310,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetString"),sig168,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetValue"),sig161,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Read"),sig120,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetString"),sig169,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Read"),sig121,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("AerospikeClient"),(WCHAR*)WStr("Aerospike.Client.AsyncCommand"),(WCHAR*)WStr("ExecuteCommand"),sig310,1,4,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Aerospike.AsyncCommandIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AerospikeClient"),(WCHAR*)WStr("Aerospike.Client.SyncCommand"),(WCHAR*)WStr("ExecuteCommand"),sig310,1,4,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Aerospike.SyncCommandIntegration"),CallTargetKind::Default,1,15}, #if _WIN32 -{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.Compilation.BuildManager"),(WCHAR*)WStr("InvokePreStartInitMethodsCore"),sig345,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.HttpModule_Integration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.ThreadContext"),(WCHAR*)WStr("AssociateWithCurrentThread"),sig340,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ThreadContext_AssociateWithCurrentThread_Integration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.Compilation.BuildManager"),(WCHAR*)WStr("InvokePreStartInitMethodsCore"),sig346,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.HttpModule_Integration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.ThreadContext"),(WCHAR*)WStr("AssociateWithCurrentThread"),sig341,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ThreadContext_AssociateWithCurrentThread_Integration"),CallTargetKind::Default,1,1}, {(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.ThreadContext"),(WCHAR*)WStr("DisassociateFromCurrentThread"),sig310,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ThreadContext_DisassociateFromCurrentThread_Integration"),CallTargetKind::Default,1,1}, #endif -{(WCHAR*)WStr("Microsoft.AspNetCore.Authentication.Abstractions"),(WCHAR*)WStr("Microsoft.AspNetCore.Authentication.AuthenticationHttpContextExtensions"),(WCHAR*)WStr("SignInAsync"),sig193,5,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.AuthenticationHttpContextExtensionsIntegration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Http"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.ApplicationBuilder"),(WCHAR*)WStr("Build"),sig078,1,3,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.AspNetCoreBlockMiddlewareIntegrationEnd"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Http"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.Internal.ApplicationBuilder"),(WCHAR*)WStr("Build"),sig078,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.AspNetCoreBlockMiddlewareIntegrationEnd"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Http"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.DefaultHttpContext"),(WCHAR*)WStr("set_User"),sig201,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.HttpContextSetUser"),CallTargetKind::Default,2,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Http.Abstractions"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.MapExtensions"),(WCHAR*)WStr("Map"),sig076,4,2,2,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.EndpointsCollection.MapExtensionsMapIntegrationV2V3"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Http.Abstractions"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.MapExtensions"),(WCHAR*)WStr("Map"),sig077,5,5,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.EndpointsCollection.MapExtensionsMapIntegrationV5Plus"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Authentication.Abstractions"),(WCHAR*)WStr("Microsoft.AspNetCore.Authentication.AuthenticationHttpContextExtensions"),(WCHAR*)WStr("SignInAsync"),sig194,5,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.AuthenticationHttpContextExtensionsIntegration"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Http"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.ApplicationBuilder"),(WCHAR*)WStr("Build"),sig079,1,3,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.AspNetCoreBlockMiddlewareIntegrationEnd"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Http"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.Internal.ApplicationBuilder"),(WCHAR*)WStr("Build"),sig079,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.AspNetCoreBlockMiddlewareIntegrationEnd"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Http"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.DefaultHttpContext"),(WCHAR*)WStr("set_User"),sig202,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.HttpContextSetUser"),CallTargetKind::Default,2,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Http.Abstractions"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.MapExtensions"),(WCHAR*)WStr("Map"),sig077,4,2,2,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.EndpointsCollection.MapExtensionsMapIntegrationV2V3"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Http.Abstractions"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.MapExtensions"),(WCHAR*)WStr("Map"),sig078,5,5,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.EndpointsCollection.MapExtensionsMapIntegrationV5Plus"),CallTargetKind::Default,1,14}, {(WCHAR*)WStr("Microsoft.AspNetCore.Http.Abstractions"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.RunExtensions"),(WCHAR*)WStr("Run"),sig328,3,2,2,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.EndpointsCollection.RunExtensionsRunIntegration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Identity"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.SignInManager`1"),(WCHAR*)WStr("PasswordSignInAsync"),sig262,5,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.SignInManagerPasswordSignInIntegration"),CallTargetKind::Default,2,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Identity"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.SignInManager`1"),(WCHAR*)WStr("PasswordSignInAsync"),sig262,5,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.SignInManagerPasswordSignInIntegration"),CallTargetKind::Derived,2,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Identity"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.SignInManager`1"),(WCHAR*)WStr("PasswordSignInAsync"),sig261,5,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.SignInManagerPasswordSignInUserIntegration"),CallTargetKind::Default,2,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Identity"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.SignInManager`1"),(WCHAR*)WStr("PasswordSignInAsync"),sig262,5,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.SignInManagerPasswordSignInUserIntegration"),CallTargetKind::Derived,2,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Identity"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.SignInManager`1"),(WCHAR*)WStr("PasswordSignInAsync"),sig263,5,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.SignInManagerPasswordSignInIntegration"),CallTargetKind::Default,2,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Identity"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.SignInManager`1"),(WCHAR*)WStr("PasswordSignInAsync"),sig263,5,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.SignInManagerPasswordSignInIntegration"),CallTargetKind::Derived,2,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Identity"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.SignInManager`1"),(WCHAR*)WStr("PasswordSignInAsync"),sig262,5,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.SignInManagerPasswordSignInUserIntegration"),CallTargetKind::Default,2,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Identity"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.SignInManager`1"),(WCHAR*)WStr("PasswordSignInAsync"),sig263,5,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.SignInManagerPasswordSignInUserIntegration"),CallTargetKind::Derived,2,14}, {(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.ModelBinding.DefaultModelBindingContext"),(WCHAR*)WStr("set_Result"),sig330,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.DefaultModelBindingContext_SetResult_Integration"),CallTargetKind::Default,6,14}, {(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.ModelBinding.DefaultModelBindingContext"),(WCHAR*)WStr("set_Result"),sig330,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.DefaultModelBindingContext_SetResult_Integration"),CallTargetKind::Derived,6,14}, {(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.MvcOptions"),(WCHAR*)WStr(".ctor"),sig310,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.MvcOptionsIntegration"),CallTargetKind::Default,2,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Server.IIS"),(WCHAR*)WStr("Microsoft.AspNetCore.Server.IIS.Core.IISHttpContext"),(WCHAR*)WStr("FireOnStarting"),sig174,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.FireOnStartCommon"),CallTargetKind::Default,6,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http.HttpProtocol"),(WCHAR*)WStr("FireOnStarting"),sig174,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.FireOnStartCommon"),CallTargetKind::Default,6,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core.KestrelServer"),(WCHAR*)WStr("StartAsync"),sig190,3,2,2,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.EndpointsCollection.KestrelServerImplStartAsyncIntegration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core.KestrelServerImpl"),(WCHAR*)WStr("StartAsync"),sig190,3,5,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.EndpointsCollection.KestrelServerImplStartAsyncIntegration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Session"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.SessionOptions"),(WCHAR*)WStr("set_IdleTimeout"),sig386,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.Session.SessionOptionsIdleTimeoutIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Microsoft.AspNetCore.StaticFiles"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.DirectoryBrowserExtensions"),(WCHAR*)WStr("UseDirectoryBrowser"),sig074,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.StaticFiles.DirectoryBrowserExtensionsUseDirectoryBrowserIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.AspNetCore.StaticFiles"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.DirectoryBrowserExtensions"),(WCHAR*)WStr("UseDirectoryBrowser"),sig075,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.StaticFiles.DirectoryBrowserExtensionsUseDirectoryBrowserIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Identity.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.UserManager`1"),(WCHAR*)WStr("CreateAsync"),sig260,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.UserManagerCreateIntegration"),CallTargetKind::Default,2,14}, -{(WCHAR*)WStr("Microsoft.Extensions.Identity.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.UserManager`1"),(WCHAR*)WStr("CreateAsync"),sig260,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.UserManagerCreateIntegration"),CallTargetKind::Derived,2,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Server.IIS"),(WCHAR*)WStr("Microsoft.AspNetCore.Server.IIS.Core.IISHttpContext"),(WCHAR*)WStr("FireOnStarting"),sig175,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.FireOnStartCommon"),CallTargetKind::Default,6,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http.HttpProtocol"),(WCHAR*)WStr("FireOnStarting"),sig175,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.FireOnStartCommon"),CallTargetKind::Default,6,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core.KestrelServer"),(WCHAR*)WStr("StartAsync"),sig191,3,2,2,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.EndpointsCollection.KestrelServerImplStartAsyncIntegration"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core.KestrelServerImpl"),(WCHAR*)WStr("StartAsync"),sig191,3,5,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.EndpointsCollection.KestrelServerImplStartAsyncIntegration"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Session"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.SessionOptions"),(WCHAR*)WStr("set_IdleTimeout"),sig387,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.Session.SessionOptionsIdleTimeoutIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Microsoft.AspNetCore.StaticFiles"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.DirectoryBrowserExtensions"),(WCHAR*)WStr("UseDirectoryBrowser"),sig075,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.StaticFiles.DirectoryBrowserExtensionsUseDirectoryBrowserIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.AspNetCore.StaticFiles"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.DirectoryBrowserExtensions"),(WCHAR*)WStr("UseDirectoryBrowser"),sig076,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.StaticFiles.DirectoryBrowserExtensionsUseDirectoryBrowserIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Identity.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.UserManager`1"),(WCHAR*)WStr("CreateAsync"),sig261,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.UserManagerCreateIntegration"),CallTargetKind::Default,2,14}, +{(WCHAR*)WStr("Microsoft.Extensions.Identity.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.UserManager`1"),(WCHAR*)WStr("CreateAsync"),sig261,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.UserManagerCreateIntegration"),CallTargetKind::Derived,2,14}, #if _WIN32 -{(WCHAR*)WStr("System.Web.Mvc"),(WCHAR*)WStr("System.Web.Mvc.Async.AsyncControllerActionInvoker"),(WCHAR*)WStr("BeginInvokeAction"),sig144,5,4,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.AsyncControllerActionInvoker_BeginInvokeAction_Integration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Web.Mvc"),(WCHAR*)WStr("System.Web.Mvc.Async.AsyncControllerActionInvoker"),(WCHAR*)WStr("EndInvokeAction"),sig123,2,4,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.AsyncControllerActionInvoker_EndInvokeAction_Integration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Web.Mvc"),(WCHAR*)WStr("System.Web.Mvc.ControllerActionInvoker"),(WCHAR*)WStr("InvokeActionMethod"),sig392,4,4,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ControllerActionInvoker_InvokeAction_Integration"),CallTargetKind::Default,6,1}, +{(WCHAR*)WStr("System.Web.Mvc"),(WCHAR*)WStr("System.Web.Mvc.Async.AsyncControllerActionInvoker"),(WCHAR*)WStr("BeginInvokeAction"),sig145,5,4,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.AsyncControllerActionInvoker_BeginInvokeAction_Integration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Web.Mvc"),(WCHAR*)WStr("System.Web.Mvc.Async.AsyncControllerActionInvoker"),(WCHAR*)WStr("EndInvokeAction"),sig124,2,4,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.AsyncControllerActionInvoker_EndInvokeAction_Integration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Web.Mvc"),(WCHAR*)WStr("System.Web.Mvc.ControllerActionInvoker"),(WCHAR*)WStr("InvokeActionMethod"),sig393,4,4,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ControllerActionInvoker_InvokeAction_Integration"),CallTargetKind::Default,6,1}, {(WCHAR*)WStr("System.Web.Http"),(WCHAR*)WStr("System.Web.Http.ApiController"),(WCHAR*)WStr("ExecuteAsync"),sig298,3,5,1,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ApiController_ExecuteAsync_Integration"),CallTargetKind::Default,1,1}, {(WCHAR*)WStr("System.Web.Http"),(WCHAR*)WStr("System.Web.Http.Controllers.ReflectedHttpActionDescriptor"),(WCHAR*)WStr("ExecuteAsync"),sig297,4,5,1,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ReflectedHttpActionDescriptor_ExecuteAsync_Integration"),CallTargetKind::Default,6,1}, {(WCHAR*)WStr("System.Web.Http"),(WCHAR*)WStr("System.Web.Http.ExceptionHandling.ExceptionHandlerExtensions"),(WCHAR*)WStr("HandleAsync"),sig299,4,5,1,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ExceptionHandlerExtensions_HandleAsync_Integration"),CallTargetKind::Default,1,1}, #endif {(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("BatchGetItem"),sig008,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.BatchGetItemIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("BatchGetItemAsync"),sig221,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.BatchGetItemAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("BatchGetItemAsync"),sig222,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.BatchGetItemAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("BatchWriteItem"),sig009,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.BatchWriteItemIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("BatchWriteItemAsync"),sig222,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.BatchWriteItemAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("BatchWriteItemAsync"),sig223,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.BatchWriteItemAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("DeleteItem"),sig010,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.DeleteItemIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("DeleteItemAsync"),sig223,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.DeleteItemAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("DeleteItemAsync"),sig224,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.DeleteItemAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("GetItem"),sig011,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.GetItemIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("GetItemAsync"),sig224,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.GetItemAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("GetItemAsync"),sig225,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.GetItemAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("PutItem"),sig012,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.PutItemIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("PutItemAsync"),sig225,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.PutItemAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("PutItemAsync"),sig226,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.PutItemAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("Scan"),sig013,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.ScanIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("ScanAsync"),sig226,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.ScanAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("ScanAsync"),sig227,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.ScanAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("UpdateItem"),sig014,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.UpdateItemIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("UpdateItemAsync"),sig227,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.UpdateItemAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("UpdateItemAsync"),sig228,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.UpdateItemAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.EventBridge"),(WCHAR*)WStr("Amazon.EventBridge.AmazonEventBridgeClient"),(WCHAR*)WStr("PutEvents"),sig015,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.EventBridge.PutEventsIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.EventBridge"),(WCHAR*)WStr("Amazon.EventBridge.AmazonEventBridgeClient"),(WCHAR*)WStr("PutEventsAsync"),sig228,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.EventBridge.PutEventsAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.EventBridge"),(WCHAR*)WStr("Amazon.EventBridge.AmazonEventBridgeClient"),(WCHAR*)WStr("PutEventsAsync"),sig229,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.EventBridge.PutEventsAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("GetRecords"),sig016,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.GetRecordsIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("GetRecordsAsync"),sig229,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.GetRecordsAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("GetRecordsAsync"),sig230,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.GetRecordsAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("PutRecord"),sig017,2,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.PutRecordIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("PutRecord"),sig017,2,3,7,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.PutRecordV3_7Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("PutRecordAsync"),sig230,3,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.PutRecordAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("PutRecordAsync"),sig230,3,3,7,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.PutRecordAsyncV3_7Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("PutRecordAsync"),sig231,3,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.PutRecordAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("PutRecordAsync"),sig231,3,3,7,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.PutRecordAsyncV3_7Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("PutRecords"),sig018,2,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.PutRecordsIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("PutRecords"),sig018,2,3,7,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.PutRecordsV3_7Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("PutRecordsAsync"),sig231,3,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.PutRecordsAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("PutRecordsAsync"),sig231,3,3,7,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.PutRecordsAsyncV3_7Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("PutRecordsAsync"),sig232,3,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.PutRecordsAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("PutRecordsAsync"),sig232,3,3,7,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.PutRecordsAsyncV3_7Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Amazon.Lambda.RuntimeSupport"),(WCHAR*)WStr("Amazon.Lambda.RuntimeSupport.HandlerWrapper"),(WCHAR*)WStr("set_Handler"),sig313,2,1,4,0,1,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Lambda.HandlerWrapperSetHandlerIntegration"),CallTargetKind::Default,1,8}, {(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("CompleteMultipartUpload"),sig021,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.MultipartUploadManagement.CompleteMultipartUploadIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("CompleteMultipartUploadAsync"),sig232,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.MultipartUploadManagement.CompleteMultipartUploadAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("CompleteMultipartUploadAsync"),sig233,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.MultipartUploadManagement.CompleteMultipartUploadAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("CopyObject"),sig022,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.CopyObjectIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("CopyObjectAsync"),sig233,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.CopyObjectAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("CopyObjectAsync"),sig234,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.CopyObjectAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("DeleteBucket"),sig023,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.BucketManagement.DeleteBucketIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("DeleteBucketAsync"),sig234,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.BucketManagement.DeleteBucketAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("DeleteBucketAsync"),sig235,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.BucketManagement.DeleteBucketAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("DeleteObject"),sig024,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.DeleteObjectIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("DeleteObjectAsync"),sig235,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.DeleteObjectAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("DeleteObjectAsync"),sig236,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.DeleteObjectAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("DeleteObjects"),sig025,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.DeleteObjectsIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("DeleteObjectsAsync"),sig236,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.DeleteObjectsAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("DeleteObjectsAsync"),sig237,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.DeleteObjectsAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("GetObject"),sig026,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.GetObjectIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("GetObjectAsync"),sig237,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.GetObjectAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("GetObjectAsync"),sig238,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.GetObjectAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("InitiateMultipartUpload"),sig027,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.MultipartUploadManagement.InitiateMultipartUploadIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("InitiateMultipartUploadAsync"),sig238,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.MultipartUploadManagement.InitiateMultipartUploadAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("InitiateMultipartUploadAsync"),sig239,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.MultipartUploadManagement.InitiateMultipartUploadAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("ListBuckets"),sig028,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.BucketManagement.ListBucketsIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("ListBucketsAsync"),sig239,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.BucketManagement.ListBucketsAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("ListBucketsAsync"),sig240,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.BucketManagement.ListBucketsAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("ListObjectsV2"),sig029,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.ListObjectsV2Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("ListObjectsV2Async"),sig240,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.ListObjectsV2AsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("ListObjectsV2Async"),sig241,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.ListObjectsV2AsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("PutBucket"),sig030,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.BucketManagement.PutBucketIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("PutBucketAsync"),sig241,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.BucketManagement.PutBucketAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("PutBucketAsync"),sig242,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.BucketManagement.PutBucketAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("PutObject"),sig031,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.PutObjectIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("PutObjectAsync"),sig242,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.PutObjectAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("PutObjectAsync"),sig243,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.PutObjectAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("UploadPart"),sig032,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.MultipartUploadManagement.UploadPartIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("UploadPartAsync"),sig243,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.MultipartUploadManagement.UploadPartAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("UploadPartAsync"),sig244,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.MultipartUploadManagement.UploadPartAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.Core"),(WCHAR*)WStr("Amazon.Runtime.HttpWebRequestMessage"),(WCHAR*)WStr("ProcessHttpResponseMessage"),sig019,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SDK.HttpWebRequestMessageProcessHttpResponseMessageIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.Core"),(WCHAR*)WStr("Amazon.Runtime.Internal.RuntimePipeline"),(WCHAR*)WStr("InvokeAsync"),sig213,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SDK.RuntimePipelineInvokeAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.Core"),(WCHAR*)WStr("Amazon.Runtime.Internal.RuntimePipeline"),(WCHAR*)WStr("InvokeAsync"),sig214,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SDK.RuntimePipelineInvokeAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.Core"),(WCHAR*)WStr("Amazon.Runtime.Internal.RuntimePipeline"),(WCHAR*)WStr("InvokeSync"),sig020,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SDK.RuntimePipelineInvokeSyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.SimpleNotificationService"),(WCHAR*)WStr("Amazon.SimpleNotificationService.AmazonSimpleNotificationServiceClient"),(WCHAR*)WStr("Publish"),sig034,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SNS.PublishIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.SimpleNotificationService"),(WCHAR*)WStr("Amazon.SimpleNotificationService.AmazonSimpleNotificationServiceClient"),(WCHAR*)WStr("PublishAsync"),sig245,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SNS.PublishAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.SimpleNotificationService"),(WCHAR*)WStr("Amazon.SimpleNotificationService.AmazonSimpleNotificationServiceClient"),(WCHAR*)WStr("PublishAsync"),sig246,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SNS.PublishAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.SimpleNotificationService"),(WCHAR*)WStr("Amazon.SimpleNotificationService.AmazonSimpleNotificationServiceClient"),(WCHAR*)WStr("PublishBatch"),sig033,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SNS.PublishBatchIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.SimpleNotificationService"),(WCHAR*)WStr("Amazon.SimpleNotificationService.AmazonSimpleNotificationServiceClient"),(WCHAR*)WStr("PublishBatchAsync"),sig244,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SNS.PublishBatchAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.SimpleNotificationService"),(WCHAR*)WStr("Amazon.SimpleNotificationService.AmazonSimpleNotificationServiceClient"),(WCHAR*)WStr("PublishBatchAsync"),sig245,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SNS.PublishBatchAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("CreateQueue"),sig035,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.CreateQueueIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("CreateQueueAsync"),sig246,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.CreateQueueAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("CreateQueueAsync"),sig247,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.CreateQueueAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("DeleteMessage"),sig037,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.DeleteMessageIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("DeleteMessageAsync"),sig248,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.DeleteMessageAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("DeleteMessageAsync"),sig249,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.DeleteMessageAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("DeleteMessageBatch"),sig036,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.DeleteMessageBatchIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("DeleteMessageBatchAsync"),sig247,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.DeleteMessageBatchAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("DeleteMessageBatchAsync"),sig248,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.DeleteMessageBatchAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("DeleteQueue"),sig038,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.DeleteQueueIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("DeleteQueueAsync"),sig249,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.DeleteQueueAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("DeleteQueueAsync"),sig250,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.DeleteQueueAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("ReceiveMessage"),sig039,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.ReceiveMessageIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("ReceiveMessageAsync"),sig250,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.ReceiveMessageAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("ReceiveMessageAsync"),sig251,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.ReceiveMessageAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("SendMessage"),sig041,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.SendMessageIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("SendMessageAsync"),sig252,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.SendMessageAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("SendMessageAsync"),sig253,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.SendMessageAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("SendMessageBatch"),sig040,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.SendMessageBatchIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("SendMessageBatchAsync"),sig251,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.SendMessageBatchAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AWSSDK.SQS"),(WCHAR*)WStr("Amazon.SQS.AmazonSQSClient"),(WCHAR*)WStr("SendMessageBatchAsync"),sig252,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SQS.SendMessageBatchAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.StepFunctions"),(WCHAR*)WStr("Amazon.StepFunctions.AmazonStepFunctionsClient"),(WCHAR*)WStr("StartExecution"),sig042,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.StepFunctions.StartExecutionIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.StepFunctions"),(WCHAR*)WStr("Amazon.StepFunctions.AmazonStepFunctionsClient"),(WCHAR*)WStr("StartExecutionAsync"),sig043,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.StepFunctions.StartExecutionAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.StepFunctions"),(WCHAR*)WStr("Amazon.StepFunctions.AmazonStepFunctionsClient"),(WCHAR*)WStr("StartSyncExecution"),sig044,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.StepFunctions.StartSyncExecutionIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.StepFunctions"),(WCHAR*)WStr("Amazon.StepFunctions.AmazonStepFunctionsClient"),(WCHAR*)WStr("StartSyncExecutionAsync"),sig045,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.StepFunctions.StartSyncExecutionAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Azure.Messaging.EventHubs"),(WCHAR*)WStr("Azure.Core.Shared.MessagingClientDiagnostics"),(WCHAR*)WStr("InstrumentMessage"),sig346,5,5,9,2,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.EventHubs.InstrumentMessageIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Azure.Messaging.EventHubs"),(WCHAR*)WStr("Azure.Core.Shared.MessagingClientDiagnostics"),(WCHAR*)WStr("InstrumentMessage"),sig347,5,5,9,2,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.EventHubs.InstrumentMessageIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Azure.Messaging.EventHubs"),(WCHAR*)WStr("Azure.Messaging.EventHubs.Amqp.AmqpConsumer"),(WCHAR*)WStr("ReceiveAsync"),sig289,4,5,9,2,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.EventHubs.AmqpConsumerReceiveAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Azure.Messaging.EventHubs"),(WCHAR*)WStr("Azure.Messaging.EventHubs.Producer.EventDataBatch"),(WCHAR*)WStr("TryAdd"),sig121,2,5,9,2,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.EventHubs.EventDataBatchTryAddIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Azure.Messaging.EventHubs"),(WCHAR*)WStr("Azure.Messaging.EventHubs.Producer.EventHubProducerClient"),(WCHAR*)WStr("SendAsync"),sig175,3,5,9,2,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.EventHubs.EventHubProducerClientSendBatchAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Azure.Messaging.EventHubs"),(WCHAR*)WStr("Azure.Messaging.EventHubs.Producer.EventHubProducerClient"),(WCHAR*)WStr("SendAsync"),sig197,3,5,9,2,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.EventHubs.EventHubProducerClientSendEnumerableAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Azure.Functions.Worker.Core"),(WCHAR*)WStr("Microsoft.Azure.Functions.Worker.Pipeline.FunctionExecutionMiddleware"),(WCHAR*)WStr("Invoke"),sig194,2,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.Functions.FunctionExecutionMiddlewareInvokeIntegration"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Azure.Messaging.EventHubs"),(WCHAR*)WStr("Azure.Messaging.EventHubs.Producer.EventDataBatch"),(WCHAR*)WStr("TryAdd"),sig122,2,5,9,2,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.EventHubs.EventDataBatchTryAddIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Azure.Messaging.EventHubs"),(WCHAR*)WStr("Azure.Messaging.EventHubs.Producer.EventHubProducerClient"),(WCHAR*)WStr("SendAsync"),sig176,3,5,9,2,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.EventHubs.EventHubProducerClientSendBatchAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Azure.Messaging.EventHubs"),(WCHAR*)WStr("Azure.Messaging.EventHubs.Producer.EventHubProducerClient"),(WCHAR*)WStr("SendAsync"),sig198,3,5,9,2,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.EventHubs.EventHubProducerClientSendEnumerableAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Azure.Functions.Worker.Core"),(WCHAR*)WStr("Microsoft.Azure.Functions.Worker.Pipeline.FunctionExecutionMiddleware"),(WCHAR*)WStr("Invoke"),sig195,2,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.Functions.FunctionExecutionMiddlewareInvokeIntegration"),CallTargetKind::Default,1,14}, {(WCHAR*)WStr("Microsoft.Azure.WebJobs.Host"),(WCHAR*)WStr("Microsoft.Azure.WebJobs.Host.Executors.FunctionExecutor"),(WCHAR*)WStr("TryExecuteAsync"),sig264,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.Functions.AzureFunctionsExecutorTryExecuteAsyncIntegration"),CallTargetKind::Default,1,14}, {(WCHAR*)WStr("Microsoft.Azure.WebJobs.Script.Grpc"),(WCHAR*)WStr("Microsoft.Azure.WebJobs.Script.Grpc.GrpcMessageConversionExtensions"),(WCHAR*)WStr("ToRpcHttp"),sig265,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.Functions.GrpcMessageConversionExtensionsToRpcHttpIntegration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Microsoft.Azure.WebJobs.Script.WebHost"),(WCHAR*)WStr("Microsoft.Azure.WebJobs.Script.WebHost.Middleware.FunctionInvocationMiddleware"),(WCHAR*)WStr("Invoke"),sig191,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.Functions.FunctionInvocationMiddlewareInvokeIntegration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Core.Shared.MessagingClientDiagnostics"),(WCHAR*)WStr("InstrumentMessage"),sig346,5,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.InstrumentMessageIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ReceiverManager"),(WCHAR*)WStr("ProcessOneMessage"),sig177,3,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.ProcessMessageIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusMessageBatch"),(WCHAR*)WStr("TryAddMessage"),sig122,2,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.SendServiceBusMessageBatchIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Azure.WebJobs.Script.WebHost"),(WCHAR*)WStr("Microsoft.Azure.WebJobs.Script.WebHost.Middleware.FunctionInvocationMiddleware"),(WCHAR*)WStr("Invoke"),sig192,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.Functions.FunctionInvocationMiddlewareInvokeIntegration"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Core.Shared.MessagingClientDiagnostics"),(WCHAR*)WStr("InstrumentMessage"),sig347,5,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.InstrumentMessageIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ReceiverManager"),(WCHAR*)WStr("ProcessOneMessage"),sig178,3,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.ProcessMessageIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusMessageBatch"),(WCHAR*)WStr("TryAddMessage"),sig123,2,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.SendServiceBusMessageBatchIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusReceiver"),(WCHAR*)WStr("ReceiveMessagesAsync"),sig290,5,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.ServiceBusReceiverReceiveMessagesAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusSender"),(WCHAR*)WStr("CreateDiagnosticScope"),sig046,4,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.SendServiceBusMessagesIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusSender"),(WCHAR*)WStr("ScheduleMessagesAsync"),sig291,4,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.ServiceBusSenderScheduleMessagesAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusSender"),(WCHAR*)WStr("SendMessagesAsync"),sig176,3,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.ServiceBusSenderSendMessageBatchAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusSender"),(WCHAR*)WStr("SendMessagesAsync"),sig198,3,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.ServiceBusSenderSendMessagesAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.ContainerCore"),(WCHAR*)WStr("GetItemQueryIterator"),sig079,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.ContainerQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusSender"),(WCHAR*)WStr("SendMessagesAsync"),sig177,3,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.ServiceBusSenderSendMessageBatchAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusSender"),(WCHAR*)WStr("SendMessagesAsync"),sig199,3,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.ServiceBusSenderSendMessagesAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.ContainerCore"),(WCHAR*)WStr("GetItemQueryIterator"),sig080,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.ContainerQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.ContainerCore"),(WCHAR*)WStr("GetItemQueryStreamIterator"),sig079,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.ContainerQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.ContainerCore"),(WCHAR*)WStr("GetItemQueryIterator"),sig081,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.ContainerQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.ContainerCore"),(WCHAR*)WStr("GetItemQueryStreamIterator"),sig080,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.ContainerQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.CosmosClient"),(WCHAR*)WStr("GetDatabaseQueryIterator"),sig079,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.ClientQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.ContainerCore"),(WCHAR*)WStr("GetItemQueryStreamIterator"),sig081,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.ContainerQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.CosmosClient"),(WCHAR*)WStr("GetDatabaseQueryIterator"),sig080,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.ClientQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.CosmosClient"),(WCHAR*)WStr("GetDatabaseQueryStreamIterator"),sig079,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.ClientQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.CosmosClient"),(WCHAR*)WStr("GetDatabaseQueryIterator"),sig081,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.ClientQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.CosmosClient"),(WCHAR*)WStr("GetDatabaseQueryStreamIterator"),sig080,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.ClientQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.DatabaseCore"),(WCHAR*)WStr("GetContainerQueryIterator"),sig079,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.DatabaseQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.CosmosClient"),(WCHAR*)WStr("GetDatabaseQueryStreamIterator"),sig081,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.ClientQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.DatabaseCore"),(WCHAR*)WStr("GetContainerQueryIterator"),sig080,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.DatabaseQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.DatabaseCore"),(WCHAR*)WStr("GetContainerQueryStreamIterator"),sig079,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.DatabaseQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.DatabaseCore"),(WCHAR*)WStr("GetContainerQueryIterator"),sig081,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.DatabaseQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.DatabaseCore"),(WCHAR*)WStr("GetContainerQueryStreamIterator"),sig080,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.DatabaseQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.DatabaseCore"),(WCHAR*)WStr("GetUserQueryIterator"),sig079,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.DatabaseQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.DatabaseCore"),(WCHAR*)WStr("GetContainerQueryStreamIterator"),sig081,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.DatabaseQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.DatabaseCore"),(WCHAR*)WStr("GetUserQueryIterator"),sig080,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.DatabaseQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.Handlers.RequestInvokerHandler"),(WCHAR*)WStr("SendAsync"),sig263,11,3,12,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.RequestInvokerHandlerSendAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("ExecuteOp"),sig180,3,3,1,3,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("ExecuteOp"),sig181,3,3,0,7,3,1,2,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("ExecuteOp"),sig178,4,3,1,3,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegrationBis"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("ExecuteOp"),sig179,4,3,0,0,3,1,1,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegrationBis"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("ExecuteOp"),sig182,4,3,0,0,3,1,2,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegrationTer"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("SendAsync"),sig180,3,3,1,3,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("SendAsync"),sig181,3,3,0,7,3,1,2,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("SendAsync"),sig182,4,3,0,0,3,1,2,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegrationTer"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.DatabaseCore"),(WCHAR*)WStr("GetUserQueryIterator"),sig081,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.DatabaseQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("ExecuteOp"),sig181,3,3,1,3,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("ExecuteOp"),sig182,3,3,0,7,3,1,2,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("ExecuteOp"),sig179,4,3,1,3,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegrationBis"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("ExecuteOp"),sig180,4,3,0,0,3,1,1,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegrationBis"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("ExecuteOp"),sig183,4,3,0,0,3,1,2,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegrationTer"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("SendAsync"),sig181,3,3,1,3,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("SendAsync"),sig182,3,3,0,7,3,1,2,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("SendAsync"),sig183,4,3,0,0,3,1,2,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegrationTer"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.MultiplexingIOService"),(WCHAR*)WStr("Execute"),sig048,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.MultiplexingIOService"),(WCHAR*)WStr("Execute"),sig049,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.MultiplexingIOService"),(WCHAR*)WStr("Execute"),sig050,3,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteIntegrationBis"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.MultiplexingIOService"),(WCHAR*)WStr("ExecuteAsync"),sig183,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.MultiplexingIOService"),(WCHAR*)WStr("ExecuteAsync"),sig184,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.MultiplexingIOService"),(WCHAR*)WStr("ExecuteAsync"),sig185,3,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegrationBis"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.MultiplexingIOService"),(WCHAR*)WStr("ExecuteAsync"),sig185,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.MultiplexingIOService"),(WCHAR*)WStr("ExecuteAsync"),sig186,3,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegrationBis"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.PooledIOService"),(WCHAR*)WStr("Execute"),sig048,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.PooledIOService"),(WCHAR*)WStr("Execute"),sig049,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.PooledIOService"),(WCHAR*)WStr("Execute"),sig050,3,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteIntegrationBis"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.PooledIOService"),(WCHAR*)WStr("ExecuteAsync"),sig183,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.PooledIOService"),(WCHAR*)WStr("ExecuteAsync"),sig184,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.PooledIOService"),(WCHAR*)WStr("ExecuteAsync"),sig185,3,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegrationBis"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.PooledIOService"),(WCHAR*)WStr("ExecuteAsync"),sig185,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.PooledIOService"),(WCHAR*)WStr("ExecuteAsync"),sig186,3,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegrationBis"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.SharedPooledIOService"),(WCHAR*)WStr("Execute"),sig048,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.SharedPooledIOService"),(WCHAR*)WStr("Execute"),sig049,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.SharedPooledIOService"),(WCHAR*)WStr("Execute"),sig050,3,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteIntegrationBis"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.SharedPooledIOService"),(WCHAR*)WStr("ExecuteAsync"),sig183,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.SharedPooledIOService"),(WCHAR*)WStr("ExecuteAsync"),sig184,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.SharedPooledIOService"),(WCHAR*)WStr("ExecuteAsync"),sig185,3,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegrationBis"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackCustomEvent"),sig370,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackCustomEventIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackCustomEvent"),sig379,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackCustomEventMetadataIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackUserLoginFailureEvent"),sig374,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackUserLoginFailureEventIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackUserLoginFailureEvent"),sig377,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackUserLoginFailureEventMetadataIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackUserLoginSuccessEvent"),sig370,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackUserLoginSuccessEventIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackUserLoginSuccessEvent"),sig379,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackUserLoginSuccessEventMetadataIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdkV2"),(WCHAR*)WStr("TrackUserLoginFailure"),sig375,5,3,0,15,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdkV2.EventTrackingSdkV2TrackUserLoginFailureUserDetailsIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdkV2"),(WCHAR*)WStr("TrackUserLoginFailure"),sig378,5,3,0,15,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdkV2.EventTrackingSdkV2TrackUserLoginFailureUserIdIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdkV2"),(WCHAR*)WStr("TrackUserLoginSuccess"),sig372,4,3,0,15,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdkV2.EventTrackingSdkV2TrackUserLoginSuccessUserDetailsIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdkV2"),(WCHAR*)WStr("TrackUserLoginSuccess"),sig383,4,3,15,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdkV2.EventTrackingSdkV2TrackUserLoginSuccessUserIdIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Baggage"),(WCHAR*)WStr("get_Current"),sig131,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Baggage.Baggage_GetCurrent_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Baggage"),(WCHAR*)WStr("set_Current"),sig347,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Baggage.Baggage_SetCurrent_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.SharedPooledIOService"),(WCHAR*)WStr("ExecuteAsync"),sig185,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.SharedPooledIOService"),(WCHAR*)WStr("ExecuteAsync"),sig186,3,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegrationBis"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackCustomEvent"),sig371,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackCustomEventIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackCustomEvent"),sig380,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackCustomEventMetadataIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackUserLoginFailureEvent"),sig375,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackUserLoginFailureEventIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackUserLoginFailureEvent"),sig378,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackUserLoginFailureEventMetadataIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackUserLoginSuccessEvent"),sig371,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackUserLoginSuccessEventIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackUserLoginSuccessEvent"),sig380,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackUserLoginSuccessEventMetadataIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdkV2"),(WCHAR*)WStr("TrackUserLoginFailure"),sig376,5,3,0,15,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdkV2.EventTrackingSdkV2TrackUserLoginFailureUserDetailsIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdkV2"),(WCHAR*)WStr("TrackUserLoginFailure"),sig379,5,3,0,15,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdkV2.EventTrackingSdkV2TrackUserLoginFailureUserIdIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdkV2"),(WCHAR*)WStr("TrackUserLoginSuccess"),sig373,4,3,0,15,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdkV2.EventTrackingSdkV2TrackUserLoginSuccessUserDetailsIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdkV2"),(WCHAR*)WStr("TrackUserLoginSuccess"),sig384,4,3,15,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdkV2.EventTrackingSdkV2TrackUserLoginSuccessUserIdIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Baggage"),(WCHAR*)WStr("get_Current"),sig132,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Baggage.Baggage_GetCurrent_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Baggage"),(WCHAR*)WStr("set_Current"),sig348,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Baggage.Baggage_SetCurrent_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Ci.TestExtensions"),(WCHAR*)WStr("AddBenchmarkData"),sig318,5,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Ci.TestExtensionsAddBenchmarkDataIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Ci.TestExtensions"),(WCHAR*)WStr("SetBenchmarkMetadata"),sig317,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Ci.TestExtensionsSetBenchmarkMetadataIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Ci.TestExtensions"),(WCHAR*)WStr("SetParameters"),sig319,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Ci.TestExtensionsSetParametersIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Ci.TestModule"),(WCHAR*)WStr("InternalCreate"),sig052,5,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Ci.TestModuleInternalCreateIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Ci.TestSession"),(WCHAR*)WStr("InternalGetOrCreate"),sig053,6,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Ci.TestSessionInternalGetOrCreateIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.GlobalSettings"),(WCHAR*)WStr("SetDebugEnabled"),sig340,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.GlobalSettingsSetDebugEnabledIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationSettings"),(WCHAR*)WStr("get_AnalyticsEnabled"),sig157,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableIntegrationSettings.AnalyticsEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationSettings"),(WCHAR*)WStr("get_AnalyticsSampleRate"),sig141,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableIntegrationSettings.AnalyticsSampleRateGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationSettings"),(WCHAR*)WStr("get_Enabled"),sig157,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableIntegrationSettings.EnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationSettings"),(WCHAR*)WStr("get_IntegrationName"),sig167,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableIntegrationSettings.IntegrationNameGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.GlobalSettings"),(WCHAR*)WStr("SetDebugEnabled"),sig341,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.GlobalSettingsSetDebugEnabledIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationSettings"),(WCHAR*)WStr("get_AnalyticsEnabled"),sig158,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableIntegrationSettings.AnalyticsEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationSettings"),(WCHAR*)WStr("get_AnalyticsSampleRate"),sig142,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableIntegrationSettings.AnalyticsSampleRateGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationSettings"),(WCHAR*)WStr("get_Enabled"),sig158,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableIntegrationSettings.EnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationSettings"),(WCHAR*)WStr("get_IntegrationName"),sig168,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableIntegrationSettings.IntegrationNameGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationSettingsCollection"),(WCHAR*)WStr("get_Item"),sig056,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableIntegrationSettingsCollectionIndexerIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_AgentUri"),sig309,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.AgentUriIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_AnalyticsEnabled"),sig120,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.AnalyticsEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_CustomSamplingRules"),sig167,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.CustomSamplingRulesGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_Environment"),sig167,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.EnvironmentGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_AnalyticsEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.AnalyticsEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_CustomSamplingRules"),sig168,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.CustomSamplingRulesGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_Environment"),sig168,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.EnvironmentGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_Exporter"),sig055,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.ExporterGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_GlobalSamplingRate"),sig158,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.GlobalSamplingRateGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_GlobalTags"),sig133,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.GlobalTagsGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_GrpcTags"),sig133,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.GrpcTagsGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_HeaderTags"),sig133,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.HeaderTagsGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_GlobalSamplingRate"),sig159,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.GlobalSamplingRateGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_GlobalTags"),sig134,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.GlobalTagsGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_GrpcTags"),sig134,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.GrpcTagsGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_HeaderTags"),sig134,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.HeaderTagsGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_Integrations"),sig057,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.IntegrationsGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_KafkaCreateConsumerScopeEnabled"),sig120,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.KafkaCreateConsumerScopeEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_LogsInjectionEnabled"),sig120,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.LogsInjectionEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_MaxTracesSubmittedPerSecond"),sig145,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.MaxTracesSubmittedPerSecondGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_ServiceName"),sig167,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.ServiceNameGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_ServiceVersion"),sig167,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.ServiceVersionGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_StartupDiagnosticLogEnabled"),sig120,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.StartupDiagnosticLogEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_StatsComputationEnabled"),sig120,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.StatsComputationEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_TraceEnabled"),sig120,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.TraceEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_TracerMetricsEnabled"),sig120,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.TracerMetricsEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettings"),(WCHAR*)WStr("get_AnalyticsEnabled"),sig157,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.IntegrationSettings.AnalyticsEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettings"),(WCHAR*)WStr("get_AnalyticsSampleRate"),sig141,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.IntegrationSettings.AnalyticsSampleRateGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettings"),(WCHAR*)WStr("get_Enabled"),sig157,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.IntegrationSettings.EnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettings"),(WCHAR*)WStr("get_IntegrationName"),sig167,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.IntegrationSettings.IntegrationNameGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_KafkaCreateConsumerScopeEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.KafkaCreateConsumerScopeEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_LogsInjectionEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.LogsInjectionEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_MaxTracesSubmittedPerSecond"),sig146,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.MaxTracesSubmittedPerSecondGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_ServiceName"),sig168,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.ServiceNameGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_ServiceVersion"),sig168,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.ServiceVersionGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_StartupDiagnosticLogEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.StartupDiagnosticLogEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_StatsComputationEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.StatsComputationEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_TraceEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.TraceEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_TracerMetricsEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.TracerMetricsEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettings"),(WCHAR*)WStr("get_AnalyticsEnabled"),sig158,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.IntegrationSettings.AnalyticsEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettings"),(WCHAR*)WStr("get_AnalyticsSampleRate"),sig142,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.IntegrationSettings.AnalyticsSampleRateGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettings"),(WCHAR*)WStr("get_Enabled"),sig158,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.IntegrationSettings.EnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettings"),(WCHAR*)WStr("get_IntegrationName"),sig168,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.IntegrationSettings.IntegrationNameGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettingsCollection"),(WCHAR*)WStr("get_Item"),sig058,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.IntegrationSettingsCollectionIndexerIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr(".ctor"),sig310,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.CtorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr(".ctor"),sig340,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.CtorUseDefaultSourcesIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr(".ctor"),sig341,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.CtorUseDefaultSourcesIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("FromDefaultSources"),sig060,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.FromDefaultSourcesIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_AgentUri"),sig309,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.AgentUriGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_AnalyticsEnabled"),sig120,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.AnalyticsEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_CustomSamplingRules"),sig167,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.CustomSamplingRulesGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_DiagnosticSourceEnabled"),sig120,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.DiagnosticSourceEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_DisabledIntegrationNames"),sig129,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.DisabledIntegrationNamesGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_Environment"),sig167,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.EnvironmentGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_AnalyticsEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.AnalyticsEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_CustomSamplingRules"),sig168,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.CustomSamplingRulesGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_DiagnosticSourceEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.DiagnosticSourceEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_DisabledIntegrationNames"),sig130,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.DisabledIntegrationNamesGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_Environment"),sig168,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.EnvironmentGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_Exporter"),sig054,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.ExporterGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_GlobalSamplingRate"),sig158,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.GlobalSamplingRateGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_GlobalTags"),sig131,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.GlobalTagsGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_GrpcTags"),sig131,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.GrpcTagsGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_HeaderTags"),sig131,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.HeaderTagsGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_GlobalSamplingRate"),sig159,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.GlobalSamplingRateGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_GlobalTags"),sig132,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.GlobalTagsGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_GrpcTags"),sig132,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.GrpcTagsGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_HeaderTags"),sig132,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.HeaderTagsGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_Integrations"),sig059,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.IntegrationsGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_KafkaCreateConsumerScopeEnabled"),sig120,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.KafkaCreateConsumerScopeEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_LogsInjectionEnabled"),sig120,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.LogsInjectionEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_MaxTracesSubmittedPerSecond"),sig145,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.MaxTracesSubmittedPerSecondGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_ServiceName"),sig167,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.ServiceNameGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_ServiceVersion"),sig167,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.ServiceVersionGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_StartupDiagnosticLogEnabled"),sig120,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.StartupDiagnosticLogEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_StatsComputationEnabled"),sig120,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.StatsComputationEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_TraceEnabled"),sig120,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.TraceEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_TracerMetricsEnabled"),sig120,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.TracerMetricsEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("PopulateDictionary"),sig344,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.PopulateDictionaryIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("set_DiagnosticSourceEnabled"),sig340,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.DiagnosticSourceEnabledSetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_KafkaCreateConsumerScopeEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.KafkaCreateConsumerScopeEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_LogsInjectionEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.LogsInjectionEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_MaxTracesSubmittedPerSecond"),sig146,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.MaxTracesSubmittedPerSecondGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_ServiceName"),sig168,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.ServiceNameGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_ServiceVersion"),sig168,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.ServiceVersionGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_StartupDiagnosticLogEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.StartupDiagnosticLogEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_StatsComputationEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.StatsComputationEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_TraceEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.TraceEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_TracerMetricsEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.TracerMetricsEnabledGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("PopulateDictionary"),sig345,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.PopulateDictionaryIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("set_DiagnosticSourceEnabled"),sig341,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.DiagnosticSourceEnabledSetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.ExtensionMethods.SpanExtensions"),(WCHAR*)WStr("SetTraceSamplingPriority"),sig320,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetTraceSamplingPriorityIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.FeatureFlagsSdk"),(WCHAR*)WStr("Evaluate"),sig061,5,3,31,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkEvaluateIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.FeatureFlagsSdk"),(WCHAR*)WStr("IsAvailable"),sig121,1,3,31,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkIsAvailableIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.FeatureFlagsSdk"),(WCHAR*)WStr("RegisterOnNewConfigEventHandler"),sig339,2,3,31,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextExtractor"),(WCHAR*)WStr(".ctor"),sig310,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorConstructorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextExtractor"),(WCHAR*)WStr("Extract"),sig067,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextExtractor"),(WCHAR*)WStr("ExtractIncludingDsm"),sig068,5,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIncludingDsmIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextExtractor"),(WCHAR*)WStr("Extract"),sig068,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextExtractor"),(WCHAR*)WStr("ExtractIncludingDsm"),sig069,5,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIncludingDsmIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextInjector"),(WCHAR*)WStr(".ctor"),sig310,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextInjectorConstructorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextInjector"),(WCHAR*)WStr("Inject"),sig311,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextInjectorInjectIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextInjector"),(WCHAR*)WStr("InjectIncludingDsm"),sig312,6,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextInjectorInjectIncludingDsmIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanExtensions"),(WCHAR*)WStr("SetTag"),sig065,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetTagIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanExtensions"),(WCHAR*)WStr("SetTag"),sig066,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetTagIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanExtensions"),(WCHAR*)WStr("SetUser"),sig321,9,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetUserIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr(".ctor"),sig363,3,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.CtorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("Configure"),sig343,2,3,7,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.ConfigureIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("Configure"),sig343,2,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.ConfigureIntegration_Pre3_7"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("Datadog.Trace.IDatadogOpenTracingTracer.StartSpan"),sig066,6,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.StartSpanIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("ForceFlushAsync"),sig174,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.ForceFlushAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("get_ActiveScope"),sig061,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.GetActiveScopeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("get_DefaultServiceName"),sig167,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.GetDefaultServiceNameIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("GetAutomaticTracerInstance"),sig159,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.GetAutomaticTracerInstanceIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("GetUpdatedImmutableTracerSettings"),sig130,3,3,7,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.GetUpdatedImmutableTracerSettingsIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("StartActive"),sig063,6,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.StartActiveImplementationIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("StartActive"),sig062,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.StartActiveOperationNameIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("StartActive"),sig064,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.StartActiveSpanCreationSettingsIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.OpenTracing"),(WCHAR*)WStr("Datadog.Trace.OpenTracing.OpenTracingTracerFactory"),(WCHAR*)WStr("CreateTracer"),sig111,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.OpenTracing.OpenTracingTracerFactoryCreateTracerIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.OpenTracing"),(WCHAR*)WStr("Datadog.Trace.OpenTracing.OpenTracingTracerFactory"),(WCHAR*)WStr("WrapTracer"),sig110,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.OpenTracing.OpenTracingTracerFactoryWrapTracerIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace"),(WCHAR*)WStr("Datadog.Trace.Util.ProcessHelpers"),(WCHAR*)WStr("StartWithDoNotTrace"),sig140,3,2,49,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.VersionConflict.ProcessHelpersStartWithDoNotTraceIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr(".ctor"),sig364,3,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.CtorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("Configure"),sig344,2,3,7,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.ConfigureIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("Configure"),sig344,2,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.ConfigureIntegration_Pre3_7"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("Datadog.Trace.IDatadogOpenTracingTracer.StartSpan"),sig067,6,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.StartSpanIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("ForceFlushAsync"),sig175,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.ForceFlushAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("get_ActiveScope"),sig062,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.GetActiveScopeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("get_DefaultServiceName"),sig168,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.GetDefaultServiceNameIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("GetAutomaticTracerInstance"),sig160,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.GetAutomaticTracerInstanceIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("GetUpdatedImmutableTracerSettings"),sig131,3,3,7,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.GetUpdatedImmutableTracerSettingsIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("StartActive"),sig064,6,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.StartActiveImplementationIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("StartActive"),sig063,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.StartActiveOperationNameIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("StartActive"),sig065,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.StartActiveSpanCreationSettingsIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.OpenTracing"),(WCHAR*)WStr("Datadog.Trace.OpenTracing.OpenTracingTracerFactory"),(WCHAR*)WStr("CreateTracer"),sig112,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.OpenTracing.OpenTracingTracerFactoryCreateTracerIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.OpenTracing"),(WCHAR*)WStr("Datadog.Trace.OpenTracing.OpenTracingTracerFactory"),(WCHAR*)WStr("WrapTracer"),sig111,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.OpenTracing.OpenTracingTracerFactoryWrapTracerIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace"),(WCHAR*)WStr("Datadog.Trace.Util.ProcessHelpers"),(WCHAR*)WStr("StartWithDoNotTrace"),sig141,3,2,49,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.VersionConflict.ProcessHelpersStartWithDoNotTraceIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("coverlet.core"),(WCHAR*)WStr("Coverlet.Core.Coverage"),(WCHAR*)WStr("GetCoverageResult"),sig051,1,3,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.CoverageGetCoverageResultIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("dotnet"),(WCHAR*)WStr("Microsoft.DotNet.Tools.Test.TestCommand"),(WCHAR*)WStr(".ctor"),sig357,6,2,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.TestCommand5ctorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("dotnet"),(WCHAR*)WStr("Microsoft.DotNet.Tools.Test.TestCommand"),(WCHAR*)WStr(".ctor"),sig356,4,6,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.TestCommandctorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("dotnet"),(WCHAR*)WStr("Microsoft.DotNet.Tools.Test.TestCommand"),(WCHAR*)WStr("Run"),sig150,2,2,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.TestCommandRunIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("dotnet"),(WCHAR*)WStr("Microsoft.DotNet.Tools.Test.TestCommand"),(WCHAR*)WStr(".ctor"),sig358,6,2,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.TestCommand5ctorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("dotnet"),(WCHAR*)WStr("Microsoft.DotNet.Tools.Test.TestCommand"),(WCHAR*)WStr(".ctor"),sig357,4,6,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.TestCommandctorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("dotnet"),(WCHAR*)WStr("Microsoft.DotNet.Tools.Test.TestCommand"),(WCHAR*)WStr("Run"),sig151,2,2,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.TestCommandRunIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TraceDataCollector"),(WCHAR*)WStr("Microsoft.VisualStudio.TraceCollector.VanguardCollector.ManagedVanguard"),(WCHAR*)WStr("Stop"),sig310,1,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.ManagedVanguardStopIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("vstest.console"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.CommandLine.Executor"),(WCHAR*)WStr("Execute"),sig148,2,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.ExecutorExecuteIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("vstest.console"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.CommandLine.Executor"),(WCHAR*)WStr("GetArgumentProcessors"),sig149,3,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.ExecutorGetArgumentProcessorsIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("vstest.console.arm64"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.CommandLine.Executor"),(WCHAR*)WStr("Execute"),sig148,2,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.ExecutorExecuteIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("vstest.console.arm64"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.CommandLine.Executor"),(WCHAR*)WStr("GetArgumentProcessors"),sig149,3,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.ExecutorGetArgumentProcessorsIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("vstest.console"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.CommandLine.Executor"),(WCHAR*)WStr("Execute"),sig149,2,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.ExecutorExecuteIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("vstest.console"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.CommandLine.Executor"),(WCHAR*)WStr("GetArgumentProcessors"),sig150,3,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.ExecutorGetArgumentProcessorsIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("vstest.console.arm64"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.CommandLine.Executor"),(WCHAR*)WStr("Execute"),sig149,2,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.ExecutorExecuteIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("vstest.console.arm64"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.CommandLine.Executor"),(WCHAR*)WStr("GetArgumentProcessors"),sig150,3,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.ExecutorGetArgumentProcessorsIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Elasticsearch.Net"),(WCHAR*)WStr("Elasticsearch.Net.RequestPipeline"),(WCHAR*)WStr("CallElasticsearch"),sig005,2,6,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Elasticsearch.V6.RequestPipeline_CallElasticsearch_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Elasticsearch.Net"),(WCHAR*)WStr("Elasticsearch.Net.RequestPipeline"),(WCHAR*)WStr("CallElasticsearch"),sig069,2,5,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Elasticsearch.V5.RequestPipeline_CallElasticsearch_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Elasticsearch.Net"),(WCHAR*)WStr("Elasticsearch.Net.RequestPipeline"),(WCHAR*)WStr("CallElasticsearchAsync"),sig215,3,6,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Elasticsearch.V6.RequestPipeline_CallElasticsearchAsync_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Elasticsearch.Net"),(WCHAR*)WStr("Elasticsearch.Net.RequestPipeline"),(WCHAR*)WStr("CallElasticsearchAsync"),sig254,3,5,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Elasticsearch.V5.RequestPipeline_CallElasticsearchAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Elasticsearch.Net"),(WCHAR*)WStr("Elasticsearch.Net.RequestPipeline"),(WCHAR*)WStr("CallElasticsearch"),sig070,2,5,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Elasticsearch.V5.RequestPipeline_CallElasticsearch_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Elasticsearch.Net"),(WCHAR*)WStr("Elasticsearch.Net.RequestPipeline"),(WCHAR*)WStr("CallElasticsearchAsync"),sig216,3,6,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Elasticsearch.V6.RequestPipeline_CallElasticsearchAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Elasticsearch.Net"),(WCHAR*)WStr("Elasticsearch.Net.RequestPipeline"),(WCHAR*)WStr("CallElasticsearchAsync"),sig255,3,5,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Elasticsearch.V5.RequestPipeline_CallElasticsearchAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Elasticsearch.Net"),(WCHAR*)WStr("Elasticsearch.Net.Transport`1"),(WCHAR*)WStr("Request"),sig004,5,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Elasticsearch.V7.Transport_Request_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Elasticsearch.Net"),(WCHAR*)WStr("Elasticsearch.Net.Transport`1"),(WCHAR*)WStr("RequestAsync"),sig214,6,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Elasticsearch.V7.Transport_RequestAsync_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Execution.ExecutionStrategy"),(WCHAR*)WStr("ExecuteAsync"),sig209,2,2,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Execution.ExecutionStrategy"),(WCHAR*)WStr("ExecuteAsync"),sig209,2,5,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ExecuteAsyncIntegrationV5AndV7"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Execution.SubscriptionExecutionStrategy"),(WCHAR*)WStr("ExecuteAsync"),sig209,2,2,3,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Execution.SubscriptionExecutionStrategy"),(WCHAR*)WStr("ExecuteAsync"),sig209,2,5,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ExecuteAsyncIntegrationV5AndV7"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Validation.DocumentValidator"),(WCHAR*)WStr("Validate"),sig070,7,2,3,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ValidateIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Validation.DocumentValidator"),(WCHAR*)WStr("ValidateAsync"),sig220,7,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ValidateAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Validation.DocumentValidator"),(WCHAR*)WStr("ValidateAsync"),sig216,7,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ValidateAsyncIntegrationV4"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Validation.DocumentValidator"),(WCHAR*)WStr("ValidateAsyncCoreAsync"),sig217,3,5,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ValidateAsyncIntegrationV5AndV7"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Validation.DocumentValidator"),(WCHAR*)WStr("ValidateAsyncCoreAsync"),sig217,3,7,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ValidateAsyncIntegrationV8"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("GraphQL.SystemReactive"),(WCHAR*)WStr("GraphQL.Execution.SubscriptionExecutionStrategy"),(WCHAR*)WStr("ExecuteAsync"),sig209,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.ParsingPrimitives"),(WCHAR*)WStr("ReadRawString"),sig169,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcAspNetCoreServer.IAST.ParsingPrimitivesReadRawStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Grpc.AspNetCore.Server"),(WCHAR*)WStr("Grpc.AspNetCore.Server.Internal.CallHandlers.ServerCallHandlerBase`3"),(WCHAR*)WStr("HandleCallAsync"),sig191,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcAspNetCoreServer.ServerCallHandlerBaseHandleCallAsyncIntegration"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Elasticsearch.Net"),(WCHAR*)WStr("Elasticsearch.Net.Transport`1"),(WCHAR*)WStr("RequestAsync"),sig215,6,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Elasticsearch.V7.Transport_RequestAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Execution.ExecutionStrategy"),(WCHAR*)WStr("ExecuteAsync"),sig210,2,2,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Execution.ExecutionStrategy"),(WCHAR*)WStr("ExecuteAsync"),sig210,2,5,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ExecuteAsyncIntegrationV5AndV7"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Execution.SubscriptionExecutionStrategy"),(WCHAR*)WStr("ExecuteAsync"),sig210,2,2,3,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Execution.SubscriptionExecutionStrategy"),(WCHAR*)WStr("ExecuteAsync"),sig210,2,5,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ExecuteAsyncIntegrationV5AndV7"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Validation.DocumentValidator"),(WCHAR*)WStr("Validate"),sig071,7,2,3,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ValidateIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Validation.DocumentValidator"),(WCHAR*)WStr("ValidateAsync"),sig221,7,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ValidateAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Validation.DocumentValidator"),(WCHAR*)WStr("ValidateAsync"),sig217,7,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ValidateAsyncIntegrationV4"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Validation.DocumentValidator"),(WCHAR*)WStr("ValidateAsyncCoreAsync"),sig218,3,5,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ValidateAsyncIntegrationV5AndV7"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("GraphQL"),(WCHAR*)WStr("GraphQL.Validation.DocumentValidator"),(WCHAR*)WStr("ValidateAsyncCoreAsync"),sig218,3,7,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ValidateAsyncIntegrationV8"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("GraphQL.SystemReactive"),(WCHAR*)WStr("GraphQL.Execution.SubscriptionExecutionStrategy"),(WCHAR*)WStr("ExecuteAsync"),sig210,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.ParsingPrimitives"),(WCHAR*)WStr("ReadRawString"),sig170,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcAspNetCoreServer.IAST.ParsingPrimitivesReadRawStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Grpc.AspNetCore.Server"),(WCHAR*)WStr("Grpc.AspNetCore.Server.Internal.CallHandlers.ServerCallHandlerBase`3"),(WCHAR*)WStr("HandleCallAsync"),sig192,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcAspNetCoreServer.ServerCallHandlerBaseHandleCallAsyncIntegration"),CallTargetKind::Default,1,14}, {(WCHAR*)WStr("Grpc.AspNetCore.Server"),(WCHAR*)WStr("Grpc.AspNetCore.Server.Internal.GrpcProtocolHelpers"),(WCHAR*)WStr("BuildHttpErrorResponse"),sig329,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcAspNetCoreServer.GrpcProtocolHelpersBuildHttpErrorResponseIntegration"),CallTargetKind::Default,1,14}, {(WCHAR*)WStr("Grpc.AspNetCore.Server"),(WCHAR*)WStr("Grpc.AspNetCore.Server.Internal.HttpContextServerCallContext"),(WCHAR*)WStr("LogCallEnd"),sig310,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcAspNetCoreServer.HttpContextServerCallContextLogCallEndIntegration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.DefaultCallInvoker"),(WCHAR*)WStr("CreateCall"),sig071,4,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Client.DefaultCallInvokerInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.AsyncCall`2"),(WCHAR*)WStr("HandleFinished"),sig341,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Client.AsyncCallHandleFinishedInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.AsyncCall`2"),(WCHAR*)WStr("HandleUnaryResponse"),sig342,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Client.AsyncCallHandleUnaryResponseInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.AsyncCallServer`2"),(WCHAR*)WStr("SendInitialMetadataAsync"),sig187,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.AsyncCallServerSendInitialMetadataAsyncInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.AsyncCallServer`2"),(WCHAR*)WStr("SendStatusFromServerAsync"),sig188,4,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.AsyncCallServerSendStatusFromServerAsyncInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.ClientStreamingServerCallHandler`2"),(WCHAR*)WStr("HandleCall"),sig186,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.ServerCallHandlerInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.DuplexStreamingServerCallHandler`2"),(WCHAR*)WStr("HandleCall"),sig186,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.ServerCallHandlerInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.MetadataArraySafeHandle"),(WCHAR*)WStr("Create"),sig072,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Client.MetadataArraySafeHandleCreateInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.ServerStreamingServerCallHandler`2"),(WCHAR*)WStr("HandleCall"),sig186,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.ServerCallHandlerInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.UnaryServerCallHandler`2"),(WCHAR*)WStr("HandleCall"),sig186,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.ServerCallHandlerInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Grpc.Net.Client"),(WCHAR*)WStr("Grpc.Net.Client.Internal.GrpcCall`2"),(WCHAR*)WStr("FinishCall"),sig359,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcNetClient.GrpcCallFinishCallIntegration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Grpc.Net.Client"),(WCHAR*)WStr("Grpc.Net.Client.Internal.GrpcCall`2"),(WCHAR*)WStr("FinishCall"),sig360,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcNetClient.GrpcCallFinishCallPre243Integration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Grpc.Net.Client"),(WCHAR*)WStr("Grpc.Net.Client.Internal.GrpcCall`2"),(WCHAR*)WStr("RunCall"),sig200,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcNetClient.GrpcCallRunCallIntegration"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.DefaultCallInvoker"),(WCHAR*)WStr("CreateCall"),sig072,4,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Client.DefaultCallInvokerInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.AsyncCall`2"),(WCHAR*)WStr("HandleFinished"),sig342,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Client.AsyncCallHandleFinishedInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.AsyncCall`2"),(WCHAR*)WStr("HandleUnaryResponse"),sig343,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Client.AsyncCallHandleUnaryResponseInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.AsyncCallServer`2"),(WCHAR*)WStr("SendInitialMetadataAsync"),sig188,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.AsyncCallServerSendInitialMetadataAsyncInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.AsyncCallServer`2"),(WCHAR*)WStr("SendStatusFromServerAsync"),sig189,4,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.AsyncCallServerSendStatusFromServerAsyncInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.ClientStreamingServerCallHandler`2"),(WCHAR*)WStr("HandleCall"),sig187,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.ServerCallHandlerInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.DuplexStreamingServerCallHandler`2"),(WCHAR*)WStr("HandleCall"),sig187,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.ServerCallHandlerInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.MetadataArraySafeHandle"),(WCHAR*)WStr("Create"),sig073,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Client.MetadataArraySafeHandleCreateInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.ServerStreamingServerCallHandler`2"),(WCHAR*)WStr("HandleCall"),sig187,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.ServerCallHandlerInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.UnaryServerCallHandler`2"),(WCHAR*)WStr("HandleCall"),sig187,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.ServerCallHandlerInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Grpc.Net.Client"),(WCHAR*)WStr("Grpc.Net.Client.Internal.GrpcCall`2"),(WCHAR*)WStr("FinishCall"),sig360,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcNetClient.GrpcCallFinishCallIntegration"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Grpc.Net.Client"),(WCHAR*)WStr("Grpc.Net.Client.Internal.GrpcCall`2"),(WCHAR*)WStr("FinishCall"),sig361,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcNetClient.GrpcCallFinishCallPre243Integration"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Grpc.Net.Client"),(WCHAR*)WStr("Grpc.Net.Client.Internal.GrpcCall`2"),(WCHAR*)WStr("RunCall"),sig201,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcNetClient.GrpcCallRunCallIntegration"),CallTargetKind::Default,1,14}, {(WCHAR*)WStr("Hangfire.Core"),(WCHAR*)WStr("Hangfire.Common.JobFilterCollection"),(WCHAR*)WStr(".ctor"),sig310,1,1,7,0,1,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Hangfire.JobFilterCollectionCtorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Security.Cryptography"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHash"),sig127,4,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegration"),CallTargetKind::Default,4,14}, -{(WCHAR*)WStr("System.Security.Cryptography"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHash"),sig128,2,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegrationBis"),CallTargetKind::Default,4,14}, -{(WCHAR*)WStr("System.Security.Cryptography"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHash"),sig126,2,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegrationBis"),CallTargetKind::Default,4,14}, -{(WCHAR*)WStr("System.Security.Cryptography"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHashAsync"),sig199,3,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegrationTer"),CallTargetKind::Default,4,14}, -{(WCHAR*)WStr("System.Security.Cryptography.Primitives"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHash"),sig127,4,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegration"),CallTargetKind::Default,4,14}, -{(WCHAR*)WStr("System.Security.Cryptography.Primitives"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHash"),sig128,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegrationBis"),CallTargetKind::Default,4,14}, -{(WCHAR*)WStr("System.Security.Cryptography.Primitives"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHash"),sig126,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegrationBis"),CallTargetKind::Default,4,14}, -{(WCHAR*)WStr("System.Security.Cryptography.Primitives"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHashAsync"),sig199,3,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegrationTer"),CallTargetKind::Default,4,14}, -{(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.Processing.MutationExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig257,2,11,0,0,11,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegrationExtra"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.Processing.QueryExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig257,2,11,0,0,12,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegrationExtra"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.Processing.QueryExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig259,2,13,0,0,13,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegrationExtraV13"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.Processing.QueryExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig258,2,14,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegrationExtraV13"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.RequestExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig256,3,11,0,0,12,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.RequestExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig256,3,13,0,0,13,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegrationV13"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.RequestExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig255,3,14,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegrationV14"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Security.Cryptography"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHash"),sig128,4,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegration"),CallTargetKind::Default,4,14}, +{(WCHAR*)WStr("System.Security.Cryptography"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHash"),sig129,2,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegrationBis"),CallTargetKind::Default,4,14}, +{(WCHAR*)WStr("System.Security.Cryptography"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHash"),sig127,2,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegrationBis"),CallTargetKind::Default,4,14}, +{(WCHAR*)WStr("System.Security.Cryptography"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHashAsync"),sig200,3,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegrationTer"),CallTargetKind::Default,4,14}, +{(WCHAR*)WStr("System.Security.Cryptography.Primitives"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHash"),sig128,4,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegration"),CallTargetKind::Default,4,14}, +{(WCHAR*)WStr("System.Security.Cryptography.Primitives"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHash"),sig129,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegrationBis"),CallTargetKind::Default,4,14}, +{(WCHAR*)WStr("System.Security.Cryptography.Primitives"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHash"),sig127,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegrationBis"),CallTargetKind::Default,4,14}, +{(WCHAR*)WStr("System.Security.Cryptography.Primitives"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHashAsync"),sig200,3,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegrationTer"),CallTargetKind::Default,4,14}, +{(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.Processing.MutationExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig258,2,11,0,0,11,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegrationExtra"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.Processing.QueryExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig258,2,11,0,0,12,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegrationExtra"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.Processing.QueryExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig260,2,13,0,0,13,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegrationExtraV13"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.Processing.QueryExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig259,2,14,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegrationExtraV13"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.RequestExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig257,3,11,0,0,12,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.RequestExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig257,3,13,0,0,13,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegrationV13"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.RequestExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig256,3,14,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegrationV14"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.CurlHandler"),(WCHAR*)WStr("SendAsync"),sig296,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.CurlHandler.CurlHandlerIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.HttpClientHandler"),(WCHAR*)WStr("Send"),sig153,3,5,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.HttpClientHandler.HttpClientHandlerSyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.HttpClientHandler"),(WCHAR*)WStr("Send"),sig154,3,5,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.HttpClientHandler.HttpClientHandlerSyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.HttpClientHandler"),(WCHAR*)WStr("SendAsync"),sig296,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.HttpClientHandler.HttpClientHandlerIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.SocketsHttpHandler"),(WCHAR*)WStr("Send"),sig153,3,5,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.SocketsHttpHandler.SocketsHttpHandlerSyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.SocketsHttpHandler"),(WCHAR*)WStr("Send"),sig154,3,5,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.SocketsHttpHandler.SocketsHttpHandlerSyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.SocketsHttpHandler"),(WCHAR*)WStr("SendAsync"),sig296,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.SocketsHttpHandler.SocketsHttpHandlerIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.WinHttpHandler"),(WCHAR*)WStr("SendAsync"),sig296,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.WinHttpHandler.WinHttpHandlerIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Net.Http.WinHttpHandler"),(WCHAR*)WStr("System.Net.Http.WinHttpHandler"),(WCHAR*)WStr("SendAsync"),sig296,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.WinHttpHandler.WinHttpHandlerIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Yarp.ReverseProxy"),(WCHAR*)WStr("Yarp.ReverseProxy.Forwarder.ForwarderHttpClientFactory"),(WCHAR*)WStr("ConfigureHandler"),sig389,3,1,1,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.SocketsHttpHandler.YarpForwarderHttpClientFactoryIntegration"),CallTargetKind::Default,1,8}, +{(WCHAR*)WStr("Yarp.ReverseProxy"),(WCHAR*)WStr("Yarp.ReverseProxy.Forwarder.ForwarderHttpClientFactory"),(WCHAR*)WStr("ConfigureHandler"),sig390,3,1,1,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.SocketsHttpHandler.YarpForwarderHttpClientFactoryIntegration"),CallTargetKind::Default,1,8}, {(WCHAR*)WStr("amqmdnetstd"),(WCHAR*)WStr("IBM.WMQ.MQDestination"),(WCHAR*)WStr("Get"),sig326,4,9,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.IbmMq.GetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("amqmdnetstd"),(WCHAR*)WStr("IBM.WMQ.MQDestination"),(WCHAR*)WStr("Put"),sig327,3,9,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.IbmMq.PutIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Logging"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactory"),(WCHAR*)WStr(".ctor"),sig349,3,2,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.LoggerFactoryConstructorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Logging"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactory"),(WCHAR*)WStr(".ctor"),sig350,4,5,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.LoggerFactoryConstructorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Logging"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactory"),(WCHAR*)WStr(".ctor"),sig351,5,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.LoggerFactoryConstructorNet7Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Logging"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactoryScopeProvider"),(WCHAR*)WStr("ForEachScope"),sig339,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.LoggerFactoryScopeProviderForEachScopeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Logging.Abstractions"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerExternalScopeProvider"),(WCHAR*)WStr("ForEachScope"),sig339,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.LoggerExternalScopeProviderForEachScopeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Telemetry"),(WCHAR*)WStr("Microsoft.Extensions.Logging.ExtendedLoggerFactory"),(WCHAR*)WStr(".ctor"),sig353,12,9,5,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.ExtendedLoggerFactoryConstructorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Telemetry"),(WCHAR*)WStr("Microsoft.Extensions.Logging.ExtendedLoggerFactory"),(WCHAR*)WStr(".ctor"),sig354,10,8,0,0,9,3,0,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.ExtendedLoggerFactoryConstructorIntegration_8xx"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Telemetry"),(WCHAR*)WStr("Microsoft.Extensions.Logging.ExtendedLoggerFactory"),(WCHAR*)WStr(".ctor"),sig352,11,9,3,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.ExtendedLoggerFactoryConstructorIntegration_930_940"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Telemetry"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactoryScopeProvider"),(WCHAR*)WStr("ForEachScope"),sig339,3,8,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.LoggerFactoryScopeProviderForEachScopeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Logging"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactory"),(WCHAR*)WStr(".ctor"),sig350,3,2,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.LoggerFactoryConstructorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Logging"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactory"),(WCHAR*)WStr(".ctor"),sig351,4,5,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.LoggerFactoryConstructorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Logging"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactory"),(WCHAR*)WStr(".ctor"),sig352,5,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.LoggerFactoryConstructorNet7Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Logging"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactoryScopeProvider"),(WCHAR*)WStr("ForEachScope"),sig340,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.LoggerFactoryScopeProviderForEachScopeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Logging.Abstractions"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerExternalScopeProvider"),(WCHAR*)WStr("ForEachScope"),sig340,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.LoggerExternalScopeProviderForEachScopeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Telemetry"),(WCHAR*)WStr("Microsoft.Extensions.Logging.ExtendedLoggerFactory"),(WCHAR*)WStr(".ctor"),sig354,12,9,5,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.ExtendedLoggerFactoryConstructorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Telemetry"),(WCHAR*)WStr("Microsoft.Extensions.Logging.ExtendedLoggerFactory"),(WCHAR*)WStr(".ctor"),sig355,10,8,0,0,9,3,0,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.ExtendedLoggerFactoryConstructorIntegration_8xx"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Telemetry"),(WCHAR*)WStr("Microsoft.Extensions.Logging.ExtendedLoggerFactory"),(WCHAR*)WStr(".ctor"),sig353,11,9,3,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.ExtendedLoggerFactoryConstructorIntegration_930_940"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Telemetry"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactoryScopeProvider"),(WCHAR*)WStr("ForEachScope"),sig340,3,8,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.LoggerFactoryScopeProviderForEachScopeIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr(".ctor"),sig314,2,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerConstructorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Close"),sig310,1,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerCloseIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Commit"),sig132,1,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerCommitAllIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Commit"),sig348,2,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerCommitIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Commit"),sig133,1,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerCommitAllIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Commit"),sig349,2,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerCommitIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Consume"),sig047,2,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerConsumeIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Dispose"),sig310,1,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerDisposeIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Unsubscribe"),sig310,1,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerUnsubscribeIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Producer`2"),(WCHAR*)WStr(".ctor"),sig315,2,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaProducerConstructorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Producer`2"),(WCHAR*)WStr("Produce"),sig316,4,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaProduceSyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Producer`2"),(WCHAR*)WStr("ProduceAsync"),sig253,4,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaProduceAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Producer`2+TypedDeliveryHandlerShim_Action"),(WCHAR*)WStr(".ctor"),sig371,5,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaProduceSyncDeliveryHandlerIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("log4net"),(WCHAR*)WStr("log4net.Appender.AppenderCollection"),(WCHAR*)WStr("ToArray"),sig073,1,2,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.Log4Net.DirectSubmission.AppenderCollectionIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("log4net"),(WCHAR*)WStr("log4net.Appender.AppenderCollection"),(WCHAR*)WStr("ToArray"),sig073,1,1,0,0,1,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.Log4Net.DirectSubmission.AppenderCollectionLegacyIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("log4net"),(WCHAR*)WStr("log4net.Util.AppenderAttachedImpl"),(WCHAR*)WStr("AppendLoopOnAppenders"),sig146,2,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Log4Net.AppenderAttachedImplIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Producer`2"),(WCHAR*)WStr("ProduceAsync"),sig254,4,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaProduceAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Producer`2+TypedDeliveryHandlerShim_Action"),(WCHAR*)WStr(".ctor"),sig372,5,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaProduceSyncDeliveryHandlerIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("log4net"),(WCHAR*)WStr("log4net.Appender.AppenderCollection"),(WCHAR*)WStr("ToArray"),sig074,1,2,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.Log4Net.DirectSubmission.AppenderCollectionIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("log4net"),(WCHAR*)WStr("log4net.Appender.AppenderCollection"),(WCHAR*)WStr("ToArray"),sig074,1,1,0,0,1,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.Log4Net.DirectSubmission.AppenderCollectionLegacyIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("log4net"),(WCHAR*)WStr("log4net.Util.AppenderAttachedImpl"),(WCHAR*)WStr("AppendLoopOnAppenders"),sig147,2,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Log4Net.AppenderAttachedImplIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingCommandMessageWireProtocol`1"),(WCHAR*)WStr("Execute"),sig007,3,3,5,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_3_5_Execute_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingCommandMessageWireProtocol`1"),(WCHAR*)WStr("Execute"),sig006,3,2,2,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Generic_Execute_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingCommandMessageWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,3,5,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_3_5_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingCommandMessageWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig218,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingCommandMessageWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig220,3,3,5,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_3_5_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingCommandMessageWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingQueryMessageWireProtocol`1"),(WCHAR*)WStr("Execute"),sig007,3,3,5,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_3_5_Execute_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingQueryMessageWireProtocol`1"),(WCHAR*)WStr("Execute"),sig006,3,2,2,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Generic_Execute_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingQueryMessageWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,3,5,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_3_5_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingQueryMessageWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig218,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingQueryMessageWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig220,3,3,5,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_3_5_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingQueryMessageWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandWireProtocol`1"),(WCHAR*)WStr("Execute"),sig007,3,3,5,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_3_5_Execute_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandWireProtocol`1"),(WCHAR*)WStr("Execute"),sig006,3,2,2,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Generic_Execute_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,3,5,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_3_5_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig218,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig220,3,3,5,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_3_5_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.GetMoreWireProtocol`1"),(WCHAR*)WStr("Execute"),sig006,3,2,2,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Generic_Execute_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.GetMoreWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig218,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.GetMoreWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.QueryWireProtocol`1"),(WCHAR*)WStr("Execute"),sig006,3,2,2,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Generic_Execute_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.QueryWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig218,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.QueryWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.WriteWireProtocolBase`1"),(WCHAR*)WStr("Execute"),sig006,3,2,2,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Generic_Execute_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.WriteWireProtocolBase`1"),(WCHAR*)WStr("ExecuteAsync"),sig218,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.WriteWireProtocolBase`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingCommandMessageWireProtocol`1"),(WCHAR*)WStr("Execute"),sig006,3,2,2,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Generic_Execute_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingCommandMessageWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig218,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingCommandMessageWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingQueryMessageWireProtocol`1"),(WCHAR*)WStr("Execute"),sig006,3,2,2,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Generic_Execute_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingQueryMessageWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig218,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandUsingQueryMessageWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandWireProtocol`1"),(WCHAR*)WStr("Execute"),sig006,3,2,2,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Generic_Execute_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig218,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.GetMoreWireProtocol`1"),(WCHAR*)WStr("Execute"),sig006,3,2,2,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Generic_Execute_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.GetMoreWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig218,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.GetMoreWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.KillCursorsWireProtocol"),(WCHAR*)WStr("Execute"),sig333,3,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Execute_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.KillCursorsWireProtocol"),(WCHAR*)WStr("ExecuteAsync"),sig195,3,2,1,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.KillCursorsWireProtocol"),(WCHAR*)WStr("ExecuteAsync"),sig196,3,2,1,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.QueryWireProtocol`1"),(WCHAR*)WStr("Execute"),sig006,3,2,2,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Generic_Execute_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.QueryWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig218,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.QueryWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.WriteWireProtocolBase`1"),(WCHAR*)WStr("Execute"),sig006,3,2,2,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Generic_Execute_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.WriteWireProtocolBase`1"),(WCHAR*)WStr("ExecuteAsync"),sig218,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.WriteWireProtocolBase`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Messaging"),(WCHAR*)WStr("System.Messaging.MessageQueue"),(WCHAR*)WStr("Purge"),sig310,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Msmq.MessageQueue_Purge_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Messaging"),(WCHAR*)WStr("System.Messaging.MessageQueue"),(WCHAR*)WStr("ReceiveCurrent"),sig152,7,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Msmq.MessageQueue_ReceiveCurrent_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Messaging"),(WCHAR*)WStr("System.Messaging.MessageQueue"),(WCHAR*)WStr("SendInternal"),sig364,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Msmq.MessageQueue_SendInternal_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Messaging"),(WCHAR*)WStr("System.Messaging.MessageQueue"),(WCHAR*)WStr("ReceiveCurrent"),sig153,7,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Msmq.MessageQueue_ReceiveCurrent_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Messaging"),(WCHAR*)WStr("System.Messaging.MessageQueue"),(WCHAR*)WStr("SendInternal"),sig365,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Msmq.MessageQueue_SendInternal_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.TestPlatform.CrossPlatEngine"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Execution.RunTestsWithSources"),(WCHAR*)WStr("SendSessionEnd"),sig310,1,14,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.RunTestsWithSourcesSendSessionEndIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("ExecuteAssemblyCleanup"),sig310,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoExecuteAssemblyCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyCleanup"),sig167,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyCleanupIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyCleanup"),sig168,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyCleanupIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyInitialize"),sig331,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyInitializeIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyInitialize"),sig332,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyInitializeIntegrationV3_9"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig310,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig394,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupIntegrationV3_9"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig393,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassCleanup"),sig173,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitialize"),sig390,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitialize"),sig391,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeIntegrationV3_9"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("Execute"),sig088,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("Execute"),sig091,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteIntegration3_8"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("ExecuteTest"),sig092,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteTestIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig395,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupIntegrationV3_9"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig394,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassCleanupIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassCleanup"),sig174,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassCleanupIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitialize"),sig391,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitialize"),sig392,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeIntegrationV3_9"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("Execute"),sig089,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("Execute"),sig092,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteIntegration3_8"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("ExecuteTest"),sig093,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteTestIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("ExecuteTestAsync"),sig271,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteTestIntegrationV3_9"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TypeCache"),(WCHAR*)WStr("GetTestMethodInfo"),sig087,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TypeCacheGetTestMethodInfoIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TypeCache"),(WCHAR*)WStr("GetTestMethodInfo"),sig086,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TypeCacheGetTestMethodInfoIntegrationV3_9"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunCleanup"),sig085,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTest"),sig089,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTest"),sig093,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestIntegration3_8"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TypeCache"),(WCHAR*)WStr("GetTestMethodInfo"),sig088,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TypeCacheGetTestMethodInfoIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TypeCache"),(WCHAR*)WStr("GetTestMethodInfo"),sig087,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TypeCacheGetTestMethodInfoIntegrationV3_9"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunCleanup"),sig086,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunCleanupIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTest"),sig090,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTest"),sig094,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestIntegration3_8"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTestAsync"),sig272,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestAsyncIntegration3_8"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.UnitTestDiscoverer"),(WCHAR*)WStr("SendTestCases"),sig380,6,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestDiscovererSendTestCasesIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.UnitTestDiscoverer"),(WCHAR*)WStr("SendTestCases"),sig381,6,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestDiscovererSendTestCasesIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("ExecuteAssemblyCleanup"),sig310,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoExecuteAssemblyCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyCleanup"),sig167,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyCleanupIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyCleanup"),sig168,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyCleanupIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyInitialize"),sig331,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyInitializeIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyInitialize"),sig332,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyInitializeIntegrationV3_9"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig310,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig394,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupIntegrationV3_9"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig393,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanupAsync"),sig393,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassCleanup"),sig173,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitialize"),sig390,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitialize"),sig391,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeIntegrationV3_9"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitializeAsync"),sig206,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig395,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupIntegrationV3_9"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig394,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassCleanupIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanupAsync"),sig394,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassCleanup"),sig174,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassCleanupIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitialize"),sig391,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitialize"),sig392,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeIntegrationV3_9"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitializeAsync"),sig207,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("ExecuteTestAsync"),sig271,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteTestIntegrationV3_9"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TypeCache"),(WCHAR*)WStr("GetTestMethodInfo"),sig087,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TypeCacheGetTestMethodInfoIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TypeCache"),(WCHAR*)WStr("GetTestMethodInfo"),sig086,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TypeCacheGetTestMethodInfoIntegrationV3_9"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunCleanup"),sig085,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTest"),sig089,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTest"),sig093,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestIntegration3_8"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TypeCache"),(WCHAR*)WStr("GetTestMethodInfo"),sig088,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TypeCacheGetTestMethodInfoIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TypeCache"),(WCHAR*)WStr("GetTestMethodInfo"),sig087,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TypeCacheGetTestMethodInfoIntegrationV3_9"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunCleanup"),sig086,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunCleanupIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTest"),sig090,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTest"),sig094,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestIntegration3_8"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTestAsync"),sig272,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestAsyncIntegration3_8"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.UnitTestDiscoverer"),(WCHAR*)WStr("SendTestCases"),sig380,6,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestDiscovererSendTestCasesIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("Execute"),sig090,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("Execute"),sig090,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.UnitTestDiscoverer"),(WCHAR*)WStr("SendTestCases"),sig381,6,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestDiscovererSendTestCasesIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("Execute"),sig091,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("Execute"),sig091,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("ExecuteAsync"),sig273,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("ExecuteAsync"),sig273,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteAsyncIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("MSTest.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("ExecuteAsync"),sig273,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MSTest.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("ExecuteAsync"),sig273,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteAsyncIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyInitialize"),sig331,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyInitializeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanupAsync"),sig393,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitializeAsync"),sig206,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanupAsync"),sig394,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitializeAsync"),sig207,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("ExecuteTestAsync"),sig271,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteTestIntegrationV3_9"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TypeCache"),(WCHAR*)WStr("GetTestMethodInfo"),sig086,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TypeCacheGetTestMethodInfoIntegrationV3_9"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTest"),sig093,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestIntegration3_8"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TypeCache"),(WCHAR*)WStr("GetTestMethodInfo"),sig087,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TypeCacheGetTestMethodInfoIntegrationV3_9"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTest"),sig094,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestIntegration3_8"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTestAsync"),sig272,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestAsyncIntegration3_8"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.UnitTestDiscoverer"),(WCHAR*)WStr("SendTestCases"),sig355,5,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestDiscovererSendTestCasesIntegrationV4"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.UnitTestDiscoverer"),(WCHAR*)WStr("SendTestCases"),sig356,5,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestDiscovererSendTestCasesIntegrationV4"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("Close"),sig310,1,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig134,2,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig134,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig145,1,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig145,1,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig094,1,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig095,2,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig094,1,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig095,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig095,1,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig096,2,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig095,1,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig096,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig274,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig275,3,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig159,1,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig159,1,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("GetString"),sig168,2,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("GetValue"),sig161,2,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("Read"),sig120,1,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("GetString"),sig169,2,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("GetValue"),sig162,2,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("Read"),sig121,1,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ReadAsync"),sig300,2,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("Close"),sig310,1,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("GetString"),sig168,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("GetValue"),sig161,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("Read"),sig120,1,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("GetString"),sig169,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("Read"),sig121,1,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig134,2,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig145,1,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig094,1,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig095,2,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig159,1,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig095,1,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig096,2,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig134,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig145,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig096,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig097,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig097,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig098,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig277,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig276,3,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig159,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("Close"),sig310,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("GetString"),sig168,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("GetValue"),sig161,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("Read"),sig120,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("GetString"),sig169,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("Read"),sig121,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.Config.LoggingConfigurationFileLoader"),(WCHAR*)WStr("Load"),sig098,3,6,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LoggingConfigurationFileLoaderLoadInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.Config.LoggingConfigurationFileLoader"),(WCHAR*)WStr("Load"),sig099,3,6,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LoggingConfigurationFileLoaderLoadInstrumentation"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LogFactory"),(WCHAR*)WStr("ActivateLoggingConfiguration"),sig334,2,6,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LogFactoryActivateLoggingConfigurationInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LogFactory"),(WCHAR*)WStr("BuildLoggerConfiguration"),sig099,3,5,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LogFactoryBuildLoggerConfiguration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LogFactory"),(WCHAR*)WStr("BuildLoggerConfiguration"),sig373,3,5,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LogFactoryGetConfigurationForLoggerInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LogFactory"),(WCHAR*)WStr("GetConfigurationForLogger"),sig373,3,2,1,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LogFactoryGetConfigurationForLoggerInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LoggerImpl"),(WCHAR*)WStr("Write"),sig387,5,1,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.LogsInjection.LoggerImplWriteIntegrationV4"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LoggerImpl"),(WCHAR*)WStr("Write"),sig387,5,5,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.LogsInjection.LoggerImplWriteIntegrationV5"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig134,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LogFactory"),(WCHAR*)WStr("BuildLoggerConfiguration"),sig100,3,5,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LogFactoryBuildLoggerConfiguration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LogFactory"),(WCHAR*)WStr("BuildLoggerConfiguration"),sig374,3,5,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LogFactoryGetConfigurationForLoggerInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LogFactory"),(WCHAR*)WStr("GetConfigurationForLogger"),sig374,3,2,1,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LogFactoryGetConfigurationForLoggerInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LoggerImpl"),(WCHAR*)WStr("Write"),sig388,5,1,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.LogsInjection.LoggerImplWriteIntegrationV4"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LoggerImpl"),(WCHAR*)WStr("Write"),sig388,5,5,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.LogsInjection.LoggerImplWriteIntegrationV5"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig145,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig100,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig101,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig101,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig102,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig278,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig159,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("Close"),sig196,4,4,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.Npgsql.ReaderCloseNpgsqlIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("GetString"),sig168,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("GetValue"),sig161,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("Read"),sig120,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("Close"),sig197,4,4,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.Npgsql.ReaderCloseNpgsqlIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("GetString"),sig169,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("Read"),sig121,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.CommandBuilder"),(WCHAR*)WStr("MakeSkipCommand"),sig102,2,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitCommandBuilderMakeTestCommandIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.CommandBuilder"),(WCHAR*)WStr("MakeTestCommand"),sig104,2,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitCommandBuilderMakeTestCommandIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.CommandBuilder"),(WCHAR*)WStr("MakeSkipCommand"),sig103,2,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitCommandBuilderMakeTestCommandIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.CommandBuilder"),(WCHAR*)WStr("MakeTestCommand"),sig105,2,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitCommandBuilderMakeTestCommandIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.SimpleWorkItem"),(WCHAR*)WStr(".ctor"),sig336,4,3,13,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.SimpleWorkItemctor2Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.SimpleWorkItem"),(WCHAR*)WStr(".ctor"),sig335,3,3,7,0,3,12,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.SimpleWorkItemctorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.SimpleWorkItem"),(WCHAR*)WStr("MakeTestCommand"),sig103,1,3,7,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitSimpleWorkItemMakeTestCommandIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.SimpleWorkItem"),(WCHAR*)WStr("MakeTestCommand"),sig104,1,3,7,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitSimpleWorkItemMakeTestCommandIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.WorkItem"),(WCHAR*)WStr("PerformWork"),sig310,1,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitWorkItemPerformWorkIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.WorkItem"),(WCHAR*)WStr("WorkItemComplete"),sig310,1,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitWorkItemWorkItemCompleteIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Reflect"),(WCHAR*)WStr("InvokeMethod"),sig164,4,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitReflectInvokeMethodIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("OpenTelemetry"),(WCHAR*)WStr("OpenTelemetry.Trace.TracerProviderBuilderExtensions"),(WCHAR*)WStr("Build"),sig109,2,1,0,0,1,0,0,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.OpenTelemetry.TracerProviderBuilderIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("OpenTelemetry.Api"),(WCHAR*)WStr("OpenTelemetry.Trace.Tracer"),(WCHAR*)WStr("StartRootSpan"),sig107,6,1,0,0,1,0,0,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.OpenTelemetry.StartRootSpanIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("OpenTelemetry.Api"),(WCHAR*)WStr("OpenTelemetry.Trace.Tracer"),(WCHAR*)WStr("StartSpan"),sig108,7,1,0,0,1,0,0,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.OpenTelemetry.StartSpanIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig134,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Reflect"),(WCHAR*)WStr("InvokeMethod"),sig165,4,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitReflectInvokeMethodIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("OpenTelemetry"),(WCHAR*)WStr("OpenTelemetry.Trace.TracerProviderBuilderExtensions"),(WCHAR*)WStr("Build"),sig110,2,1,0,0,1,0,0,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.OpenTelemetry.TracerProviderBuilderIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("OpenTelemetry.Api"),(WCHAR*)WStr("OpenTelemetry.Trace.Tracer"),(WCHAR*)WStr("StartRootSpan"),sig108,6,1,0,0,1,0,0,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.OpenTelemetry.StartRootSpanIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("OpenTelemetry.Api"),(WCHAR*)WStr("OpenTelemetry.Trace.Tracer"),(WCHAR*)WStr("StartSpan"),sig109,7,1,0,0,1,0,0,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.OpenTelemetry.StartSpanIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig145,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig112,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig113,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig113,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig114,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig279,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig280,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig282,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig281,3,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalar"),sig159,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("Close"),sig310,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("GetString"),sig168,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("GetValue"),sig161,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("Read"),sig120,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("GetString"),sig169,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("Read"),sig121,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("Close"),sig310,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig134,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig134,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig145,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig145,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig114,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig115,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig114,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig115,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig115,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig116,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig115,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig116,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig283,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig284,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig286,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, @@ -1017,219 +1020,219 @@ std::vector callTargets = {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig284,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig286,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig285,3,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalar"),sig159,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalar"),sig159,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("GetString"),sig168,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("GetValue"),sig161,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("Read"),sig120,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("GetString"),sig169,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("GetValue"),sig162,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("Read"),sig121,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ReadAsync"),sig300,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("Close"),sig310,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("GetString"),sig168,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("GetValue"),sig161,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("Read"),sig120,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("GetString"),sig169,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("Read"),sig121,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Diagnostics.Process"),(WCHAR*)WStr("Start"),sig139,1,1,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Process.ProcessStartIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Diagnostics.Process"),(WCHAR*)WStr("System.Diagnostics.Process"),(WCHAR*)WStr("Start"),sig139,1,1,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Process.ProcessStartIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Diagnostics.Process"),(WCHAR*)WStr("Start"),sig140,1,1,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Process.ProcessStartIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Diagnostics.Process"),(WCHAR*)WStr("System.Diagnostics.Process"),(WCHAR*)WStr("Start"),sig140,1,1,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Process.ProcessStartIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IBufferMessage"),(WCHAR*)WStr("InternalMergeFrom"),sig324,2,3,15,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.BufferMessageInternalMergeFromIntegration"),CallTargetKind::Interface,1,15}, {(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IBufferMessage"),(WCHAR*)WStr("InternalWriteTo"),sig325,2,3,15,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.BufferMessageInternalWriteToIntegration"),CallTargetKind::Interface,1,15}, {(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IMessage"),(WCHAR*)WStr("MergeFrom"),sig322,2,3,13,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.MessageMergeFromIntegration"),CallTargetKind::Interface,1,15}, {(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IMessage"),(WCHAR*)WStr("MergeFrom"),sig322,2,3,0,0,3,12,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.OldMessageMergeFromIntegration"),CallTargetKind::Interface,1,15}, {(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IMessage"),(WCHAR*)WStr("WriteTo"),sig323,2,3,13,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.MessageWriteToIntegration"),CallTargetKind::Interface,1,15}, {(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IMessage"),(WCHAR*)WStr("WriteTo"),sig323,2,3,0,0,3,12,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.OldMessageWriteToIntegration"),CallTargetKind::Interface,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.AsyncDefaultBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliver"),sig204,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverAsyncIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.AsyncDefaultBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliverAsync"),sig205,9,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverAsyncAsyncIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.DefaultBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliver"),sig385,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Framing.Impl.Model"),(WCHAR*)WStr("_Private_BasicPublish"),sig381,6,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicPublishIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Framing.Impl.Model"),(WCHAR*)WStr("_Private_ExchangeDeclare"),sig382,9,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.ExchangeDeclareIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Framing.Impl.Model"),(WCHAR*)WStr("_Private_QueueDeclare"),sig376,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.QueueDeclareIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.IAsyncBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliver"),sig204,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverAsyncIntegration"),CallTargetKind::Interface,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.IAsyncBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliverAsync"),sig205,9,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverAsyncAsyncIntegration"),CallTargetKind::Interface,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.IBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliver"),sig385,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverIntegration"),CallTargetKind::Interface,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.AsyncDefaultBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliver"),sig205,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverAsyncIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.AsyncDefaultBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliverAsync"),sig206,9,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverAsyncAsyncIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.DefaultBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliver"),sig386,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Framing.Impl.Model"),(WCHAR*)WStr("_Private_BasicPublish"),sig382,6,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicPublishIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Framing.Impl.Model"),(WCHAR*)WStr("_Private_ExchangeDeclare"),sig383,9,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.ExchangeDeclareIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Framing.Impl.Model"),(WCHAR*)WStr("_Private_QueueDeclare"),sig377,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.QueueDeclareIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.IAsyncBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliver"),sig205,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverAsyncIntegration"),CallTargetKind::Interface,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.IAsyncBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliverAsync"),sig206,9,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverAsyncAsyncIntegration"),CallTargetKind::Interface,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.IBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliver"),sig386,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverIntegration"),CallTargetKind::Interface,1,15}, {(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("BasicConsumeAsync"),sig301,9,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicConsumeAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("BasicGetAsync"),sig287,4,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicGetAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("BasicPublishAsync"),sig304,7,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicPublishAsyncCachedStringsIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("BasicPublishAsync"),sig305,7,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicPublishAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("ExchangeDeclareAsync"),sig202,9,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.ExchangeDeclareAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("PopulateBasicPropertiesHeaders"),sig117,4,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.PopulateBasicPropertiesHeadersIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("QueueBindAsync"),sig203,7,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.QueueBindAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("ExchangeDeclareAsync"),sig203,9,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.ExchangeDeclareAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("PopulateBasicPropertiesHeaders"),sig118,4,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.PopulateBasicPropertiesHeadersIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("QueueBindAsync"),sig204,7,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.QueueBindAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("QueueDeclareAsync"),sig288,9,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.QueueDeclareAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.ModelBase"),(WCHAR*)WStr("BasicConsume"),sig171,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicConsumeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.ModelBase"),(WCHAR*)WStr("BasicGet"),sig116,3,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.ModelBase"),(WCHAR*)WStr("QueueBind"),sig384,5,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.QueueBindIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.ModelBase"),(WCHAR*)WStr("BasicConsume"),sig172,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicConsumeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.ModelBase"),(WCHAR*)WStr("BasicGet"),sig117,3,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.ModelBase"),(WCHAR*)WStr("QueueBind"),sig385,5,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.QueueBindIntegration"),CallTargetKind::Default,1,15}, #if _WIN32 -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.BinaryClientFormatterSink"),(WCHAR*)WStr("SyncProcessMessage"),sig166,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.SyncProcessMessageIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.BinaryServerFormatterSink"),(WCHAR*)WStr("ProcessMessage"),sig165,8,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Server.ProcessMessageIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.BinaryServerFormatterSink"),(WCHAR*)WStr("SerializeResponse"),sig366,5,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Server.BinarySerializeResponseIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Http.HttpClientTransportSink"),(WCHAR*)WStr("ProcessAndSend"),sig154,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.HttpProcessAndSendIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Http.HttpClientTransportSink"),(WCHAR*)WStr("ProcessMessage"),sig367,6,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.HttpProcessMessageIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Http.HttpClientTransportSink"),(WCHAR*)WStr("ProcessResponseException"),sig362,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.HttpProcessResponseExceptionIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Http.HttpClientTransportSink"),(WCHAR*)WStr("ReceiveAndProcess"),sig361,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.HttpReceiveAndProcessIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Ipc.IpcClientTransportSink"),(WCHAR*)WStr("ProcessMessage"),sig367,6,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.IpcTcpProcessMessageIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.SoapClientFormatterSink"),(WCHAR*)WStr("SyncProcessMessage"),sig166,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.SyncProcessMessageIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.SoapServerFormatterSink"),(WCHAR*)WStr("ProcessMessage"),sig165,8,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Server.ProcessMessageIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.SoapServerFormatterSink"),(WCHAR*)WStr("SerializeResponse"),sig365,6,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Server.SoapSerializeResponseIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Tcp.TcpClientTransportSink"),(WCHAR*)WStr("ProcessMessage"),sig367,6,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.IpcTcpProcessMessageIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.BinaryClientFormatterSink"),(WCHAR*)WStr("SyncProcessMessage"),sig167,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.SyncProcessMessageIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.BinaryServerFormatterSink"),(WCHAR*)WStr("ProcessMessage"),sig166,8,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Server.ProcessMessageIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.BinaryServerFormatterSink"),(WCHAR*)WStr("SerializeResponse"),sig367,5,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Server.BinarySerializeResponseIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Http.HttpClientTransportSink"),(WCHAR*)WStr("ProcessAndSend"),sig155,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.HttpProcessAndSendIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Http.HttpClientTransportSink"),(WCHAR*)WStr("ProcessMessage"),sig368,6,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.HttpProcessMessageIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Http.HttpClientTransportSink"),(WCHAR*)WStr("ProcessResponseException"),sig363,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.HttpProcessResponseExceptionIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Http.HttpClientTransportSink"),(WCHAR*)WStr("ReceiveAndProcess"),sig362,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.HttpReceiveAndProcessIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Ipc.IpcClientTransportSink"),(WCHAR*)WStr("ProcessMessage"),sig368,6,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.IpcTcpProcessMessageIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.SoapClientFormatterSink"),(WCHAR*)WStr("SyncProcessMessage"),sig167,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.SyncProcessMessageIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.SoapServerFormatterSink"),(WCHAR*)WStr("ProcessMessage"),sig166,8,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Server.ProcessMessageIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.SoapServerFormatterSink"),(WCHAR*)WStr("SerializeResponse"),sig366,6,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Server.SoapSerializeResponseIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Tcp.TcpClientTransportSink"),(WCHAR*)WStr("ProcessMessage"),sig368,6,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.IpcTcpProcessMessageIntegration"),CallTargetKind::Default,1,1}, #endif {(WCHAR*)WStr("WebDriver"),(WCHAR*)WStr("OpenQA.Selenium.Remote.HttpCommandExecutor"),(WCHAR*)WStr("OnSendingRemoteHttpRequest"),sig337,2,3,12,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.Selenium.HttpCommandExecutorOnSendingRemoteHttpRequestIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("WebDriver"),(WCHAR*)WStr("OpenQA.Selenium.Remote.RemoteWebDriver"),(WCHAR*)WStr("Execute"),sig105,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.Selenium.WebDriverExecuteIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("WebDriver"),(WCHAR*)WStr("OpenQA.Selenium.Remote.RemoteWebDriver"),(WCHAR*)WStr("Execute"),sig105,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.Selenium.WebDriverExecuteIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("WebDriver"),(WCHAR*)WStr("OpenQA.Selenium.WebDriver"),(WCHAR*)WStr("Execute"),sig106,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.Selenium.WebDriverExecuteIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("WebDriver"),(WCHAR*)WStr("OpenQA.Selenium.WebDriver"),(WCHAR*)WStr("Execute"),sig106,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.Selenium.WebDriverExecuteIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("WebDriver"),(WCHAR*)WStr("OpenQA.Selenium.Remote.RemoteWebDriver"),(WCHAR*)WStr("Execute"),sig106,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.Selenium.WebDriverExecuteIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("WebDriver"),(WCHAR*)WStr("OpenQA.Selenium.Remote.RemoteWebDriver"),(WCHAR*)WStr("Execute"),sig106,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.Selenium.WebDriverExecuteIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("WebDriver"),(WCHAR*)WStr("OpenQA.Selenium.WebDriver"),(WCHAR*)WStr("Execute"),sig107,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.Selenium.WebDriverExecuteIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("WebDriver"),(WCHAR*)WStr("OpenQA.Selenium.WebDriver"),(WCHAR*)WStr("Execute"),sig107,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.Selenium.WebDriverExecuteIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("Serilog"),(WCHAR*)WStr("Serilog.Core.Logger"),(WCHAR*)WStr("Dispatch"),sig338,2,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.Serilog.LogsInjection.LoggerDispatchInstrumentation"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Serilog"),(WCHAR*)WStr("Serilog.Core.Pipeline.Logger"),(WCHAR*)WStr("Dispatch"),sig338,2,1,4,0,1,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.Serilog.LogsInjection.LoggerDispatchInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Serilog"),(WCHAR*)WStr("Serilog.LoggerConfiguration"),(WCHAR*)WStr("CreateLogger"),sig118,1,1,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.Serilog.DirectSubmission.LoggerConfigurationInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Serilog"),(WCHAR*)WStr("Serilog.LoggerConfiguration"),(WCHAR*)WStr("CreateLogger"),sig119,1,1,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.Serilog.DirectSubmission.LoggerConfigurationInstrumentation"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("ServiceStack.Redis"),(WCHAR*)WStr("ServiceStack.Redis.RedisNativeClient"),(WCHAR*)WStr("SendReceive"),sig002,5,4,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.ServiceStack.RedisNativeClientSendReceiveIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("ServiceStack.Redis"),(WCHAR*)WStr("ServiceStack.Redis.RedisNativeClient"),(WCHAR*)WStr("SendReceive"),sig003,6,6,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.ServiceStack.RedisNativeClientSendReceiveIntegration_6_2_0"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig134,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig145,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig081,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig082,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig082,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig083,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig266,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig269,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig267,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig268,3,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig159,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Close"),sig310,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetString"),sig168,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetValue"),sig161,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Read"),sig120,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetString"),sig169,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Read"),sig121,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("Close"),sig310,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("GetString"),sig168,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("GetValue"),sig161,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("Read"),sig120,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("GetString"),sig169,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("Read"),sig121,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig134,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig145,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig135,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig136,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig136,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig137,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig293,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig159,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Close"),sig310,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetString"),sig168,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetValue"),sig161,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Read"),sig120,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetString"),sig169,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Read"),sig121,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig134,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig145,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig135,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig136,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig136,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig137,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig293,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig159,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Close"),sig310,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetString"),sig168,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetValue"),sig161,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Read"),sig120,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetString"),sig169,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Read"),sig121,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("Close"),sig310,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("GetString"),sig168,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("GetValue"),sig161,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("Read"),sig120,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("GetString"),sig169,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("Read"),sig121,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig134,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig145,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteReader"),sig083,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteReader"),sig084,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteReader"),sig084,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteReader"),sig085,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig270,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteScalar"),sig159,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig134,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig145,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig147,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteCommand"),(WCHAR*)WStr("ExecuteReader"),sig137,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteCommand"),(WCHAR*)WStr("ExecuteReader"),sig138,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteCommand"),(WCHAR*)WStr("ExecuteScalar"),sig159,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RestSharp"),(WCHAR*)WStr("RestSharp.Extensions.StringExtensions"),(WCHAR*)WStr("UrlEncode"),sig172,3,104,0,0,112,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RestSharp.UrlEncode2Integration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("RestSharp"),(WCHAR*)WStr("RestSharp.Extensions.StringExtensions"),(WCHAR*)WStr("UrlEncode"),sig170,2,104,0,0,112,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RestSharp.UrlEncodeIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.ConnectionMultiplexer"),(WCHAR*)WStr("ExecuteAsyncImpl"),sig211,5,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.ConnectionMultiplexerExecuteAsyncImplIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.ConnectionMultiplexer"),(WCHAR*)WStr("ExecuteAsyncImpl"),sig212,6,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.ConnectionMultiplexerExecuteAsyncImplIntegration_2_6_45"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig148,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteCommand"),(WCHAR*)WStr("ExecuteReader"),sig138,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteCommand"),(WCHAR*)WStr("ExecuteReader"),sig139,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteCommand"),(WCHAR*)WStr("ExecuteScalar"),sig161,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarWithBehaviorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RestSharp"),(WCHAR*)WStr("RestSharp.Extensions.StringExtensions"),(WCHAR*)WStr("UrlEncode"),sig173,3,104,0,0,112,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RestSharp.UrlEncode2Integration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("RestSharp"),(WCHAR*)WStr("RestSharp.Extensions.StringExtensions"),(WCHAR*)WStr("UrlEncode"),sig171,2,104,0,0,112,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RestSharp.UrlEncodeIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.ConnectionMultiplexer"),(WCHAR*)WStr("ExecuteAsyncImpl"),sig212,5,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.ConnectionMultiplexerExecuteAsyncImplIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.ConnectionMultiplexer"),(WCHAR*)WStr("ExecuteAsyncImpl"),sig213,6,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.ConnectionMultiplexerExecuteAsyncImplIntegration_2_6_45"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.ConnectionMultiplexer"),(WCHAR*)WStr("ExecuteSyncImpl"),sig000,4,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.ConnectionMultiplexerExecuteSyncImplIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.ConnectionMultiplexer"),(WCHAR*)WStr("ExecuteSyncImpl"),sig001,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.ConnectionMultiplexerExecuteSyncImplIntegration_2_6_45"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.ConnectionMultiplexer"),(WCHAR*)WStr("SelectServer"),sig119,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.ConnectionMultiplexerSelectServerIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.RedisBase"),(WCHAR*)WStr("ExecuteAsync"),sig208,4,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.ConnectionMultiplexer"),(WCHAR*)WStr("SelectServer"),sig120,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.ConnectionMultiplexerSelectServerIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.RedisBase"),(WCHAR*)WStr("ExecuteAsync"),sig209,4,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.RedisBase"),(WCHAR*)WStr("ExecuteSync"),sig000,4,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteSyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.RedisBatch"),(WCHAR*)WStr("ExecuteAsync"),sig208,4,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.RedisBatch"),(WCHAR*)WStr("ExecuteAsync"),sig207,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration_2_6_48"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.RedisTransaction"),(WCHAR*)WStr("ExecuteAsync"),sig208,4,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.RedisTransaction"),(WCHAR*)WStr("ExecuteAsync"),sig207,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration_2_6_48"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.ConnectionMultiplexer"),(WCHAR*)WStr("ExecuteAsyncImpl"),sig211,5,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.ConnectionMultiplexerExecuteAsyncImplIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.ConnectionMultiplexer"),(WCHAR*)WStr("ExecuteAsyncImpl"),sig212,6,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.ConnectionMultiplexerExecuteAsyncImplIntegration_2_6_45"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.RedisBatch"),(WCHAR*)WStr("ExecuteAsync"),sig209,4,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.RedisBatch"),(WCHAR*)WStr("ExecuteAsync"),sig208,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration_2_6_48"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.RedisTransaction"),(WCHAR*)WStr("ExecuteAsync"),sig209,4,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("StackExchange.Redis"),(WCHAR*)WStr("StackExchange.Redis.RedisTransaction"),(WCHAR*)WStr("ExecuteAsync"),sig208,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration_2_6_48"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.ConnectionMultiplexer"),(WCHAR*)WStr("ExecuteAsyncImpl"),sig212,5,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.ConnectionMultiplexerExecuteAsyncImplIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.ConnectionMultiplexer"),(WCHAR*)WStr("ExecuteAsyncImpl"),sig213,6,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.ConnectionMultiplexerExecuteAsyncImplIntegration_2_6_45"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.ConnectionMultiplexer"),(WCHAR*)WStr("ExecuteSyncImpl"),sig000,4,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.ConnectionMultiplexerExecuteSyncImplIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.ConnectionMultiplexer"),(WCHAR*)WStr("ExecuteSyncImpl"),sig001,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.ConnectionMultiplexerExecuteSyncImplIntegration_2_6_45"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.RedisBase"),(WCHAR*)WStr("ExecuteAsync"),sig208,4,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.RedisBase"),(WCHAR*)WStr("ExecuteAsync"),sig209,4,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.RedisBase"),(WCHAR*)WStr("ExecuteSync"),sig000,4,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteSyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.RedisBatch"),(WCHAR*)WStr("ExecuteAsync"),sig208,4,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.RedisBatch"),(WCHAR*)WStr("ExecuteAsync"),sig207,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration_2_6_48"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.RedisTransaction"),(WCHAR*)WStr("ExecuteAsync"),sig208,4,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.RedisTransaction"),(WCHAR*)WStr("ExecuteAsync"),sig207,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration_2_6_48"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics"),(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddleware"),(WCHAR*)WStr("DisplayException"),sig192,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.StackTraceLeak.DeveloperExceptionPageMiddlewareIntegration"),CallTargetKind::Default,4,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics"),(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddleware"),(WCHAR*)WStr("DisplayException"),sig189,2,3,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.StackTraceLeak.DeveloperExceptionPageMiddlewareIntegration_Pre_3_0_0"),CallTargetKind::Default,4,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics"),(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddlewareImpl"),(WCHAR*)WStr("DisplayException"),sig189,2,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.StackTraceLeak.DeveloperExceptionPageMiddlewareIntegration_Pre_3_0_0"),CallTargetKind::Default,4,14}, +{(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.RedisBatch"),(WCHAR*)WStr("ExecuteAsync"),sig209,4,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.RedisBatch"),(WCHAR*)WStr("ExecuteAsync"),sig208,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration_2_6_48"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.RedisTransaction"),(WCHAR*)WStr("ExecuteAsync"),sig209,4,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("StackExchange.Redis.StrongName"),(WCHAR*)WStr("StackExchange.Redis.RedisTransaction"),(WCHAR*)WStr("ExecuteAsync"),sig208,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.StackExchange.RedisExecuteAsyncIntegration_2_6_48"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics"),(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddleware"),(WCHAR*)WStr("DisplayException"),sig193,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.StackTraceLeak.DeveloperExceptionPageMiddlewareIntegration"),CallTargetKind::Default,4,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics"),(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddleware"),(WCHAR*)WStr("DisplayException"),sig190,2,3,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.StackTraceLeak.DeveloperExceptionPageMiddlewareIntegration_Pre_3_0_0"),CallTargetKind::Default,4,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics"),(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddlewareImpl"),(WCHAR*)WStr("DisplayException"),sig190,2,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.StackTraceLeak.DeveloperExceptionPageMiddlewareIntegration_Pre_3_0_0"),CallTargetKind::Default,4,14}, #if _WIN32 -{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.HttpResponse"),(WCHAR*)WStr("WriteErrorMessage"),sig358,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.StackTraceLeak.HttpResponseIntegration"),CallTargetKind::Default,4,1}, +{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.HttpResponse"),(WCHAR*)WStr("WriteErrorMessage"),sig359,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.StackTraceLeak.HttpResponseIntegration"),CallTargetKind::Default,4,1}, #endif {(WCHAR*)WStr("System.Security.Cryptography"),(WCHAR*)WStr("System.Security.Cryptography.SymmetricAlgorithm"),(WCHAR*)WStr(".ctor"),sig310,1,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CryptographyAlgorithm.SymmetricAlgorithmIntegration"),CallTargetKind::Default,4,14}, {(WCHAR*)WStr("System.Security.Cryptography.Primitives"),(WCHAR*)WStr("System.Security.Cryptography.SymmetricAlgorithm"),(WCHAR*)WStr(".ctor"),sig310,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CryptographyAlgorithm.SymmetricAlgorithmIntegration"),CallTargetKind::Default,4,14}, {(WCHAR*)WStr("Microsoft.TestPlatform.PlatformAbstractions"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.PlatformAbstractions.PlatformAssemblyResolver"),(WCHAR*)WStr(".ctor"),sig310,1,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.PlatformAssemblyResolverAssemblyResolverEventIntegration"),CallTargetKind::Default,1,15}, #if _WIN32 -{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.AsyncMethodInvoker"),(WCHAR*)WStr("InvokeBegin"),sig143,5,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.AsyncMethodInvoker_InvokeBegin_Integration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.AsyncMethodInvoker"),(WCHAR*)WStr("InvokeEnd"),sig163,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.AsyncMethodInvoker_InvokeEnd_Integration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.ChannelHandler"),(WCHAR*)WStr("HandleRequest"),sig124,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.ChannelHandlerIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.ImmutableDispatchRuntime"),(WCHAR*)WStr("AfterReceiveRequest"),sig368,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.AfterReceiveRequestIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.ImmutableDispatchRuntime"),(WCHAR*)WStr("BeforeSendReply"),sig369,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.BeforeSendReplyIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.SyncMethodInvoker"),(WCHAR*)WStr("Invoke"),sig162,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.SyncMethodInvokerIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.AsyncMethodInvoker"),(WCHAR*)WStr("InvokeBegin"),sig144,5,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.AsyncMethodInvoker_InvokeBegin_Integration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.AsyncMethodInvoker"),(WCHAR*)WStr("InvokeEnd"),sig164,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.AsyncMethodInvoker_InvokeEnd_Integration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.ChannelHandler"),(WCHAR*)WStr("HandleRequest"),sig125,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.ChannelHandlerIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.ImmutableDispatchRuntime"),(WCHAR*)WStr("AfterReceiveRequest"),sig369,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.AfterReceiveRequestIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.ImmutableDispatchRuntime"),(WCHAR*)WStr("BeforeSendReply"),sig370,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.BeforeSendReplyIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.SyncMethodInvoker"),(WCHAR*)WStr("Invoke"),sig163,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.SyncMethodInvokerIntegration"),CallTargetKind::Default,1,1}, {(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.TaskMethodInvoker"),(WCHAR*)WStr("InvokeAsync"),sig302,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.TaskMethodInvokerIntegration"),CallTargetKind::Default,1,1}, #endif -{(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("BeginGetRequestStream"),sig142,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_BeginGetRequestStream_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("BeginGetResponse"),sig142,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_BeginGetResponse_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("EndGetResponse"),sig156,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_EndGetResponse_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("GetRequestStream"),sig151,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_GetRequestStream_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("GetResponse"),sig155,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_GetResponse_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Net.WebRequest"),(WCHAR*)WStr("GetResponseAsync"),sig210,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.WebRequest_GetResponseAsync_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("BeginGetRequestStream"),sig142,3,4,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_BeginGetRequestStream_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("BeginGetRequestStream"),sig142,3,9,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_BeginGetRequestStreamV9_Integration"),CallTargetKind::Default,1,8}, -{(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("EndGetResponse"),sig156,2,9,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_EndGetResponseV9_Integration"),CallTargetKind::Default,1,8}, -{(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("GetRequestStream"),sig151,1,4,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_GetRequestStream_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("GetRequestStream"),sig151,1,9,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_GetRequestStreamV9_Integration"),CallTargetKind::Default,1,8}, -{(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("GetResponse"),sig155,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_GetResponse_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.WebRequest"),(WCHAR*)WStr("GetResponseAsync"),sig210,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.WebRequest_GetResponseAsync_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Html.Abstractions"),(WCHAR*)WStr("Microsoft.AspNetCore.Html.HtmlString"),(WCHAR*)WStr(".ctor"),sig370,2,1,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.Html.HtmlStringIntegration"),CallTargetKind::Default,4,14}, +{(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("BeginGetRequestStream"),sig143,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_BeginGetRequestStream_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("BeginGetResponse"),sig143,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_BeginGetResponse_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("EndGetResponse"),sig157,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_EndGetResponse_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("GetRequestStream"),sig152,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_GetRequestStream_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("GetResponse"),sig156,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_GetResponse_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Net.WebRequest"),(WCHAR*)WStr("GetResponseAsync"),sig211,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.WebRequest_GetResponseAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("BeginGetRequestStream"),sig143,3,4,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_BeginGetRequestStream_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("BeginGetRequestStream"),sig143,3,9,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_BeginGetRequestStreamV9_Integration"),CallTargetKind::Default,1,8}, +{(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("EndGetResponse"),sig157,2,9,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_EndGetResponseV9_Integration"),CallTargetKind::Default,1,8}, +{(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("GetRequestStream"),sig152,1,4,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_GetRequestStream_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("GetRequestStream"),sig152,1,9,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_GetRequestStreamV9_Integration"),CallTargetKind::Default,1,8}, +{(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("GetResponse"),sig156,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_GetResponse_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.WebRequest"),(WCHAR*)WStr("GetResponseAsync"),sig211,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.WebRequest_GetResponseAsync_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Html.Abstractions"),(WCHAR*)WStr("Microsoft.AspNetCore.Html.HtmlString"),(WCHAR*)WStr(".ctor"),sig371,2,1,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.Html.HtmlStringIntegration"),CallTargetKind::Default,4,14}, #if _WIN32 -{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.HtmlString"),(WCHAR*)WStr(".ctor"),sig370,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.Html.HtmlStringIntegration"),CallTargetKind::Default,4,1}, +{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.HtmlString"),(WCHAR*)WStr(".ctor"),sig371,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.Html.HtmlStringIntegration"),CallTargetKind::Default,4,1}, #endif -{(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("BeforeTestAssemblyFinishedAsync"),sig174,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerBeforeTestAssemblyFinishedAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("BeforeTestAssemblyFinishedAsync"),sig174,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerBeforeTestAssemblyFinishedAsyncIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("BeforeTestAssemblyFinishedAsync"),sig175,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerBeforeTestAssemblyFinishedAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("BeforeTestAssemblyFinishedAsync"),sig175,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerBeforeTestAssemblyFinishedAsyncIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("RunAsync"),sig303,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestClassRunner`1"),(WCHAR*)WStr("RunAsync"),sig303,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestClassRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestInvoker`1"),(WCHAR*)WStr("RunAsync"),sig294,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestInvokerRunAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestOutputHelper"),(WCHAR*)WStr("QueueTestOutput"),sig370,2,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestOutputHelperQueueTestOutputIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestOutputHelper"),(WCHAR*)WStr("QueueTestOutput"),sig371,2,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestOutputHelperQueueTestOutputIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestRunner`1"),(WCHAR*)WStr("RunAsync"),sig303,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("BeforeTestAssemblyFinishedAsync"),sig174,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerBeforeTestAssemblyFinishedAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("BeforeTestAssemblyFinishedAsync"),sig174,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerBeforeTestAssemblyFinishedAsyncIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("BeforeTestAssemblyFinishedAsync"),sig175,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerBeforeTestAssemblyFinishedAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("BeforeTestAssemblyFinishedAsync"),sig175,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerBeforeTestAssemblyFinishedAsyncIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("RunAsync"),sig303,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestClassRunner`1"),(WCHAR*)WStr("RunAsync"),sig303,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestClassRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestFrameworkDiscoverer"),(WCHAR*)WStr("ReportDiscoveredTestCase"),sig125,4,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.TestFrameworkDiscovererReportDiscoveredTestCaseIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestFrameworkDiscoverer"),(WCHAR*)WStr("ReportDiscoveredTestCase"),sig126,4,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.TestFrameworkDiscovererReportDiscoveredTestCaseIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestInvoker`1"),(WCHAR*)WStr("RunAsync"),sig294,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestInvokerRunAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestOutputHelper"),(WCHAR*)WStr("QueueTestOutput"),sig370,2,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestOutputHelperQueueTestOutputIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestOutputHelper"),(WCHAR*)WStr("QueueTestOutput"),sig371,2,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestOutputHelperQueueTestOutputIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestRunner`1"),(WCHAR*)WStr("RunAsync"),sig303,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.TestAssemblyRunner`4"),(WCHAR*)WStr("Run"),sig307,2,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XUnitTestAssemblyRunnerRunV3Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.TestClassRunner`4"),(WCHAR*)WStr("Run"),sig307,2,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XUnitTestClassRunnerRunV3Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.TestOutputHelper"),(WCHAR*)WStr("QueueTestOutput"),sig370,2,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XUnitTestOutputHelperQueueTestOutputV3Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.TestOutputHelper"),(WCHAR*)WStr("QueueTestOutput"),sig371,2,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XUnitTestOutputHelperQueueTestOutputV3Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.TestRunner`2"),(WCHAR*)WStr("RunTest"),sig306,2,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XUnitTestRunnerV3Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.XunitTestMethodRunnerBase`3"),(WCHAR*)WStr("RunTestCase"),sig308,3,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XUnitTestMethodRunnerBaseRunTestCaseV3Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.XunitTestMethodRunnerContext"),(WCHAR*)WStr(".ctor"),sig388,8,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XunitTestMethodRunnerContextCtorV3Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.XunitTestMethodRunnerContext"),(WCHAR*)WStr(".ctor"),sig389,8,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XunitTestMethodRunnerContextCtorV3Integration"),CallTargetKind::Default,1,15}, }; return profiler->RegisterCallTargetDefinitions((WCHAR*) WStr("Tracing"), callTargets.data(), callTargets.size(), enabledCategories, platform); } diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs index a75c4f4b0605..6247bb5ee230 100644 --- a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs @@ -7,14 +7,11 @@ using System; using System.Collections.Generic; -using System.Linq; using Datadog.Trace.FeatureFlags; using Datadog.Trace.FeatureFlags.Rcm.Model; using Datadog.Trace.TestHelpers; -using Datadog.Trace.Vendors.Newtonsoft.Json.Bson; -using Google.Protobuf.WellKnownTypes; -using Newtonsoft.Json; -using Newtonsoft.Json.Linq; +using Datadog.Trace.Vendors.Newtonsoft.Json; +using Datadog.Trace.Vendors.Newtonsoft.Json.Linq; using Xunit; using ValueType = Datadog.Trace.FeatureFlags.Rcm.Model.ValueType; @@ -42,7 +39,7 @@ public void BundledTest(string description, TestCase? testCase) var ctx = new EvaluationContext(testCase.TargetingKey ?? string.Empty, testCase.Attributes); // Not supported format - Skip.If(testCase.VariationType == "JSON", "JSON result format not supported"); + // Skip.If(testCase.VariationType == "JSON", "JSON result format not supported"); var type = GetVariationType(testCase.VariationType); @@ -54,20 +51,44 @@ public void BundledTest(string description, TestCase? testCase) _ = 0; } - Assert.Equal(testCase.Result.Value, result.Value); - Assert.Equal(testCase.Result.Variant, result.Variant); + AssertEqual(testCase.Result.Value, result.Value); + AssertEqual(testCase.Result.Variant, result.Variant); Assert.NotNull(description); + + void AssertEqual(object? expected, object? obj) + { + if (type == EvaluationType.INTEGER && obj is int intObj) + { + Assert.Equal(Convert.ToInt32(expected), intObj); + } + else if (type == EvaluationType.JSON) + { + if (obj is string jsonTxt) + { + Assert.Equal(expected?.ToString(), obj); + } + else + { + Assert.Equal(expected, obj); + } + } + else + { + Assert.Equal(expected, obj); + } + } } - private static System.Type GetVariationType(string? variationType) + private static EvaluationType GetVariationType(string? variationType) { return variationType switch { - "INTEGER" => typeof(long), - "NUMERIC" => typeof(double), - "STRING" => typeof(string), - "BOOLEAN" => typeof(bool), + "INTEGER" => EvaluationType.INTEGER, + "NUMERIC" => EvaluationType.NUMERIC, + "STRING" => EvaluationType.STRING, + "BOOLEAN" => EvaluationType.BOOLEAN, + "JSON" => EvaluationType.JSON, _ => throw new NotImplementedException(), }; } diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs index 36adeb24a47d..5244c695f23d 100644 --- a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs @@ -72,29 +72,29 @@ public void MapValueTests(object? input, object? expected) { if (expected is null || expected is string) { - var res = FeatureFlagsEvaluator.MapValue(input); + var res = FeatureFlagsEvaluator.MapValue(EvaluationType.STRING, input); Assert.Equal(expected, res); } else if (expected is int expectedInt) { - var res = FeatureFlagsEvaluator.MapValue(input); + var res = FeatureFlagsEvaluator.MapValue(EvaluationType.INTEGER, input); Assert.Equal(expected, res); } else if (expected is double expectedDouble) { - var res = FeatureFlagsEvaluator.MapValue(input); + var res = FeatureFlagsEvaluator.MapValue(EvaluationType.NUMERIC, input); Assert.Equal(expected, res); } else if (expected is bool expectedBool) { - var res = FeatureFlagsEvaluator.MapValue(input); + var res = FeatureFlagsEvaluator.MapValue(EvaluationType.BOOLEAN, input); Assert.Equal(expected, res); } else if (expected is System.Type) { try { - _ = FeatureFlagsEvaluator.MapValue(input); + _ = FeatureFlagsEvaluator.MapValue(EvaluationType.STRING, input); } catch (Exception res) { @@ -113,7 +113,7 @@ public void EvaluateWithoutConfigReturnsProviderNotReadyAndDefault() var evaluator = new FeatureFlagsEvaluator(null, null, 1000); var ctx = new EvaluationContext("target"); - var result = evaluator.Evaluate("test", 23, ctx); + var result = evaluator.Evaluate("test", EvaluationType.INTEGER, 23, ctx); Assert.Equal(23, result.Value); Assert.Equal(EvaluationReason.ERROR, result.Reason); @@ -126,7 +126,7 @@ public void EvaluateWithMissingTargetingKeyReturnsTargetingKeyMissing() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration(), 1000); var ctx = new EvaluationContext(string.Empty); // no targetingKey - var result = evaluator.Evaluate("flag", "default", ctx); + var result = evaluator.Evaluate("flag", EvaluationType.STRING, "default", ctx); Assert.Equal("default", result.Value); Assert.Equal(EvaluationReason.ERROR, result.Reason); @@ -138,7 +138,7 @@ public void EvaluateWithUnknownFlagReturnsFlagNotFound() { var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration(), 1000); var ctx = new EvaluationContext("user-123"); - var result = evaluator.Evaluate("unknown", "default", ctx); + var result = evaluator.Evaluate("unknown", EvaluationType.STRING, "default", ctx); Assert.Equal("default", result.Value); Assert.Equal(EvaluationReason.ERROR, result.Reason); @@ -155,7 +155,7 @@ public void EvaluateDisabledFlagReturnsDisabledReason() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user"); - var result = evaluator.Evaluate("disabled-flag", true, ctx); + var result = evaluator.Evaluate("disabled-flag", EvaluationType.BOOLEAN, true, ctx); Assert.Equal(true, result.Value); Assert.Equal(EvaluationReason.DISABLED, result.Reason); @@ -173,12 +173,12 @@ public void EvaluateFlagWithoutAllocationsReturnsGeneralError() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("allocation"); - var result1 = evaluator.Evaluate("null-allocation", 23, ctx); + var result1 = evaluator.Evaluate("null-allocation", EvaluationType.INTEGER, 23, ctx); Assert.Equal(23, result1.Value); Assert.Equal(EvaluationReason.ERROR, result1.Reason); Assert.Equal("GENERAL", result1.FlagMetadata?["errorCode"]); - var result2 = evaluator.Evaluate("empty-allocation", 23, ctx); + var result2 = evaluator.Evaluate("empty-allocation", EvaluationType.INTEGER, 23, ctx); Assert.Equal(23, result2.Value); Assert.Equal(EvaluationReason.ERROR, result2.Reason); Assert.Equal("GENERAL", result2.FlagMetadata?["errorCode"]); @@ -251,7 +251,7 @@ public void EvaluateSimpleStringFlagReturnsTargetingMatch() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user-123"); - var result = evaluator.Evaluate("simple-string", "default", ctx); + var result = evaluator.Evaluate("simple-string", EvaluationType.STRING, "default", ctx); Assert.Equal("test-value", result.Value); Assert.Equal(EvaluationReason.TARGETING_MATCH, result.Reason); @@ -269,7 +269,7 @@ public void EvaluateRuleBasedFlagMatchesEmailPremium() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user-premium", new Dictionary { { "email", "john@company.com" } }); - var result = evaluator.Evaluate("rule-based-flag", "default", ctx); + var result = evaluator.Evaluate("rule-based-flag", EvaluationType.STRING, "default", ctx); Assert.Equal("premium", result.Value); Assert.Equal(EvaluationReason.TARGETING_MATCH, result.Reason); @@ -287,7 +287,7 @@ public void EvaluateNumericRuleFlagMatchesScoreGte800() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user-vip", new Dictionary { { "score", 850 } }); - var result = evaluator.Evaluate("numeric-rule-flag", "default", ctx); + var result = evaluator.Evaluate("numeric-rule-flag", EvaluationType.STRING, "default", ctx); Assert.Equal("vip", result.Value); Assert.Equal(EvaluationReason.TARGETING_MATCH, result.Reason); @@ -305,7 +305,7 @@ public void EvaluateTimeBasedFlagWithExpiredAllocationReturnsDefaultReason() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user"); - var result = evaluator.Evaluate("time-based-flag", "default", ctx); + var result = evaluator.Evaluate("time-based-flag", EvaluationType.STRING, "default", ctx); Assert.Equal("default", result.Value); Assert.Equal(EvaluationReason.DEFAULT, result.Reason); @@ -323,7 +323,7 @@ public void EvaluateExposureFlagLogsExposureEvent() var evaluator = new FeatureFlagsEvaluator((e) => events.Add(e), new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user-123"); - var result = evaluator.Evaluate("exposure-flag", "default", ctx); + var result = evaluator.Evaluate("exposure-flag", EvaluationType.STRING, "default", ctx); Assert.Equal("tracked-value", result.Value); Assert.Equal(EvaluationReason.TARGETING_MATCH, result.Reason); diff --git a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs index d93def529400..c769aef5cd36 100644 --- a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs +++ b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs @@ -50,7 +50,7 @@ private static void Main(string[] args) IEvaluation? Evaluate(string key) { var context = new EvaluationContext(key); - var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, typeof(string), "Not found", context); + var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, Datadog.Trace.FeatureFlags.EvaluationType.STRING, "Not found", context); if (evaluation is null) { From 48c78ed6d175b5cb0409edca7a5dccb86e7fe0d6 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Wed, 17 Dec 2025 14:31:21 +0100 Subject: [PATCH 24/54] Fixed public api --- ...og.Trace.Manual.PublicApiHasNotChanged.verified.txt | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt index 64c70d55c50a..6773ac50f366 100644 --- a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt +++ b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt @@ -506,9 +506,17 @@ namespace Datadog.Trace.FeatureFlags UNKNOWN = 6, ERROR = 7, } + public enum EvaluationType + { + INTEGER = 0, + NUMERIC = 1, + STRING = 2, + BOOLEAN = 3, + JSON = 4, + } public static class FeatureFlagsSdk { - public static Datadog.Trace.FeatureFlags.IEvaluation? Evaluate(string key, System.Type targetType, object? defaultValue, Datadog.Trace.FeatureFlags.IEvaluationContext? context) { } + public static Datadog.Trace.FeatureFlags.IEvaluation? Evaluate(string key, Datadog.Trace.FeatureFlags.EvaluationType targetType, object? defaultValue, Datadog.Trace.FeatureFlags.IEvaluationContext? context) { } public static bool IsAvailable() { } public static void RegisterOnNewConfigEventHandler(System.Action onNewConfig) { } } From 6cf838bbcf3097844776077de80f6b8945bf77cc Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Wed, 17 Dec 2025 14:34:56 +0100 Subject: [PATCH 25/54] PR comments --- .../src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs | 3 +-- tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs index f6dbad0f620b..b34bbdae8d37 100644 --- a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs +++ b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs @@ -10,8 +10,7 @@ namespace Datadog.Trace.FeatureFlags; /// -/// Handlers for setting ASM login success / failures events in traces -/// Includes a security scan if asm is enabled +/// Functions to retrieve FeatureFlags from server /// public static class FeatureFlagsSdk { diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs index ff1f1f00b62a..87b098f67750 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs @@ -10,7 +10,7 @@ namespace Datadog.Trace.FeatureFlags { - /// Estandard implementation of a EvaluationContext + /// Standard implementation of a EvaluationContext /// Targeting Key /// Context optional parameters public class EvaluationContext(string key, IDictionary? values = null) From 0aa757af9d4e757caf0c0ee2070862d80251570f Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Wed, 17 Dec 2025 15:05:07 +0100 Subject: [PATCH 26/54] Reused ValueType preexistent enum --- tracer/build/supported_calltargets.g.json | 2 +- .../DatadogProvider.cs | 10 ++-- .../Datadog.Trace.Manual.csproj | 2 +- .../FeatureFlags/FeatureFlagsSdk.cs | 2 +- .../FeatureFlagsSdkEvaluateIntegration.cs | 6 +- .../FeatureFlags/FeatureFlagsEvaluator.cs | 42 +++++++------- .../FeatureFlags/FeatureFlagsModule.cs | 2 +- .../FeatureFlags/Rcm/Model/ValueType.cs | 20 ------- .../{EvaluationType.cs => ValueType.cs} | 4 +- .../Generated/generated_calltargets.g.cpp | 2 +- .../FeatureFlagsHelpers.cs | 1 + .../FeatureFlagsEvaluatorTests.Bundle.cs | 23 ++++---- .../FeatureFlagsEvaluatorTests.cs | 58 +++++++++++++------ ...Manual.PublicApiHasNotChanged.verified.txt | 18 +++--- .../Samples.FeatureFlags/Program.cs | 2 +- 15 files changed, 96 insertions(+), 98 deletions(-) delete mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ValueType.cs rename tracer/src/Datadog.Trace/FeatureFlags/{EvaluationType.cs => ValueType.cs} (88%) diff --git a/tracer/build/supported_calltargets.g.json b/tracer/build/supported_calltargets.g.json index 55ab81dbce82..d816d86cf9c4 100644 --- a/tracer/build/supported_calltargets.g.json +++ b/tracer/build/supported_calltargets.g.json @@ -6690,7 +6690,7 @@ "TargetReturnType": "Datadog.Trace.FeatureFlags.IEvaluation", "TargetParameterTypes": [ "System.String", - "Datadog.Trace.FeatureFlags.EvaluationType", + "Datadog.Trace.FeatureFlags.ValueType", "System.Object", "Datadog.Trace.FeatureFlags.IEvaluationContext" ], diff --git a/tracer/src/Datadog.FeatureFlags.OpenFeature/DatadogProvider.cs b/tracer/src/Datadog.FeatureFlags.OpenFeature/DatadogProvider.cs index 2b61b151c396..5a4e2ac89ad9 100644 --- a/tracer/src/Datadog.FeatureFlags.OpenFeature/DatadogProvider.cs +++ b/tracer/src/Datadog.FeatureFlags.OpenFeature/DatadogProvider.cs @@ -37,7 +37,7 @@ public override Task> ResolveBooleanValueAsync(string fl return Task.Run( () => { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.EvaluationType.BOOLEAN, defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.BOOLEAN, defaultValue, GetContext(context)); return GetResolutionDetails(res); }, cancellationToken); @@ -54,7 +54,7 @@ public override Task> ResolveDoubleValueAsync(string f return Task.Run( () => { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.EvaluationType.NUMERIC, defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.NUMERIC, defaultValue, GetContext(context)); return GetResolutionDetails(res); }, cancellationToken); @@ -71,7 +71,7 @@ public override Task> ResolveIntegerValueAsync(string fla return Task.Run( () => { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.EvaluationType.INTEGER, defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.INTEGER, defaultValue, GetContext(context)); return GetResolutionDetails(res); }, cancellationToken); @@ -88,7 +88,7 @@ public override Task> ResolveStringValueAsync(string f return Task.Run( () => { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.EvaluationType.STRING, defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.STRING, defaultValue, GetContext(context)); return GetResolutionDetails(res); }, cancellationToken); @@ -105,7 +105,7 @@ public override Task> ResolveStructureValueAsync(string return Task.Run( () => { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.EvaluationType.JSON, defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.JSON, defaultValue, GetContext(context)); return GetResolutionDetails(res); }, cancellationToken); diff --git a/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj b/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj index 1701063f5159..25ffc0fb8293 100644 --- a/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj +++ b/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj @@ -30,7 +30,7 @@ - + diff --git a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs index b34bbdae8d37..302ca25349d4 100644 --- a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs +++ b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs @@ -38,7 +38,7 @@ public static void RegisterOnNewConfigEventHandler(Action onNewConfig) /// The evaluation context [Instrumented] [MethodImpl(MethodImplOptions.NoInlining)] - public static IEvaluation? Evaluate(string key, EvaluationType targetType, object? defaultValue, IEvaluationContext? context) + public static IEvaluation? Evaluate(string key, ValueType targetType, object? defaultValue, IEvaluationContext? context) { return null; } diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs index 4a194a1ae8ec..1fcd53ace464 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs @@ -23,7 +23,7 @@ namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual; TypeName = "Datadog.Trace.FeatureFlags.FeatureFlagsSdk", MethodName = "Evaluate", ReturnTypeName = "Datadog.Trace.FeatureFlags.IEvaluation", - ParameterTypeNames = [ClrNames.String, "Datadog.Trace.FeatureFlags.EvaluationType", ClrNames.Object, "Datadog.Trace.FeatureFlags.IEvaluationContext"], + ParameterTypeNames = [ClrNames.String, "Datadog.Trace.FeatureFlags.ValueType", ClrNames.Object, "Datadog.Trace.FeatureFlags.IEvaluationContext"], MinimumVersion = "3.31.0", MaximumVersion = "3.*.*", IntegrationName = nameof(IntegrationId.DatadogTraceManual))] @@ -33,7 +33,7 @@ public class FeatureFlagsSdkEvaluateIntegration { internal static CallTargetState OnMethodBegin(ref string? key, ref TTargetType targetType, ref object? defaultValue, ref TContext? context) { - return new CallTargetState(null, new State(key, (EvaluationType)(Convert.ToInt32(targetType)), defaultValue, context)); + return new CallTargetState(null, new State(key, (FeatureFlags.ValueType)(Convert.ToInt32(targetType)), defaultValue, context)); } internal static CallTargetReturn OnMethodEnd(TReturn? returnValue, Exception? exception, in CallTargetState state) @@ -43,7 +43,7 @@ internal static CallTargetState OnMethodBegin(re return new CallTargetReturn(res.DuckCast()); } - private record struct State(string? Key, EvaluationType TargetType, object? DefaultValue, object? Context) + private record struct State(string? Key, FeatureFlags.ValueType TargetType, object? DefaultValue, object? Context) { } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index d4c122dd0939..6a192b00f929 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -61,7 +61,7 @@ public FeatureFlagsEvaluator(Action? onExposureEve private delegate bool NumberEquality(double a, double b); - public Evaluation Evaluate(string flagKey, EvaluationType resultType, object? defaultValue, IEvaluationContext? context) + public Evaluation Evaluate(string flagKey, ValueType resultType, object? defaultValue, IEvaluationContext? context) { try { @@ -92,40 +92,38 @@ public Evaluation Evaluate(string flagKey, EvaluationType resultType, object? de }); } -/* - if (!SupportedResolutionTypes.Contains(resultType)) + if (config.Flags is null || !config.Flags.TryGetValue(flagKey, out var flag) || flag is null) { return new Evaluation( flagKey, defaultValue, EvaluationReason.ERROR, - error: "TYPE_MISMATCH", + error: "FLAG_NOT_FOUND", metadata: new Dictionary { - ["errorCode"] = "TYPE_MISMATCH" + ["errorCode"] = "FLAG_NOT_FOUND" }); } -*/ - if (config.Flags is null || !config.Flags.TryGetValue(flagKey, out var flag) || flag is null) + if (!flag.Enabled is true) { return new Evaluation( flagKey, defaultValue, - EvaluationReason.ERROR, - error: "FLAG_NOT_FOUND", - metadata: new Dictionary - { - ["errorCode"] = "FLAG_NOT_FOUND" - }); + EvaluationReason.DISABLED); } - if (!flag.Enabled is true) + if (flag.VariationType != resultType) { return new Evaluation( flagKey, defaultValue, - EvaluationReason.DISABLED); + EvaluationReason.ERROR, + error: "TYPE_MISMATCH", + metadata: new Dictionary + { + ["errorCode"] = "TYPE_MISMATCH" + }); } if (flag.Allocations is { Count: 0 }) @@ -475,19 +473,19 @@ private static string GetMd5Hash(string input) return context.GetAttribute(name); } - internal static object? MapValue(EvaluationType target, object? value) + internal static object? MapValue(ValueType target, object? value) { if (value is null) { return default!; } - if (target == EvaluationType.STRING) + if (target == ValueType.STRING) { return Convert.ToString(value, CultureInfo.InvariantCulture); } - if (target == EvaluationType.BOOLEAN) + if (target == ValueType.BOOLEAN) { if (value is IConvertible) { @@ -502,19 +500,19 @@ private static string GetMd5Hash(string input) return bool.Parse(value.ToString()!); } - if (target == EvaluationType.INTEGER) + if (target == ValueType.INTEGER) { var number = ParseDouble(value); return (int)number; } - if (target == EvaluationType.NUMERIC) + if (target == ValueType.NUMERIC) { var number = ParseDouble(value); return (double)number; } - if (target == EvaluationType.JSON) + if (target == ValueType.JSON) { if (value is JObject) { @@ -608,7 +606,7 @@ private static double ParseDouble(object value) private Evaluation ResolveVariant( string flagKey, - EvaluationType resultType, + ValueType resultType, object? defaultValue, Flag flag, string variationKey, diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index f10b990dd9ca..a428ae7a169b 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -99,7 +99,7 @@ internal void RegisterOnNewConfigEventHandler(Action? onNewConfig) _onNewConfigEventHander = onNewConfig; } - internal Evaluation Evaluate(string flagKey, EvaluationType resultType, object? defaultValue, IEvaluationContext context) + internal Evaluation Evaluate(string flagKey, ValueType resultType, object? defaultValue, IEvaluationContext context) { if (!_enabled) { diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ValueType.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ValueType.cs deleted file mode 100644 index 939a09289763..000000000000 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ValueType.cs +++ /dev/null @@ -1,20 +0,0 @@ -// -// 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 System.Collections.Generic; - -namespace Datadog.Trace.FeatureFlags.Rcm.Model; - -internal enum ValueType -{ - BOOLEAN, - INTEGER, - NUMERIC, - STRING, - JSON -} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationType.cs b/tracer/src/Datadog.Trace/FeatureFlags/ValueType.cs similarity index 88% rename from tracer/src/Datadog.Trace/FeatureFlags/EvaluationType.cs rename to tracer/src/Datadog.Trace/FeatureFlags/ValueType.cs index 06e2e4b65845..2f6e9ef6b8c2 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationType.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/ValueType.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. // @@ -8,7 +8,7 @@ namespace Datadog.Trace.FeatureFlags; /// Evaluation result reason -public enum EvaluationType +public enum ValueType { /// Integer numeric value INTEGER, diff --git a/tracer/src/Datadog.Tracer.Native/Generated/generated_calltargets.g.cpp b/tracer/src/Datadog.Tracer.Native/Generated/generated_calltargets.g.cpp index 77e32ea5992a..724729b1b40a 100644 --- a/tracer/src/Datadog.Tracer.Native/Generated/generated_calltargets.g.cpp +++ b/tracer/src/Datadog.Tracer.Native/Generated/generated_calltargets.g.cpp @@ -76,7 +76,7 @@ WCHAR* sig057[]={(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationS WCHAR* sig058[]={(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettings"),(WCHAR*)WStr("System.String"),}; WCHAR* sig059[]={(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettingsCollection"),}; WCHAR* sig060[]={(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),}; -WCHAR* sig061[]={(WCHAR*)WStr("Datadog.Trace.FeatureFlags.IEvaluation"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.EvaluationType"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.IEvaluationContext"),}; +WCHAR* sig061[]={(WCHAR*)WStr("Datadog.Trace.FeatureFlags.IEvaluation"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.ValueType"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.IEvaluationContext"),}; WCHAR* sig062[]={(WCHAR*)WStr("Datadog.Trace.IScope"),}; WCHAR* sig063[]={(WCHAR*)WStr("Datadog.Trace.IScope"),(WCHAR*)WStr("System.String"),}; WCHAR* sig064[]={(WCHAR*)WStr("Datadog.Trace.IScope"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.ISpanContext"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Nullable`1[System.DateTimeOffset]"),(WCHAR*)WStr("System.Nullable`1[System.Boolean]"),}; diff --git a/tracer/test/Datadog.Trace.TestHelpers/FeatureFlagsHelpers.cs b/tracer/test/Datadog.Trace.TestHelpers/FeatureFlagsHelpers.cs index faf7dafe7448..f21e04d5c0c3 100644 --- a/tracer/test/Datadog.Trace.TestHelpers/FeatureFlagsHelpers.cs +++ b/tracer/test/Datadog.Trace.TestHelpers/FeatureFlagsHelpers.cs @@ -6,6 +6,7 @@ #nullable enable using System.Collections.Generic; +using Datadog.Trace.FeatureFlags; using Datadog.Trace.FeatureFlags.Rcm.Model; namespace Datadog.Trace.TestHelpers; diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs index 6247bb5ee230..db3f65066e53 100644 --- a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs @@ -13,7 +13,6 @@ using Datadog.Trace.Vendors.Newtonsoft.Json; using Datadog.Trace.Vendors.Newtonsoft.Json.Linq; using Xunit; -using ValueType = Datadog.Trace.FeatureFlags.Rcm.Model.ValueType; namespace Datadog.Trace.Tests.FeatureFlags; @@ -58,37 +57,37 @@ public void BundledTest(string description, TestCase? testCase) void AssertEqual(object? expected, object? obj) { - if (type == EvaluationType.INTEGER && obj is int intObj) + if (type == Trace.FeatureFlags.ValueType.INTEGER && obj is int intObj) { Assert.Equal(Convert.ToInt32(expected), intObj); } - else if (type == EvaluationType.JSON) + else if (type == Trace.FeatureFlags.ValueType.JSON) { if (obj is string jsonTxt) { - Assert.Equal(expected?.ToString(), obj); + Assert.Equal(expected?.ToString(), obj); } else { - Assert.Equal(expected, obj); + Assert.Equal(expected, obj); } } else { - Assert.Equal(expected, obj); + Assert.Equal(expected, obj); } } } - private static EvaluationType GetVariationType(string? variationType) + private static Trace.FeatureFlags.ValueType GetVariationType(string? variationType) { return variationType switch { - "INTEGER" => EvaluationType.INTEGER, - "NUMERIC" => EvaluationType.NUMERIC, - "STRING" => EvaluationType.STRING, - "BOOLEAN" => EvaluationType.BOOLEAN, - "JSON" => EvaluationType.JSON, + "INTEGER" => Trace.FeatureFlags.ValueType.INTEGER, + "NUMERIC" => Trace.FeatureFlags.ValueType.NUMERIC, + "STRING" => Trace.FeatureFlags.ValueType.STRING, + "BOOLEAN" => Trace.FeatureFlags.ValueType.BOOLEAN, + "JSON" => Trace.FeatureFlags.ValueType.JSON, _ => throw new NotImplementedException(), }; } diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs index 5244c695f23d..5a3eb94e19a2 100644 --- a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs @@ -10,10 +10,8 @@ using Datadog.Trace.FeatureFlags; using Datadog.Trace.FeatureFlags.Rcm.Model; using Datadog.Trace.TestHelpers; -using Google.Protobuf.WellKnownTypes; -using Moq; using Xunit; -using ValueType = Datadog.Trace.FeatureFlags.Rcm.Model.ValueType; +using ValueType = Datadog.Trace.FeatureFlags.ValueType; namespace Datadog.Trace.Tests.FeatureFlags; @@ -72,29 +70,29 @@ public void MapValueTests(object? input, object? expected) { if (expected is null || expected is string) { - var res = FeatureFlagsEvaluator.MapValue(EvaluationType.STRING, input); + var res = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.STRING, input); Assert.Equal(expected, res); } else if (expected is int expectedInt) { - var res = FeatureFlagsEvaluator.MapValue(EvaluationType.INTEGER, input); + var res = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.INTEGER, input); Assert.Equal(expected, res); } else if (expected is double expectedDouble) { - var res = FeatureFlagsEvaluator.MapValue(EvaluationType.NUMERIC, input); + var res = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.NUMERIC, input); Assert.Equal(expected, res); } else if (expected is bool expectedBool) { - var res = FeatureFlagsEvaluator.MapValue(EvaluationType.BOOLEAN, input); + var res = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.BOOLEAN, input); Assert.Equal(expected, res); } else if (expected is System.Type) { try { - _ = FeatureFlagsEvaluator.MapValue(EvaluationType.STRING, input); + _ = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.STRING, input); } catch (Exception res) { @@ -113,7 +111,7 @@ public void EvaluateWithoutConfigReturnsProviderNotReadyAndDefault() var evaluator = new FeatureFlagsEvaluator(null, null, 1000); var ctx = new EvaluationContext("target"); - var result = evaluator.Evaluate("test", EvaluationType.INTEGER, 23, ctx); + var result = evaluator.Evaluate("test", Trace.FeatureFlags.ValueType.INTEGER, 23, ctx); Assert.Equal(23, result.Value); Assert.Equal(EvaluationReason.ERROR, result.Reason); @@ -126,7 +124,7 @@ public void EvaluateWithMissingTargetingKeyReturnsTargetingKeyMissing() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration(), 1000); var ctx = new EvaluationContext(string.Empty); // no targetingKey - var result = evaluator.Evaluate("flag", EvaluationType.STRING, "default", ctx); + var result = evaluator.Evaluate("flag", Trace.FeatureFlags.ValueType.STRING, "default", ctx); Assert.Equal("default", result.Value); Assert.Equal(EvaluationReason.ERROR, result.Reason); @@ -138,7 +136,7 @@ public void EvaluateWithUnknownFlagReturnsFlagNotFound() { var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration(), 1000); var ctx = new EvaluationContext("user-123"); - var result = evaluator.Evaluate("unknown", EvaluationType.STRING, "default", ctx); + var result = evaluator.Evaluate("unknown", Trace.FeatureFlags.ValueType.STRING, "default", ctx); Assert.Equal("default", result.Value); Assert.Equal(EvaluationReason.ERROR, result.Reason); @@ -155,13 +153,35 @@ public void EvaluateDisabledFlagReturnsDisabledReason() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user"); - var result = evaluator.Evaluate("disabled-flag", EvaluationType.BOOLEAN, true, ctx); + var result = evaluator.Evaluate("disabled-flag", Trace.FeatureFlags.ValueType.BOOLEAN, true, ctx); Assert.Equal(true, result.Value); Assert.Equal(EvaluationReason.DISABLED, result.Reason); Assert.Null(result.Error); } + [Fact] + public void EvaluateFlagWithTypeMismatchReturnsTypeMismatchError() + { + var flags = new Dictionary + { + ["null-allocation"] = new Flag { Key = "target", Enabled = true, VariationType = ValueType.STRING }, + ["empty-allocation"] = new Flag { Key = "target", Enabled = true, VariationType = ValueType.STRING, Allocations = new List() }, + }; + var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); + var ctx = new EvaluationContext("allocation"); + + var result1 = evaluator.Evaluate("null-allocation", Trace.FeatureFlags.ValueType.BOOLEAN, 23, ctx); + Assert.Equal(23, result1.Value); + Assert.Equal(EvaluationReason.ERROR, result1.Reason); + Assert.Equal("TYPE_MISMATCH", result1.FlagMetadata?["errorCode"]); + + var result2 = evaluator.Evaluate("empty-allocation", Trace.FeatureFlags.ValueType.NUMERIC, 23, ctx); + Assert.Equal(23, result2.Value); + Assert.Equal(EvaluationReason.ERROR, result2.Reason); + Assert.Equal("TYPE_MISMATCH", result2.FlagMetadata?["errorCode"]); + } + [Fact] public void EvaluateFlagWithoutAllocationsReturnsGeneralError() { @@ -173,12 +193,12 @@ public void EvaluateFlagWithoutAllocationsReturnsGeneralError() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("allocation"); - var result1 = evaluator.Evaluate("null-allocation", EvaluationType.INTEGER, 23, ctx); + var result1 = evaluator.Evaluate("null-allocation", Trace.FeatureFlags.ValueType.STRING, 23, ctx); Assert.Equal(23, result1.Value); Assert.Equal(EvaluationReason.ERROR, result1.Reason); Assert.Equal("GENERAL", result1.FlagMetadata?["errorCode"]); - var result2 = evaluator.Evaluate("empty-allocation", EvaluationType.INTEGER, 23, ctx); + var result2 = evaluator.Evaluate("empty-allocation", Trace.FeatureFlags.ValueType.STRING, 23, ctx); Assert.Equal(23, result2.Value); Assert.Equal(EvaluationReason.ERROR, result2.Reason); Assert.Equal("GENERAL", result2.FlagMetadata?["errorCode"]); @@ -251,7 +271,7 @@ public void EvaluateSimpleStringFlagReturnsTargetingMatch() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user-123"); - var result = evaluator.Evaluate("simple-string", EvaluationType.STRING, "default", ctx); + var result = evaluator.Evaluate("simple-string", Trace.FeatureFlags.ValueType.STRING, "default", ctx); Assert.Equal("test-value", result.Value); Assert.Equal(EvaluationReason.TARGETING_MATCH, result.Reason); @@ -269,7 +289,7 @@ public void EvaluateRuleBasedFlagMatchesEmailPremium() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user-premium", new Dictionary { { "email", "john@company.com" } }); - var result = evaluator.Evaluate("rule-based-flag", EvaluationType.STRING, "default", ctx); + var result = evaluator.Evaluate("rule-based-flag", Trace.FeatureFlags.ValueType.STRING, "default", ctx); Assert.Equal("premium", result.Value); Assert.Equal(EvaluationReason.TARGETING_MATCH, result.Reason); @@ -287,7 +307,7 @@ public void EvaluateNumericRuleFlagMatchesScoreGte800() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user-vip", new Dictionary { { "score", 850 } }); - var result = evaluator.Evaluate("numeric-rule-flag", EvaluationType.STRING, "default", ctx); + var result = evaluator.Evaluate("numeric-rule-flag", Trace.FeatureFlags.ValueType.STRING, "default", ctx); Assert.Equal("vip", result.Value); Assert.Equal(EvaluationReason.TARGETING_MATCH, result.Reason); @@ -305,7 +325,7 @@ public void EvaluateTimeBasedFlagWithExpiredAllocationReturnsDefaultReason() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user"); - var result = evaluator.Evaluate("time-based-flag", EvaluationType.STRING, "default", ctx); + var result = evaluator.Evaluate("time-based-flag", Trace.FeatureFlags.ValueType.STRING, "default", ctx); Assert.Equal("default", result.Value); Assert.Equal(EvaluationReason.DEFAULT, result.Reason); @@ -323,7 +343,7 @@ public void EvaluateExposureFlagLogsExposureEvent() var evaluator = new FeatureFlagsEvaluator((e) => events.Add(e), new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user-123"); - var result = evaluator.Evaluate("exposure-flag", EvaluationType.STRING, "default", ctx); + var result = evaluator.Evaluate("exposure-flag", Trace.FeatureFlags.ValueType.STRING, "default", ctx); Assert.Equal("tracked-value", result.Value); Assert.Equal(EvaluationReason.TARGETING_MATCH, result.Reason); diff --git a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt index 6773ac50f366..c46069061f9e 100644 --- a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt +++ b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt @@ -506,17 +506,9 @@ namespace Datadog.Trace.FeatureFlags UNKNOWN = 6, ERROR = 7, } - public enum EvaluationType - { - INTEGER = 0, - NUMERIC = 1, - STRING = 2, - BOOLEAN = 3, - JSON = 4, - } public static class FeatureFlagsSdk { - public static Datadog.Trace.FeatureFlags.IEvaluation? Evaluate(string key, Datadog.Trace.FeatureFlags.EvaluationType targetType, object? defaultValue, Datadog.Trace.FeatureFlags.IEvaluationContext? context) { } + public static Datadog.Trace.FeatureFlags.IEvaluation? Evaluate(string key, Datadog.Trace.FeatureFlags.ValueType targetType, object? defaultValue, Datadog.Trace.FeatureFlags.IEvaluationContext? context) { } public static bool IsAvailable() { } public static void RegisterOnNewConfigEventHandler(System.Action onNewConfig) { } } @@ -535,4 +527,12 @@ namespace Datadog.Trace.FeatureFlags string TargetingKey { get; } object? GetAttribute(string key); } + public enum ValueType + { + INTEGER = 0, + NUMERIC = 1, + STRING = 2, + BOOLEAN = 3, + JSON = 4, + } } \ No newline at end of file diff --git a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs index c769aef5cd36..900e3f0bbbcc 100644 --- a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs +++ b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs @@ -50,7 +50,7 @@ private static void Main(string[] args) IEvaluation? Evaluate(string key) { var context = new EvaluationContext(key); - var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, Datadog.Trace.FeatureFlags.EvaluationType.STRING, "Not found", context); + var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, Datadog.Trace.FeatureFlags.ValueType.STRING, "Not found", context); if (evaluation is null) { From 73b6fbf03ffd21c2da21b848afaf34a1aee05644 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Thu, 18 Dec 2025 15:45:08 +0100 Subject: [PATCH 27/54] PR comments and removed nuget package --- Datadog.Trace.sln | 7 -- .../README.md | 82 ------------------- .../Datadog.FeatureFlags.OpenFeature.csproj | 46 ----------- .../supported-configurations-docs.yaml | 3 +- .../FeatureFlags/Exposure/ExposureApi.cs | 2 +- .../FeatureFlags/Exposure/Model/Allocation.cs | 25 +----- .../Exposure/Model/ExposureEvent.cs | 13 +-- .../FeatureFlags/Exposure/Model/Flag.cs | 5 +- .../FeatureFlags/Exposure/Model/Subject.cs | 7 +- .../FeatureFlags/Exposure/Model/Variant.cs | 5 +- .../FeatureFlags/FeatureFlagsEvaluator.cs | 13 ++- .../FeatureFlags/FeatureFlagsModule.cs | 2 +- .../FeatureFlags/Rcm/FfeProduct.cs | 2 +- .../ConfigurationKeys.FeatureFlags.g.cs | 3 +- .../ConfigurationKeys.FeatureFlags.g.cs | 3 +- .../ConfigurationKeys.FeatureFlags.g.cs | 3 +- .../ConfigurationKeys.FeatureFlags.g.cs | 3 +- .../FeatureFlagsEvaluatorTests.cs | 2 +- .../Samples.FeatureFlags/Program.cs | 4 +- .../DatadogProvider.cs | 0 .../Samples.OpenFeature-2.9/Program.cs | 4 +- .../Samples.OpenFeature-2.9.csproj | 2 +- 22 files changed, 30 insertions(+), 206 deletions(-) delete mode 100644 docs/Datadog.FeatureFlags.OpenFeature/README.md delete mode 100644 tracer/src/Datadog.FeatureFlags.OpenFeature/Datadog.FeatureFlags.OpenFeature.csproj rename tracer/{src/Datadog.FeatureFlags.OpenFeature => test/test-applications/feature-flags/Samples.OpenFeature-2.9}/DatadogProvider.cs (100%) diff --git a/Datadog.Trace.sln b/Datadog.Trace.sln index ca68d466d1f9..779fe03a0421 100644 --- a/Datadog.Trace.sln +++ b/Datadog.Trace.sln @@ -633,8 +633,6 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.OpenFeature-2.9", " EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Datadog.Trace.Tools.Analyzers.CodeFixes", "tracer\src\Datadog.Trace.Tools.Analyzers.CodeFixes\Datadog.Trace.Tools.Analyzers.CodeFixes.csproj", "{32521F0A-D52D-4DB1-86C4-3D72DEDA6E55}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Datadog.FeatureFlags.OpenFeature", "tracer\src\Datadog.FeatureFlags.OpenFeature\Datadog.FeatureFlags.OpenFeature.csproj", "{E40B79B5-F801-FD8B-901A-0B3CE8B5486C}" -EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -1535,10 +1533,6 @@ Global {32521F0A-D52D-4DB1-86C4-3D72DEDA6E55}.Debug|Any CPU.Build.0 = Debug|Any CPU {32521F0A-D52D-4DB1-86C4-3D72DEDA6E55}.Release|Any CPU.ActiveCfg = Release|Any CPU {32521F0A-D52D-4DB1-86C4-3D72DEDA6E55}.Release|Any CPU.Build.0 = Release|Any CPU - {E40B79B5-F801-FD8B-901A-0B3CE8B5486C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {E40B79B5-F801-FD8B-901A-0B3CE8B5486C}.Debug|Any CPU.Build.0 = Debug|Any CPU - {E40B79B5-F801-FD8B-901A-0B3CE8B5486C}.Release|Any CPU.ActiveCfg = Release|Any CPU - {E40B79B5-F801-FD8B-901A-0B3CE8B5486C}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -1789,7 +1783,6 @@ Global {D5A8ABB9-CB23-974E-F338-5D9172D96CD8} = {D0C69381-F696-4113-BE7E-BA43468F431C} {021D714E-1764-D76B-15B5-C9114FE934C2} = {D0C69381-F696-4113-BE7E-BA43468F431C} {32521F0A-D52D-4DB1-86C4-3D72DEDA6E55} = {9E5F0022-0A50-40BF-AC6A-C3078585ECAB} - {E40B79B5-F801-FD8B-901A-0B3CE8B5486C} = {9E5F0022-0A50-40BF-AC6A-C3078585ECAB} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {160A1D00-1F5B-40F8-A155-621B4459D78F} diff --git a/docs/Datadog.FeatureFlags.OpenFeature/README.md b/docs/Datadog.FeatureFlags.OpenFeature/README.md deleted file mode 100644 index 3bbed8b45821..000000000000 --- a/docs/Datadog.FeatureFlags.OpenFeature/README.md +++ /dev/null @@ -1,82 +0,0 @@ -# `Datadog.FeatureFlags.OpenFeature` NuGet package - -This package contains the Datadog .NET OpenFeature SDK - -## Should I install this package? - -Install this package if: - -- You intend to use the DataDog *FeatureFlags* tooling in your OpenFeature enabled app - -## What does Datadog.FeatureFlags.OpenFeature contain? - -Datadog.FeatureFlags.OpenFeature contains three things: - -- The **Datadog.FeatureFlags.OpenFeature.dll assembly** with the **DatadogProvider** compatible with **OpenFeature** from **V2.0.0 onwards**. -- A reference to the [Datadog.Trace NuGet package](https://www.nuget.org/packages/Datadog.Trace) for custom instrumentation. -- The native binaries required for automatic instrumentation, for the Continuous Profiler, and for ASM. - -These native binaries are identical to those installed by the MSI and Linux installer packages, so Datadog.FeatureFlags.OpenFeature should be considered an alternative deployment mechanism for automatic instrumentation. - -The main advantages of Datadog.FeatureFlags.OpenFeature over the MSI or Linux packages are: -- You can use it in locations where you cannot access the underlying host to install the MSI or Linux package. -- You can have multiple applications on the same host using different versions of Datadog.Trace.Bundle without issue. - -## Getting Started - -1. Configure the Datadog agent for APM [as described in our documentation](https://docs.datadoghq.com/tracing/setup_overview/setup/dotnet-core#configure-the-datadog-agent-for-apm). -2. Add the [Datadog.FeatureFlags.OpenFeature](https://www.nuget.org/packages/Datadog.FeatureFlags.OpenFeature) NuGet package to your project, using `dotnet add package Datadog.FeatureFlags.OpenFeature`, for example. -3. Configure the tracer on the server, as [described below](#configure-the-tracer) -4. Add an instance of the **DatadogProvider** to your **OpenFeature.Api.Instance** using `await OpenFeature.Api.Instance.SetProviderAsync(new Datadog.FeatureFlags.OpenFeature.DatadogProvider())` - -### Configure the environment - -After adding the NuGet package to your project, set the following **required** environment variables to enable automatic instrumentation of your application and restart the application. - -> **_NOTE:_** -The following are the mandatory variables. For further configuration options, see our public documentation for the [Tracer](https://docs.datadoghq.com/tracing/trace_collection/library_config/dotnet-core/?tab=environmentvariables) and the [Continuous Profiler](https://docs.datadoghq.com/profiler/enabling/dotnet/?tab=linux#configuration). - - -.NET Core: - -``` -CORECLR_ENABLE_PROFILING=1 -CORECLR_PROFILER={846F5F1C-F9AE-4B07-969E-05C26BC060D8} -CORECLR_PROFILER_PATH= -DD_DOTNET_TRACER_HOME=/datadog -``` - -.NET Framework: - -``` -COR_ENABLE_PROFILING=1 -COR_PROFILER={846F5F1C-F9AE-4B07-969E-05C26BC060D8} -COR_PROFILER_PATH= -DD_DOTNET_TRACER_HOME=/datadog -``` - -The value for the `` placeholder is the path to the directory containing the application’s .dll files. The value for the `CORECLR_PROFILER_PATH`/`COR_PROFILER_PATH` environment variable varies based on the system where the application is running: - -| OPERATING SYSTEM AND PROCESS ARCHITECTURE | CORECLR_PROFILER_PATH VALUE | -|-------------------------------------------|------------------------------------------------------------------------------| -| Alpine Linux x64 | /datadog/linux-musl-x64/Datadog.Trace.ClrProfiler.Native.so | -| Linux x64 | /datadog/linux-x64/Datadog.Trace.ClrProfiler.Native.so | -| Alpine Linux ARM64 | /datadog/linux-musl-arm64/Datadog.Trace.ClrProfiler.Native.so | -| Linux ARM64 | /datadog/linux-arm64/Datadog.Trace.ClrProfiler.Native.so | -| Windows x64 | \datadog\win-x64\Datadog.Trace.ClrProfiler.Native.dll | -| Windows x86 | \datadog\win-x86\Datadog.Trace.ClrProfiler.Native.dll | - -For Docker images running on Linux, configure the image to run the createLogPath.sh script: - -``` -RUN //datadog/createLogPath.sh -``` - -### Examples - -Docker examples are available [here](https://github.com/DataDog/dd-trace-dotnet/tree/master/tracer/samples/NugetDeployment) - -## Get in touch - -If you have questions, feedback, or feature requests, reach our [support](https://docs.datadoghq.com/help). - diff --git a/tracer/src/Datadog.FeatureFlags.OpenFeature/Datadog.FeatureFlags.OpenFeature.csproj b/tracer/src/Datadog.FeatureFlags.OpenFeature/Datadog.FeatureFlags.OpenFeature.csproj deleted file mode 100644 index c16b9c0da1fe..000000000000 --- a/tracer/src/Datadog.FeatureFlags.OpenFeature/Datadog.FeatureFlags.OpenFeature.csproj +++ /dev/null @@ -1,46 +0,0 @@ - - - - Datadog OpenFeature SDK - OpenFeature SDK for Datadog - false - true - README.md - - $(NoWarn);NU5100;NU5128;NU1901;NU1902;NU1903;NU1904 - bin\$(Configuration)\packages - False - - - - - - - - - Never - true - - - - - - Never - Never - - - - Never - Never - - - - - - - - - - - - diff --git a/tracer/src/Datadog.Trace/Configuration/supported-configurations-docs.yaml b/tracer/src/Datadog.Trace/Configuration/supported-configurations-docs.yaml index 9c8c3fa4b637..2b48a7b4d1d9 100644 --- a/tracer/src/Datadog.Trace/Configuration/supported-configurations-docs.yaml +++ b/tracer/src/Datadog.Trace/Configuration/supported-configurations-docs.yaml @@ -873,7 +873,7 @@ DD_TRACE_HTTP_SERVER_ERROR_STATUSES: | DD_TRACE_INJECT_CONTEXT_INTO_STORED_PROCEDURES_ENABLED: | Configuration key to enable or disable the injection of the Datadog trace context into stored procedures. - Default value is false (enabled). + Default value is false (disabled). When enabled, Datadog trace context will be injected into individual stored procedure calls when the following requirements are met:
    • The database is Microsoft SQL Server and is set to @@ -884,6 +884,7 @@ DD_TRACE_INJECT_CONTEXT_INTO_STORED_PROCEDURES_ENABLED: | DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED: | Enables Feature Flags Provider (Experimental). + Default value is false (disabled). DD_TRACE_KAFKA_CREATE_CONSUMER_SCOPE_ENABLED: | diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs index 932bb72df21d..90b56fcc4f66 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs @@ -118,7 +118,7 @@ private ArraySegment GetPayload() return new ArraySegment(Encoding.UTF8.GetBytes(json)); } - public void SendExposure(ExposureEvent exposure) + public void SendExposure(in ExposureEvent exposure) { lock (_exposures) { diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Allocation.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Allocation.cs index 7a0152490a10..1a9d504f7294 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Allocation.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Allocation.cs @@ -11,27 +11,4 @@ namespace Datadog.Trace.FeatureFlags.Exposure.Model; -internal class Allocation(string key) -{ - public string Key { get; } = key; - - public override bool Equals(object? obj) - { - if (this == obj) - { - return true; - } - - if (obj is Allocation that) - { - return Key.Equals(that.Key); - } - - return false; - } - - public override int GetHashCode() - { - return Key.GetHashCode(); - } -} +internal sealed record Allocation(string Key); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/ExposureEvent.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/ExposureEvent.cs index 7bdf680cb21e..c3665ab00cfe 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/ExposureEvent.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/ExposureEvent.cs @@ -11,15 +11,4 @@ namespace Datadog.Trace.FeatureFlags.Exposure.Model; -internal class ExposureEvent(long timeStamp, Allocation allocation, Flag flag, Variant variant, Subject subject) -{ - public long TimeStamp { get; } = timeStamp; - - public Allocation Allocation { get; } = allocation; - - public Flag Flag { get; } = flag; - - public Variant Variant { get; } = variant; - - public Subject Subject { get; } = subject; -} +internal sealed record ExposureEvent(long TimeStamp, Allocation Allocation, Flag Flag, Variant Variant, Subject Subject); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Flag.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Flag.cs index bd71969f4dc8..4e65edd22b5c 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Flag.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Flag.cs @@ -11,7 +11,4 @@ namespace Datadog.Trace.FeatureFlags.Exposure.Model; -internal class Flag(string key) -{ - public string Key { get; } = key; -} +internal sealed record Flag(string Key); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Subject.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Subject.cs index b92735a7d3b2..51ece8f246a8 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Subject.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Subject.cs @@ -11,9 +11,4 @@ namespace Datadog.Trace.FeatureFlags.Exposure.Model; -internal class Subject(string id, IDictionary attributes) -{ - public string Id { get; } = id; - - public IDictionary Attributes { get; } = attributes; -} +internal sealed record Subject(string Id, IDictionary Attributes); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Variant.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Variant.cs index b40a60aa38d8..338b800e6e5a 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Variant.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Variant.cs @@ -11,7 +11,4 @@ namespace Datadog.Trace.FeatureFlags.Exposure.Model; -internal class Variant(string key) -{ - public string Key { get; } = key; -} +internal sealed record Variant(string Key); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index 6a192b00f929..75f335bcbbfb 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -6,17 +6,12 @@ #nullable enable using System; -using System.CodeDom; using System.Collections; using System.Collections.Generic; using System.Globalization; -using System.Linq; -using System.Runtime.CompilerServices; using System.Security.Cryptography; using System.Text; using System.Text.RegularExpressions; -using Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.SDK; -using Datadog.Trace.Debugger.Expressions; using Datadog.Trace.FeatureFlags.Rcm.Model; using Datadog.Trace.Logging; using Datadog.Trace.Vendors.Newtonsoft.Json; @@ -40,11 +35,11 @@ internal class FeatureFlagsEvaluator "MM-dd-yyyy'T'HH:mm:ss'Z'", }; - private readonly Action? _onExposureEvent; + private readonly ReportExposureDelegate? _onExposureEvent; private readonly ServerConfiguration? _config; private readonly long _timeoutMs; - public FeatureFlagsEvaluator(Action? onExposureEvent, ServerConfiguration? config, long timeoutMs = 1000) + public FeatureFlagsEvaluator(ReportExposureDelegate? onExposureEvent, ServerConfiguration? config, long timeoutMs = 1000) { _onExposureEvent = onExposureEvent; _config = config; @@ -681,5 +676,9 @@ private sealed class FlattenEntry(string key, object? value) public object? Value { get; } = value; } + +#pragma warning disable SA1201 // Elements should appear in the correct order + internal delegate void ReportExposureDelegate(in Exposure.Model.ExposureEvent ev); +#pragma warning restore SA1201 // Elements should appear in the correct order } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index a428ae7a169b..8937096f7117 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -135,7 +135,7 @@ private void UpdateConfig(List> list) } } - private void ReportExposure(ExposureEvent exposure) + private void ReportExposure(in ExposureEvent exposure) { _exposureApi?.SendExposure(exposure); } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs index 7919ac5efb80..53bccb8216f0 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs @@ -50,7 +50,7 @@ public ApplyDetails[] UpdateFromRcm(Dictionary if (serverConfigFile.TypedFile is not null) { _serverConfigurations.Add(new KeyValuePair(ffeConfig.Path.Path, serverConfigFile.TypedFile)); - res.Add(ApplyDetails.FromOk(ffeConfig.Path.Path)); + res.Insert(0, ApplyDetails.FromOk(ffeConfig.Path.Path)); apply = true; } } diff --git a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs index c0f262891413..92cf4328cc1a 100644 --- a/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net461/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs @@ -19,6 +19,7 @@ internal static class FeatureFlags { /// /// Enables Feature Flags Provider (Experimental). + /// Default value is false (disabled). /// public const string FlaggingProviderEnabled = "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED"; @@ -83,7 +84,7 @@ internal static class FeatureFlags /// /// Configuration key to enable or disable the injection of the Datadog trace context into stored procedures. - /// Default value is false (enabled). + /// Default value is false (disabled). /// When enabled, Datadog trace context will be injected into individual stored procedure calls when the following requirements are met: ///
        ///
      • The database is Microsoft SQL Server and is set to diff --git a/tracer/src/Datadog.Trace/Generated/net6.0/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs b/tracer/src/Datadog.Trace/Generated/net6.0/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs index c0f262891413..92cf4328cc1a 100644 --- a/tracer/src/Datadog.Trace/Generated/net6.0/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/net6.0/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs @@ -19,6 +19,7 @@ internal static class FeatureFlags { /// /// Enables Feature Flags Provider (Experimental). + /// Default value is false (disabled). /// public const string FlaggingProviderEnabled = "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED"; @@ -83,7 +84,7 @@ internal static class FeatureFlags /// /// Configuration key to enable or disable the injection of the Datadog trace context into stored procedures. - /// Default value is false (enabled). + /// Default value is false (disabled). /// When enabled, Datadog trace context will be injected into individual stored procedure calls when the following requirements are met: ///
          ///
        • The database is Microsoft SQL Server and is set to diff --git a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs index c0f262891413..92cf4328cc1a 100644 --- a/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netcoreapp3.1/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs @@ -19,6 +19,7 @@ internal static class FeatureFlags { /// /// Enables Feature Flags Provider (Experimental). + /// Default value is false (disabled). /// public const string FlaggingProviderEnabled = "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED"; @@ -83,7 +84,7 @@ internal static class FeatureFlags /// /// Configuration key to enable or disable the injection of the Datadog trace context into stored procedures. - /// Default value is false (enabled). + /// Default value is false (disabled). /// When enabled, Datadog trace context will be injected into individual stored procedure calls when the following requirements are met: ///
            ///
          • The database is Microsoft SQL Server and is set to diff --git a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs index c0f262891413..92cf4328cc1a 100644 --- a/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs +++ b/tracer/src/Datadog.Trace/Generated/netstandard2.0/Datadog.Trace.SourceGenerators/ConfigurationKeysGenerator/ConfigurationKeys.FeatureFlags.g.cs @@ -19,6 +19,7 @@ internal static class FeatureFlags { /// /// Enables Feature Flags Provider (Experimental). + /// Default value is false (disabled). /// public const string FlaggingProviderEnabled = "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED"; @@ -83,7 +84,7 @@ internal static class FeatureFlags /// /// Configuration key to enable or disable the injection of the Datadog trace context into stored procedures. - /// Default value is false (enabled). + /// Default value is false (disabled). /// When enabled, Datadog trace context will be injected into individual stored procedure calls when the following requirements are met: ///
              ///
            • The database is Microsoft SQL Server and is set to diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs index 5a3eb94e19a2..0d9eaee3aab3 100644 --- a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs @@ -340,7 +340,7 @@ public void EvaluateExposureFlagLogsExposureEvent() }; List events = new List(); - var evaluator = new FeatureFlagsEvaluator((e) => events.Add(e), new ServerConfiguration { Flags = flags }); + var evaluator = new FeatureFlagsEvaluator((in e) => events.Add(e), new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user-123"); var result = evaluator.Evaluate("exposure-flag", Trace.FeatureFlags.ValueType.STRING, "default", ctx); diff --git a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs index 900e3f0bbbcc..c55557dfa608 100644 --- a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs +++ b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs @@ -1,5 +1,6 @@ using System; using System.Diagnostics; +using System.Threading; using Datadog.Trace.FeatureFlags; namespace Samples.FeatureFlags; @@ -8,7 +9,6 @@ class Program private static void Main(string[] args) { - // See https://aka.ms/new-console-template for more information Console.WriteLine("FeatureFlags SDK Sample"); if (!Datadog.Trace.FeatureFlags.FeatureFlagsSdk.IsAvailable()) @@ -27,7 +27,7 @@ private static void Main(string[] args) int configUpdates = 0; - Datadog.Trace.FeatureFlags.FeatureFlagsSdk.RegisterOnNewConfigEventHandler(() => configUpdates++); + Datadog.Trace.FeatureFlags.FeatureFlagsSdk.RegisterOnNewConfigEventHandler(() => Interlocked.Increment(ref configUpdates)); int attempts = 5; while (configUpdates == 0) diff --git a/tracer/src/Datadog.FeatureFlags.OpenFeature/DatadogProvider.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DatadogProvider.cs similarity index 100% rename from tracer/src/Datadog.FeatureFlags.OpenFeature/DatadogProvider.cs rename to tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DatadogProvider.cs diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs index 942417a435ba..a17052e9f179 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs @@ -1,4 +1,5 @@ using System; +using System.Threading; using OpenFeature.Model; namespace Samples.OpenFeature_2_9; @@ -8,7 +9,6 @@ class Program private static void Main(string[] args) { - // See https://aka.ms/new-console-template for more information Console.WriteLine("OpenFeature 2.9 FeatureFlags SDK Sample"); OpenFeature.Api.Instance.SetProviderAsync(new Datadog.FeatureFlags.OpenFeature.DatadogProvider()).Wait(); @@ -30,7 +30,7 @@ private static void Main(string[] args) int configUpdates = 0; - Datadog.Trace.FeatureFlags.FeatureFlagsSdk.RegisterOnNewConfigEventHandler(() => configUpdates++); + Datadog.Trace.FeatureFlags.FeatureFlagsSdk.RegisterOnNewConfigEventHandler(() => Interlocked.Increment(ref configUpdates)); int attempts = 5; while (configUpdates == 0) diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj index 66e11109800b..1cc9efbbd7fe 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj @@ -12,7 +12,7 @@ - + From 3f1418f849b0f87ddb9c0b469631bcb65f4b1a96 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Thu, 18 Dec 2025 16:01:36 +0100 Subject: [PATCH 28/54] Hide new public FF api --- .../FeatureFlags/FeatureFlagsSdk.cs | 3 ++ .../FeatureFlags/EvaluationContext.cs | 3 ++ .../FeatureFlags/EvaluationReason.cs | 4 ++ .../Datadog.Trace/FeatureFlags/IEvaluation.cs | 8 ++- .../FeatureFlags/IEvaluationContext.cs | 3 ++ .../Datadog.Trace/FeatureFlags/ValueType.cs | 4 ++ ...Manual.PublicApiHasNotChanged.verified.txt | 50 ------------------- 7 files changed, 20 insertions(+), 55 deletions(-) diff --git a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs index 302ca25349d4..e1719de30e65 100644 --- a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs +++ b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs @@ -4,6 +4,7 @@ // #nullable enable +using System.ComponentModel; using System.Runtime.CompilerServices; using Datadog.Trace.SourceGenerators; @@ -12,6 +13,8 @@ namespace Datadog.Trace.FeatureFlags; /// /// Functions to retrieve FeatureFlags from server /// +[EditorBrowsable(EditorBrowsableState.Never)] +[Browsable(false)] public static class FeatureFlagsSdk { /// Gets a value indicating wether FeatureFlags framework is available or not diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs index 87b098f67750..2e2ad0428c22 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs @@ -7,12 +7,15 @@ using System; using System.Collections.Generic; +using System.ComponentModel; namespace Datadog.Trace.FeatureFlags { /// Standard implementation of a EvaluationContext /// Targeting Key /// Context optional parameters + [EditorBrowsable(EditorBrowsableState.Never)] + [Browsable(false)] public class EvaluationContext(string key, IDictionary? values = null) : IEvaluationContext { diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationReason.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationReason.cs index 9714dcd5b94b..be51f6be35a0 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationReason.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationReason.cs @@ -5,9 +5,13 @@ #nullable enable +using System.ComponentModel; + namespace Datadog.Trace.FeatureFlags; /// Evaluation result reason +[EditorBrowsable(EditorBrowsableState.Never)] +[Browsable(false)] public enum EvaluationReason { /// Default value diff --git a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluation.cs b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluation.cs index f1b4d3fbfadd..bcdd7e2a06f7 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluation.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluation.cs @@ -5,16 +5,14 @@ #nullable enable -using System; using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; -using System.Web; +using System.ComponentModel; namespace Datadog.Trace.FeatureFlags; /// FeatureFlag Evaluation result. +[EditorBrowsable(EditorBrowsableState.Never)] +[Browsable(false)] public partial interface IEvaluation { /// Gets the flag key being evaluate diff --git a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs index 6ca092cd1aa5..9208d6d28c8a 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs @@ -6,10 +6,13 @@ #nullable enable using System.Collections.Generic; +using System.ComponentModel; namespace Datadog.Trace.FeatureFlags; /// FeatureFlag Evaluation result. +[EditorBrowsable(EditorBrowsableState.Never)] +[Browsable(false)] public partial interface IEvaluationContext { /// Gets the tareting key. diff --git a/tracer/src/Datadog.Trace/FeatureFlags/ValueType.cs b/tracer/src/Datadog.Trace/FeatureFlags/ValueType.cs index 2f6e9ef6b8c2..8eefadb666d8 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/ValueType.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/ValueType.cs @@ -5,9 +5,13 @@ #nullable enable +using System.ComponentModel; + namespace Datadog.Trace.FeatureFlags; /// Evaluation result reason +[EditorBrowsable(EditorBrowsableState.Never)] +[Browsable(false)] public enum ValueType { /// Integer numeric value diff --git a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt index c46069061f9e..452fcd2588c0 100644 --- a/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt +++ b/tracer/test/Datadog.Trace.Tests/Snapshots/PublicApiTests.Datadog.Trace.Manual.PublicApiHasNotChanged.verified.txt @@ -485,54 +485,4 @@ namespace Datadog.Trace.ExtensionMethods { public static void SetTraceSamplingPriority(this Datadog.Trace.ISpan span, Datadog.Trace.SamplingPriority samplingPriority) { } } -} -namespace Datadog.Trace.FeatureFlags -{ - public class EvaluationContext : Datadog.Trace.FeatureFlags.IEvaluationContext - { - public EvaluationContext(string key, System.Collections.Generic.IDictionary? values = null) { } - public System.Collections.Generic.IDictionary Attributes { get; } - public string TargetingKey { get; } - public object? GetAttribute(string key) { } - } - public enum EvaluationReason - { - DEFAULT = 0, - STATIC = 1, - TARGETING_MATCH = 2, - SPLIT = 3, - DISABLED = 4, - CACHED = 5, - UNKNOWN = 6, - ERROR = 7, - } - public static class FeatureFlagsSdk - { - public static Datadog.Trace.FeatureFlags.IEvaluation? Evaluate(string key, Datadog.Trace.FeatureFlags.ValueType targetType, object? defaultValue, Datadog.Trace.FeatureFlags.IEvaluationContext? context) { } - public static bool IsAvailable() { } - public static void RegisterOnNewConfigEventHandler(System.Action onNewConfig) { } - } - public interface IEvaluation - { - string? Error { get; } - string FlagKey { get; } - System.Collections.Generic.IDictionary? FlagMetadata { get; } - Datadog.Trace.FeatureFlags.EvaluationReason Reason { get; } - object? Value { get; } - string? Variant { get; } - } - public interface IEvaluationContext - { - System.Collections.Generic.IDictionary Attributes { get; } - string TargetingKey { get; } - object? GetAttribute(string key); - } - public enum ValueType - { - INTEGER = 0, - NUMERIC = 1, - STRING = 2, - BOOLEAN = 3, - JSON = 4, - } } \ No newline at end of file From 6776f66299b5bba25381f95f8c6dbf6a8c0e83a3 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Thu, 18 Dec 2025 16:23:09 +0100 Subject: [PATCH 29/54] Added OpenFeature to ApiVersion integration tests --- Datadog.Trace.sln | 2 +- .../PackageVersionsGeneratorDefinitions.json | 15 +++++++++++++-- .../FeatureFlags/FeatureFlagsTests.cs | 6 +++--- .../DatadogProvider.cs | 0 .../Program.cs | 6 +++--- .../Samples.OpenFeature.csproj} | 3 ++- 6 files changed, 22 insertions(+), 10 deletions(-) rename tracer/test/test-applications/feature-flags/{Samples.OpenFeature-2.9 => Samples.OpenFeature}/DatadogProvider.cs (100%) rename tracer/test/test-applications/feature-flags/{Samples.OpenFeature-2.9 => Samples.OpenFeature}/Program.cs (90%) rename tracer/test/test-applications/feature-flags/{Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj => Samples.OpenFeature/Samples.OpenFeature.csproj} (78%) diff --git a/Datadog.Trace.sln b/Datadog.Trace.sln index 779fe03a0421..57baebd0ed23 100644 --- a/Datadog.Trace.sln +++ b/Datadog.Trace.sln @@ -629,7 +629,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "feature-flags", "feature-fl EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.FeatureFlags", "tracer\test\test-applications\feature-flags\Samples.FeatureFlags\Samples.FeatureFlags.csproj", "{D5A8ABB9-CB23-974E-F338-5D9172D96CD8}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.OpenFeature-2.9", "tracer\test\test-applications\feature-flags\Samples.OpenFeature-2.9\Samples.OpenFeature-2.9.csproj", "{021D714E-1764-D76B-15B5-C9114FE934C2}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.OpenFeature", "tracer\test\test-applications\feature-flags\Samples.OpenFeature\Samples.OpenFeature.csproj", "{021D714E-1764-D76B-15B5-C9114FE934C2}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Datadog.Trace.Tools.Analyzers.CodeFixes", "tracer\src\Datadog.Trace.Tools.Analyzers.CodeFixes\Datadog.Trace.Tools.Analyzers.CodeFixes.csproj", "{32521F0A-D52D-4DB1-86C4-3D72DEDA6E55}" EndProject diff --git a/tracer/build/PackageVersionsGeneratorDefinitions.json b/tracer/build/PackageVersionsGeneratorDefinitions.json index 5a931094d8ee..aebd17ff940d 100644 --- a/tracer/build/PackageVersionsGeneratorDefinitions.json +++ b/tracer/build/PackageVersionsGeneratorDefinitions.json @@ -962,6 +962,17 @@ "4.15.*", "4.20.*", "4.*.*" - ] - } + ], + { + "IntegrationName": "OpenFeature", + "SampleProjectName": "Samples.OpenFeature", + "NugetPackageSearchName": "OpenFeature", + "MinVersion": "1.0.0", + "MaxVersionExclusive": "3.0.0", + "SpecificVersions": [ + "1.0.*", + "2.0.*", + "2.10.*" + ] + } ] \ No newline at end of file diff --git a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs index 7a51080d3bef..c569bf6721d7 100644 --- a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs +++ b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs @@ -44,10 +44,10 @@ public FeatureFlagsTests(ITestOutputHelper output) #if NETFRAMEWORK [Collection(nameof(ManualInstrumentationTests))] #endif -public class OpenFeature_2_9_FeatureFlagsTests : FeatureFlagsTestsBase +public class OpenFeatureFeatureFlagsTests : FeatureFlagsTestsBase { - public OpenFeature_2_9_FeatureFlagsTests(ITestOutputHelper output) - : base("OpenFeature-2.9", output) + public OpenFeatureFeatureFlagsTests(ITestOutputHelper output) + : base("OpenFeature", output) { } } diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DatadogProvider.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature/DatadogProvider.cs similarity index 100% rename from tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/DatadogProvider.cs rename to tracer/test/test-applications/feature-flags/Samples.OpenFeature/DatadogProvider.cs diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature/Program.cs similarity index 90% rename from tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs rename to tracer/test/test-applications/feature-flags/Samples.OpenFeature/Program.cs index a17052e9f179..f646eab99623 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Program.cs +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature/Program.cs @@ -2,7 +2,7 @@ using System.Threading; using OpenFeature.Model; -namespace Samples.OpenFeature_2_9; +namespace Samples.OpenFeature; class Program { @@ -11,8 +11,8 @@ private static void Main(string[] args) { Console.WriteLine("OpenFeature 2.9 FeatureFlags SDK Sample"); - OpenFeature.Api.Instance.SetProviderAsync(new Datadog.FeatureFlags.OpenFeature.DatadogProvider()).Wait(); - var client = OpenFeature.Api.Instance.GetClient(); + global::OpenFeature.Api.Instance.SetProviderAsync(new Datadog.FeatureFlags.OpenFeature.DatadogProvider()).Wait(); + var client = global::OpenFeature.Api.Instance.GetClient(); if (!Datadog.Trace.FeatureFlags.FeatureFlagsSdk.IsAvailable()) { diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj b/tracer/test/test-applications/feature-flags/Samples.OpenFeature/Samples.OpenFeature.csproj similarity index 78% rename from tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj rename to tracer/test/test-applications/feature-flags/Samples.OpenFeature/Samples.OpenFeature.csproj index 1cc9efbbd7fe..da5eb46ced48 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature-2.9/Samples.OpenFeature-2.9.csproj +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature/Samples.OpenFeature.csproj @@ -5,10 +5,11 @@ false false enable + 2.9.0 - + From ea6bef43b82f977e24b3056273916544ec9c729d Mon Sep 17 00:00:00 2001 From: Daniel Romano <108014683+daniel-romano-DD@users.noreply.github.com> Date: Fri, 19 Dec 2025 08:41:56 +0100 Subject: [PATCH 30/54] Update tracer/test/Datadog.Trace.Tests/Datadog.Trace.Tests.csproj Co-authored-by: Andrew Lock --- .../Datadog.Trace.Tests.csproj | 21 +------------------ 1 file changed, 1 insertion(+), 20 deletions(-) diff --git a/tracer/test/Datadog.Trace.Tests/Datadog.Trace.Tests.csproj b/tracer/test/Datadog.Trace.Tests/Datadog.Trace.Tests.csproj index 21ad217a4934..2d2e44e5bb7e 100644 --- a/tracer/test/Datadog.Trace.Tests/Datadog.Trace.Tests.csproj +++ b/tracer/test/Datadog.Trace.Tests/Datadog.Trace.Tests.csproj @@ -74,26 +74,7 @@ - - - - - - - - - - - - - - - - - - - - + From d0c2c5d03f4410a8a8b57fceabafcc7527e013d7 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Fri, 19 Dec 2025 08:43:51 +0100 Subject: [PATCH 31/54] Fixed typo --- .../PackageVersionsGeneratorDefinitions.json | 27 ++++++++++--------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/tracer/build/PackageVersionsGeneratorDefinitions.json b/tracer/build/PackageVersionsGeneratorDefinitions.json index aebd17ff940d..48defb175130 100644 --- a/tracer/build/PackageVersionsGeneratorDefinitions.json +++ b/tracer/build/PackageVersionsGeneratorDefinitions.json @@ -962,17 +962,18 @@ "4.15.*", "4.20.*", "4.*.*" - ], - { - "IntegrationName": "OpenFeature", - "SampleProjectName": "Samples.OpenFeature", - "NugetPackageSearchName": "OpenFeature", - "MinVersion": "1.0.0", - "MaxVersionExclusive": "3.0.0", - "SpecificVersions": [ - "1.0.*", - "2.0.*", - "2.10.*" - ] - } + ] + }, + { + "IntegrationName": "OpenFeature", + "SampleProjectName": "Samples.OpenFeature", + "NugetPackageSearchName": "OpenFeature", + "MinVersion": "1.0.0", + "MaxVersionExclusive": "3.0.0", + "SpecificVersions": [ + "1.0.*", + "2.0.*", + "2.10.*" + ] + } ] \ No newline at end of file From 7a1d6891dec68081149d015696546632cf1df561 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Fri, 19 Dec 2025 08:57:59 +0100 Subject: [PATCH 32/54] PR Comments --- .../FeatureFlags/Exposure/ExposureApi.cs | 46 +++++++++++-------- 1 file changed, 26 insertions(+), 20 deletions(-) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs index 90b56fcc4f66..5af46a369756 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs @@ -56,33 +56,32 @@ public static ExposureApi Create(TracerSettings tracerSettings) return new ExposureApi(apiRequestFactory, tracerSettings); } - public void Start() + public void TryToStartSendLoopIfNotStarted() { - _ = Task.Run(StartSendLoopAsync) - .ContinueWith(t => { Log.Error(t.Exception, "FeatureFlags Exposure send loop failed"); }, TaskContinuationOptions.OnlyOnFaulted); - } - - private async Task StartSendLoopAsync() - { - if (Interlocked.Exchange(ref _started, 1) != 0) + if (_started == 1 || Interlocked.Exchange(ref _started, 1) != 0) { return; } - var uri = _apiRequestFactory.GetEndpoint($"evp_proxy/v2/{ExposurePath}"); + _ = Task.Run(SendLoopAsync) + .ContinueWith(t => { Log.Error(t.Exception, "FeatureFlags Exposure send loop failed"); }, TaskContinuationOptions.OnlyOnFaulted); + } + private async Task SendLoopAsync() + { while (!_processExit.Task.IsCompleted) { - if (_exposures.Count > 0) + try { - try + var uri = _apiRequestFactory.GetEndpoint($"evp_proxy/v2/{ExposurePath}"); + if (_exposures.Count > 0) { await SendBatchAsync(uri).ConfigureAwait(false); } - catch (Exception ex) - { - Log.Error(ex, "Error while sending Feature Flags exposures to the agent"); - } + } + catch (Exception ex) + { + Log.Error(ex, "Error while sending Feature Flags exposures to the agent"); } try @@ -98,10 +97,17 @@ private async Task StartSendLoopAsync() private async Task SendBatchAsync(Uri uri) { - var request = _apiRequestFactory.Create(uri); - var payload = GetPayload(); - using var response = await request.PostAsync(payload, MimeTypes.Json) - .ConfigureAwait(false); + try + { + var request = _apiRequestFactory.Create(uri); + var payload = GetPayload(); + using var response = await request.PostAsync(payload, MimeTypes.Json) + .ConfigureAwait(false); + } + catch (Exception ex) + { + Log.Error(ex, "Error in Feature Flags exposures reporting loop"); + } } private ArraySegment GetPayload() @@ -123,7 +129,7 @@ public void SendExposure(in ExposureEvent exposure) lock (_exposures) { _exposures.Enqueue(exposure); - Start(); + TryToStartSendLoopIfNotStarted(); } } From 43d0c395de0b1c1d4d9923c70b1004958341da2c Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Fri, 19 Dec 2025 19:04:54 +0100 Subject: [PATCH 33/54] Fixed FeatureFlagsModule life cycle and ExposureAPI settings management --- Datadog.Trace.Samples.g.sln | 2 +- .../build/Datadog.Trace.Trimming.xml | 3 + .../Ci/TestOptimizationTracerManager.cs | 13 ++- .../TestOptimizationTracerManagerFactory.cs | 10 ++- .../FeatureFlagsSdkEvaluateIntegration.cs | 4 +- .../FeatureFlagsSdkIsAvailableIntegration.cs | 2 +- ...isterOnNewConfigEventHandlerIntegration.cs | 4 +- .../ClrProfiler/Instrumentation.cs | 10 --- .../Datadog.Trace/FeatureFlags/Evaluation.cs | 2 +- .../FeatureFlags/EvaluationContext.cs | 2 +- .../FeatureFlags/Exposure/ExposureApi.cs | 74 +++++++++++------ .../FeatureFlags/FeatureFlagsEvaluator.cs | 5 +- .../FeatureFlags/FeatureFlagsModule.cs | 82 +++++-------------- .../FeatureFlags/Rcm/FfeProduct.cs | 2 +- .../FeatureFlags/Rcm/Model/Allocation.cs | 2 +- .../Rcm/Model/ConditionConfiguration.cs | 2 +- .../FeatureFlags/Rcm/Model/Environment.cs | 2 +- .../FeatureFlags/Rcm/Model/Flag.cs | 2 +- .../FeatureFlags/Rcm/Model/Rule.cs | 2 +- .../Rcm/Model/ServerConfiguration.cs | 2 +- .../FeatureFlags/Rcm/Model/Shard.cs | 2 +- .../FeatureFlags/Rcm/Model/ShardRange.cs | 2 +- .../FeatureFlags/Rcm/Model/Split.cs | 2 +- .../FeatureFlags/Rcm/Model/Variant.cs | 2 +- tracer/src/Datadog.Trace/Tracer.cs | 5 +- tracer/src/Datadog.Trace/TracerManager.cs | 18 +++- .../src/Datadog.Trace/TracerManagerFactory.cs | 17 ++-- .../FeatureFlags/FeatureFlagsTests.cs | 2 +- .../Datadog.Trace.Tests/TracerInstanceTest.cs | 2 +- .../TracerManagerFactoryTests.cs | 5 +- .../Samples.FeatureFlags/Evaluator.cs | 36 ++++++++ .../Samples.FeatureFlags/Program.cs | 38 ++------- .../Samples.OpenFeature/DatadogProvider.cs | 12 ++- .../Samples.OpenFeature/Evaluator.cs | 41 ++++++++++ .../Samples.OpenFeature/Program.cs | 75 ----------------- .../Samples.OpenFeature.csproj | 4 + 36 files changed, 245 insertions(+), 245 deletions(-) create mode 100644 tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Evaluator.cs create mode 100644 tracer/test/test-applications/feature-flags/Samples.OpenFeature/Evaluator.cs delete mode 100644 tracer/test/test-applications/feature-flags/Samples.OpenFeature/Program.cs diff --git a/Datadog.Trace.Samples.g.sln b/Datadog.Trace.Samples.g.sln index 6398c3a61484..301603ec359d 100644 --- a/Datadog.Trace.Samples.g.sln +++ b/Datadog.Trace.Samples.g.sln @@ -453,7 +453,7 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.AzureFunctions.V4Is EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.FeatureFlags", "tracer\test\test-applications\feature-flags\Samples.FeatureFlags\Samples.FeatureFlags.csproj", "{D5A8ABB9-CB23-974E-F338-5D9172D96CD8}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.OpenFeature-2.9", "tracer\test\test-applications\feature-flags\Samples.OpenFeature-2.9\Samples.OpenFeature-2.9.csproj", "{021D714E-1764-D76B-15B5-C9114FE934C2}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.OpenFeature", "tracer\test\test-applications\feature-flags\Samples.OpenFeature\Samples.OpenFeature.csproj", "{021D714E-1764-D76B-15B5-C9114FE934C2}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml b/tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml index e729b88100d6..a6bea9519727 100644 --- a/tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml +++ b/tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml @@ -231,6 +231,7 @@ + @@ -582,6 +583,8 @@ + + diff --git a/tracer/src/Datadog.Trace/Ci/TestOptimizationTracerManager.cs b/tracer/src/Datadog.Trace/Ci/TestOptimizationTracerManager.cs index 3fbab5649d5c..9c1ec01908ad 100644 --- a/tracer/src/Datadog.Trace/Ci/TestOptimizationTracerManager.cs +++ b/tracer/src/Datadog.Trace/Ci/TestOptimizationTracerManager.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. // @@ -14,6 +14,7 @@ using Datadog.Trace.Configuration; using Datadog.Trace.DataStreamsMonitoring; using Datadog.Trace.DogStatsd; +using Datadog.Trace.FeatureFlags; using Datadog.Trace.Logging; using Datadog.Trace.Logging.DirectSubmission; using Datadog.Trace.Logging.TracerFlare; @@ -45,7 +46,8 @@ public TestOptimizationTracerManager( IRemoteConfigurationManager remoteConfigurationManager, IDynamicConfigurationManager dynamicConfigurationManager, ITracerFlareManager tracerFlareManager, - ISpanEventsManager spanEventsManager) + ISpanEventsManager spanEventsManager, + FeatureFlagsModule featureFlags) : base( settings, agentWriter, @@ -63,6 +65,7 @@ public TestOptimizationTracerManager( dynamicConfigurationManager, tracerFlareManager, spanEventsManager, + featureFlags, GetProcessors(settings.PartialFlushEnabled, agentWriter is CIVisibilityProtocolWriter)) { } @@ -161,7 +164,8 @@ public LockedManager( IRemoteConfigurationManager remoteConfigurationManager, IDynamicConfigurationManager dynamicConfigurationManager, ITracerFlareManager tracerFlareManager, - ISpanEventsManager spanEventsManager) + ISpanEventsManager spanEventsManager, + FeatureFlagsModule featureFlags) : base( settings, agentWriter, @@ -178,7 +182,8 @@ public LockedManager( remoteConfigurationManager, dynamicConfigurationManager, tracerFlareManager, - spanEventsManager) + spanEventsManager, + featureFlags) { } } diff --git a/tracer/src/Datadog.Trace/Ci/TestOptimizationTracerManagerFactory.cs b/tracer/src/Datadog.Trace/Ci/TestOptimizationTracerManagerFactory.cs index 795311ea7ece..30c94f363757 100644 --- a/tracer/src/Datadog.Trace/Ci/TestOptimizationTracerManagerFactory.cs +++ b/tracer/src/Datadog.Trace/Ci/TestOptimizationTracerManagerFactory.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. // @@ -15,6 +15,7 @@ using Datadog.Trace.Configuration; using Datadog.Trace.DataStreamsMonitoring; using Datadog.Trace.DogStatsd; +using Datadog.Trace.FeatureFlags; using Datadog.Trace.Logging.DirectSubmission; using Datadog.Trace.Logging.TracerFlare; using Datadog.Trace.RemoteConfigurationManagement; @@ -54,15 +55,16 @@ protected override TracerManager CreateTracerManagerFrom( IRemoteConfigurationManager remoteConfigurationManager, IDynamicConfigurationManager dynamicConfigurationManager, ITracerFlareManager tracerFlareManager, - ISpanEventsManager spanEventsManager) + ISpanEventsManager spanEventsManager, + FeatureFlagsModule featureFlags) { telemetry.RecordTestOptimizationSettings(_settings); if (_testOptimizationTracerManagement.UseLockedTracerManager) { - return new TestOptimizationTracerManager.LockedManager(settings, agentWriter, scopeManager, statsd, runtimeMetrics, logSubmissionManager, telemetry, discoveryService, dataStreamsManager, gitMetadataTagsProvider, traceSampler, spanSampler, remoteConfigurationManager, dynamicConfigurationManager, tracerFlareManager, spanEventsManager); + return new TestOptimizationTracerManager.LockedManager(settings, agentWriter, scopeManager, statsd, runtimeMetrics, logSubmissionManager, telemetry, discoveryService, dataStreamsManager, gitMetadataTagsProvider, traceSampler, spanSampler, remoteConfigurationManager, dynamicConfigurationManager, tracerFlareManager, spanEventsManager, featureFlags); } - return new TestOptimizationTracerManager(settings, agentWriter, scopeManager, statsd, runtimeMetrics, logSubmissionManager, telemetry, discoveryService, dataStreamsManager, gitMetadataTagsProvider, traceSampler, spanSampler, remoteConfigurationManager, dynamicConfigurationManager, tracerFlareManager, spanEventsManager); + return new TestOptimizationTracerManager(settings, agentWriter, scopeManager, statsd, runtimeMetrics, logSubmissionManager, telemetry, discoveryService, dataStreamsManager, gitMetadataTagsProvider, traceSampler, spanSampler, remoteConfigurationManager, dynamicConfigurationManager, tracerFlareManager, spanEventsManager, featureFlags); } protected override TelemetrySettings CreateTelemetrySettings(TracerSettings settings) diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs index 1fcd53ace464..ce1777a7d8cb 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs @@ -29,7 +29,7 @@ namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual; IntegrationName = nameof(IntegrationId.DatadogTraceManual))] [Browsable(false)] [EditorBrowsable(EditorBrowsableState.Never)] -public class FeatureFlagsSdkEvaluateIntegration +public sealed class FeatureFlagsSdkEvaluateIntegration { internal static CallTargetState OnMethodBegin(ref string? key, ref TTargetType targetType, ref object? defaultValue, ref TContext? context) { @@ -39,7 +39,7 @@ internal static CallTargetState OnMethodBegin(re internal static CallTargetReturn OnMethodEnd(TReturn? returnValue, Exception? exception, in CallTargetState state) { var parameters = (State)state.State!; - var res = FeatureFlagsModule.Instance.Evaluate(parameters.Key!, parameters.TargetType, parameters.DefaultValue, parameters.Context.DuckCast()!); + var res = TracerManager.Instance.FeatureFlags?.Evaluate(parameters.Key!, parameters.TargetType, parameters.DefaultValue, parameters.Context.DuckCast()!); return new CallTargetReturn(res.DuckCast()); } diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkIsAvailableIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkIsAvailableIntegration.cs index bafd30330d19..540975b96881 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkIsAvailableIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkIsAvailableIntegration.cs @@ -27,7 +27,7 @@ namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual; IntegrationName = nameof(IntegrationId.DatadogTraceManual))] [Browsable(false)] [EditorBrowsable(EditorBrowsableState.Never)] -public class FeatureFlagsSdkIsAvailableIntegration +public sealed class FeatureFlagsSdkIsAvailableIntegration { internal static CallTargetReturn OnMethodEnd(bool returnValue, Exception? exception, in CallTargetState state) { diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs index 0e8fbbd1e87f..d2e70fd95f95 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs @@ -28,11 +28,11 @@ namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual; IntegrationName = nameof(IntegrationId.DatadogTraceManual))] [Browsable(false)] [EditorBrowsable(EditorBrowsableState.Never)] -public class FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration +public sealed class FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration { internal static CallTargetState OnMethodBegin(ref Action? onNewConfig) { - FeatureFlagsModule.Instance.RegisterOnNewConfigEventHandler(onNewConfig); + TracerManager.Instance.FeatureFlags?.RegisterOnNewConfigEventHandler(onNewConfig); return CallTargetState.GetDefault(); } } diff --git a/tracer/src/Datadog.Trace/ClrProfiler/Instrumentation.cs b/tracer/src/Datadog.Trace/ClrProfiler/Instrumentation.cs index 9ace782dcd8c..6a8e383f1dbe 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/Instrumentation.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/Instrumentation.cs @@ -324,16 +324,6 @@ internal static void InitializeNoNativeParts(Stopwatch sw = null) Log.Error(ex, "Error initializing Security"); } - try - { - Log.Debug("Initializing Feature Flags singleton instance."); - _ = FeatureFlagsModule.Instance; - } - catch (Exception ex) - { - Log.Error(ex, "Error initializing Feature Flags Module"); - } - #if !NETFRAMEWORK try { diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs b/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs index 842942c1e583..50642a2d8217 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs @@ -14,7 +14,7 @@ namespace Datadog.Trace.FeatureFlags { - internal class Evaluation(string flagKey, object? value, EvaluationReason reason, string? variant = null, string? error = null, IDictionary? metadata = null) + internal sealed class Evaluation(string flagKey, object? value, EvaluationReason reason, string? variant = null, string? error = null, IDictionary? metadata = null) : IEvaluation { public string FlagKey { get; } = flagKey; diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs index 2e2ad0428c22..f69bfff9e2b3 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs @@ -16,7 +16,7 @@ namespace Datadog.Trace.FeatureFlags /// Context optional parameters [EditorBrowsable(EditorBrowsableState.Never)] [Browsable(false)] - public class EvaluationContext(string key, IDictionary? values = null) + public sealed class EvaluationContext(string key, IDictionary? values = null) : IEvaluationContext { /// Gets the Context Targeting Key diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs index 5af46a369756..99d540ef05a6 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs @@ -11,72 +11,90 @@ using System.Threading; using System.Threading.Tasks; using Datadog.Trace.Agent; -using Datadog.Trace.Agent.DiscoveryService; using Datadog.Trace.Agent.Transports; using Datadog.Trace.Configuration; -using Datadog.Trace.FeatureFlags.Exposure; using Datadog.Trace.FeatureFlags.Exposure.Model; using Datadog.Trace.HttpOverStreams; -using Datadog.Trace.Logging.TracerFlare; -using Datadog.Trace.VendoredMicrosoftCode.System.Reflection.Internal; +using Datadog.Trace.Logging; using Datadog.Trace.Vendors.Newtonsoft.Json; -using Datadog.Trace.Vendors.Serilog; -using static InlineIL.IL; namespace Datadog.Trace.Exposure { - internal class ExposureApi + internal sealed class ExposureApi : IDisposable { + internal static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(ExposureApi)); + public const string ExposurePath = "api/v2/exposure"; private readonly TaskCompletionSource _processExit = new(); - private readonly IApiRequestFactory _apiRequestFactory; - private readonly Queue _exposures = new Queue(); private readonly TimeSpan _sendInterval = TimeSpan.FromSeconds(10); - private readonly Dictionary _context = new Dictionary(); + private readonly Queue _exposures = new Queue(); + private IApiRequestFactory? _apiRequestFactory = null; + private Dictionary _context = new Dictionary(); private int _started = 0; - private ExposureApi(IApiRequestFactory apiRequestFactory, TracerSettings tracerSettings) + private ExposureApi(TracerSettings tracerSettings) { - _apiRequestFactory = apiRequestFactory; - _context["service"] = tracerSettings.Manager.InitialMutableSettings.ServiceName ?? "unknown"; - _context["env"] = tracerSettings.Manager.InitialMutableSettings.Environment ?? "unknown"; - _context["version"] = tracerSettings.Manager.InitialMutableSettings.ServiceVersion ?? "unknown"; + UpdateSettings(tracerSettings.Manager.InitialExporterSettings, tracerSettings.Manager.InitialMutableSettings); + tracerSettings.Manager.SubscribeToChanges(settingChanges => UpdateSettings(settingChanges.UpdatedExporter ?? settingChanges.PreviousExporter, settingChanges.UpdatedMutable ?? settingChanges.PreviousMutable)); } - public static ExposureApi Create(TracerSettings tracerSettings) + private void UpdateSettings(ExporterSettings exporterSettings, MutableSettings settings) { + Log.Debug("ExposureApi::UpdateSettings -> Applyting settings"); var apiRequestFactory = AgentTransportStrategy.Get( - tracerSettings.Manager.InitialExporterSettings, + exporterSettings, productName: "FeatureFlags exposure", tcpTimeout: TimeSpan.FromSeconds(5), AgentHttpHeaderNames.MinimalHeaders, () => new MinimalAgentHeaderHelper(), uri => uri); + Interlocked.Exchange(ref _apiRequestFactory, apiRequestFactory); - return new ExposureApi(apiRequestFactory, tracerSettings); + var context = new Dictionary + { + { "service", settings.ServiceName ?? "unknown" }, + { "env", settings.Environment ?? "unknown" }, + { "version", settings.ServiceVersion ?? "unknown" } + }; + Interlocked.Exchange(ref _context, context); + } + + public static ExposureApi Create(TracerSettings tracerSettings) + { + return new ExposureApi(tracerSettings); + } + + public void Dispose() + { + try { _processExit.TrySetResult(true); } + catch { } } public void TryToStartSendLoopIfNotStarted() { - if (_started == 1 || Interlocked.Exchange(ref _started, 1) != 0) + if (_started != 0 || Interlocked.Exchange(ref _started, 1) != 0) { return; } - _ = Task.Run(SendLoopAsync) - .ContinueWith(t => { Log.Error(t.Exception, "FeatureFlags Exposure send loop failed"); }, TaskContinuationOptions.OnlyOnFaulted); + _ = Task.Run(SendLoopAsync).ContinueWith(t => { Log.Error(t.Exception, "FeatureFlags Exposure send loop failed"); }, TaskContinuationOptions.OnlyOnFaulted); } private async Task SendLoopAsync() { + Log.Debug("ExposureApi::SendLoopAsync -> Enter"); while (!_processExit.Task.IsCompleted) { try { - var uri = _apiRequestFactory.GetEndpoint($"evp_proxy/v2/{ExposurePath}"); - if (_exposures.Count > 0) + var apiRequestFactory = _apiRequestFactory; + if (apiRequestFactory is not null) { - await SendBatchAsync(uri).ConfigureAwait(false); + var uri = apiRequestFactory.GetEndpoint($"evp_proxy/v2/{ExposurePath}"); + if (_exposures.Count > 0) + { + await SendBatchAsync(apiRequestFactory, uri).ConfigureAwait(false); + } } } catch (Exception ex) @@ -92,14 +110,16 @@ private async Task SendLoopAsync() { // We are shutting down, so don't do anything about it } + + Log.Debug("ExposureApi::SendLoopAsync -> Exit"); } } - private async Task SendBatchAsync(Uri uri) + private async Task SendBatchAsync(IApiRequestFactory apiRequestFactory, Uri uri) { try { - var request = _apiRequestFactory.Create(uri); + var request = apiRequestFactory.Create(uri); var payload = GetPayload(); using var response = await request.PostAsync(payload, MimeTypes.Json) .ConfigureAwait(false); @@ -133,7 +153,7 @@ public void SendExposure(in ExposureEvent exposure) } } - private class ExposuresRequest(Dictionary context, List exposures) + private sealed class ExposuresRequest(Dictionary context, List exposures) { public Dictionary Context { get; } = context; diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index 75f335bcbbfb..741297044f71 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -19,7 +19,7 @@ namespace Datadog.Trace.FeatureFlags { - internal class FeatureFlagsEvaluator + internal sealed class FeatureFlagsEvaluator { internal static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(FeatureFlagsEvaluator)); @@ -660,6 +660,7 @@ private void DispatchExposure( return; } + Log.Debug("FeatureFlagsEvaluator::DispatchExposure -> FlagKey: {FlagKey}", flagKey); var evt = new Exposure.Model.ExposureEvent( DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(), new Exposure.Model.Allocation(allocationKey), @@ -667,7 +668,7 @@ private void DispatchExposure( new Exposure.Model.Variant(variantKey), new Exposure.Model.Subject(context?.TargetingKey ?? string.Empty, FlattenContext(context))); - _onExposureEvent?.Invoke(evt); + _onExposureEvent?.Invoke(in evt); } private sealed class FlattenEntry(string key, object? value) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index 8937096f7117..1ee2d6db583e 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -7,35 +7,21 @@ using System; using System.Collections.Generic; -using System.Linq; using System.Threading; -using Datadog.Trace.Agent.DiscoveryService; using Datadog.Trace.AppSec.Rcm; -using Datadog.Trace.AppSec.Rcm.Models.AsmFeatures; -using Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcAspNetCoreServer; using Datadog.Trace.Configuration; -using Datadog.Trace.Debugger.Configurations; using Datadog.Trace.Exposure; using Datadog.Trace.FeatureFlags.Exposure.Model; -using Datadog.Trace.FeatureFlags.Rcm; using Datadog.Trace.FeatureFlags.Rcm.Model; using Datadog.Trace.Logging; using Datadog.Trace.RemoteConfigurationManagement; -using Datadog.Trace.Sampling; -using Datadog.Trace.Telemetry; -using Datadog.Trace.Vendors.Serilog; namespace Datadog.Trace.FeatureFlags { - internal class FeatureFlagsModule + internal sealed class FeatureFlagsModule : IDisposable { internal static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(FeatureFlagsModule)); - private static FeatureFlagsModule? _instance; - private static bool _globalInstanceInitialized; - private static object _globalInstanceLock = new(); - private static bool _enabled = false; - private readonly IRcmSubscriptionManager _rcmSubscriptionManager; private ISubscription? _rcmSubscription = null; private FfeProduct? _ffeProduct = null; @@ -44,55 +30,35 @@ internal class FeatureFlagsModule private FeatureFlagsEvaluator? _evaluator = null; - static FeatureFlagsModule() - { - } - - /// - /// Initializes a new instance of the class with default settings. - /// - public FeatureFlagsModule() - : this(TracerSettings.FromDefaultSourcesInternal(), null) - { - } - internal FeatureFlagsModule(TracerSettings settings, IRcmSubscriptionManager? rcmSubscriptionManager = null) { + Log.Debug("FeatureFlagsModule ENABLED"); _rcmSubscriptionManager = rcmSubscriptionManager ?? RcmSubscriptionManager.Instance; - - if (settings.IsFlaggingProviderEnabled) + _exposureApi = ExposureApi.Create(settings); + _ffeProduct = new FfeProduct(UpdateRemoteConfig); + if (Interlocked.Exchange(ref _rcmSubscription, new Subscription(_ffeProduct.UpdateFromRcm, RcmProducts.FfeFlags)) == null) { - Log.Debug("FeatureFlagsModule ENABLED"); - _enabled = true; - _ffeProduct = new FfeProduct(UpdateConfig); - if (Interlocked.Exchange(ref _rcmSubscription, new Subscription(_ffeProduct.UpdateFromRcm, RcmProducts.FfeFlags)) == null) - { - _rcmSubscriptionManager.SubscribeToChanges(_rcmSubscription!); - _rcmSubscriptionManager.SetCapability(RcmCapabilitiesIndices.FfeFlagConfigurationRules, true); - } - - _exposureApi = ExposureApi.Create(settings); + _rcmSubscriptionManager.SubscribeToChanges(_rcmSubscription!); + _rcmSubscriptionManager.SetCapability(RcmCapabilitiesIndices.FfeFlagConfigurationRules, true); } } - /// - /// Gets or sets the global instance. - /// - public static FeatureFlagsModule Instance - { - get => LazyInitializer.EnsureInitialized(ref _instance, ref _globalInstanceInitialized, ref _globalInstanceLock)!; + public long Timeout { get; set; } = 1000; - set + public static FeatureFlagsModule? Create(TracerSettings settings, IRcmSubscriptionManager? rcmSubscriptionManager = null) + { + if (settings.IsFlaggingProviderEnabled) { - lock (_globalInstanceLock) - { - _instance = value; - _globalInstanceInitialized = true; - } + return new FeatureFlagsModule(settings, rcmSubscriptionManager ?? RcmSubscriptionManager.Instance); } + + return null; } - public long Timeout { get; set; } = 1000; + public void Dispose() + { + _exposureApi?.Dispose(); + } internal void RegisterOnNewConfigEventHandler(Action? onNewConfig) { @@ -101,12 +67,6 @@ internal void RegisterOnNewConfigEventHandler(Action? onNewConfig) internal Evaluation Evaluate(string flagKey, ValueType resultType, object? defaultValue, IEvaluationContext context) { - if (!_enabled) - { - Log.Debug("FeatureFlagsModule::Evaluate -> FeatureFlagsModule DISABLED"); - return new Evaluation(flagKey, null, EvaluationReason.ERROR, null, "FeatureFlagsSdk is disabled"); - } - if (_evaluator is null) { Log.Debug("FeatureFlagsModule::Evaluate -> Evaluator is null (no config received)"); @@ -117,9 +77,9 @@ internal Evaluation Evaluate(string flagKey, ValueType resultType, object? defau return _evaluator.Evaluate(flagKey, resultType, defaultValue, context); } - private void UpdateConfig(List> list) + private void UpdateRemoteConfig(List> list) { - Log.Debug("FeatureFlagsModule::UpdateConfig -> New config received. {Count}", list.Count); + Log.Debug("FeatureFlagsModule::UpdateRemoteConfig -> New config received. {Count}", list.Count); try { // Feed configs to the rules evaluator @@ -131,7 +91,7 @@ private void UpdateConfig(List> list) } catch (Exception ex) { - Log.Warning(ex, "FeatureFlagsModule::UpdateConfig -> Error processing new config"); + Log.Warning(ex, "FeatureFlagsModule::UpdateRemoteConfig -> Error processing new config"); } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs index 53bccb8216f0..c37a111e1513 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs @@ -16,7 +16,7 @@ namespace Datadog.Trace.AppSec.Rcm; -internal class FfeProduct +internal sealed class FfeProduct { internal static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(FfeProduct)); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Allocation.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Allocation.cs index 43c74c36abc4..46dbbc25a06c 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Allocation.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Allocation.cs @@ -10,7 +10,7 @@ namespace Datadog.Trace.FeatureFlags.Rcm.Model; -internal class Allocation +internal sealed class Allocation { public string? Key { get; set; } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ConditionConfiguration.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ConditionConfiguration.cs index e2b51b5a10c9..8e0a7923e9ca 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ConditionConfiguration.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ConditionConfiguration.cs @@ -10,7 +10,7 @@ namespace Datadog.Trace.FeatureFlags.Rcm.Model; -internal class ConditionConfiguration +internal sealed class ConditionConfiguration { public ConditionOperator? Operator { get; set; } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Environment.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Environment.cs index b5728be10faa..ca17d4bea64d 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Environment.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Environment.cs @@ -10,7 +10,7 @@ namespace Datadog.Trace.FeatureFlags.Rcm.Model; -internal class Environment +internal sealed class Environment { public string? Name { get; set; } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Flag.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Flag.cs index 8215eb47278a..562c8c90307e 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Flag.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Flag.cs @@ -10,7 +10,7 @@ namespace Datadog.Trace.FeatureFlags.Rcm.Model; -internal class Flag +internal sealed class Flag { public string? Key { get; set; } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Rule.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Rule.cs index d9382546bda2..f9c1b27b7da1 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Rule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Rule.cs @@ -10,7 +10,7 @@ namespace Datadog.Trace.FeatureFlags.Rcm.Model; -internal class Rule(List? conditions) +internal sealed class Rule(List? conditions) { public List? Conditions { get; set; } = conditions; } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ServerConfiguration.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ServerConfiguration.cs index e74c534bd8bb..7badc9ec85c6 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ServerConfiguration.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ServerConfiguration.cs @@ -10,7 +10,7 @@ namespace Datadog.Trace.FeatureFlags.Rcm.Model; -internal class ServerConfiguration +internal sealed class ServerConfiguration { public string? CreatedAt { get; set; } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Shard.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Shard.cs index 0841dee177c3..9e2ad75263c1 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Shard.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Shard.cs @@ -11,7 +11,7 @@ namespace Datadog.Trace.FeatureFlags.Rcm.Model; -internal class Shard +internal sealed class Shard { public string? Salt { get; set; } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ShardRange.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ShardRange.cs index 2e2787ca342a..fd97d05fe8fd 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ShardRange.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ShardRange.cs @@ -11,7 +11,7 @@ namespace Datadog.Trace.FeatureFlags.Rcm.Model; -internal class ShardRange +internal sealed class ShardRange { public int Start { get; set; } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Split.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Split.cs index 787515ee3ce8..36c44a87e58f 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Split.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Split.cs @@ -10,7 +10,7 @@ namespace Datadog.Trace.FeatureFlags.Rcm.Model; -internal class Split +internal sealed class Split { public List? Shards { get; set; } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Variant.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Variant.cs index decfe1a586f1..29a6b88241ee 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Variant.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/Variant.cs @@ -10,7 +10,7 @@ namespace Datadog.Trace.FeatureFlags.Rcm.Model; -internal class Variant(string? key, string? value) +internal sealed class Variant(string? key, string? value) { public Variant() : this(null, null) diff --git a/tracer/src/Datadog.Trace/Tracer.cs b/tracer/src/Datadog.Trace/Tracer.cs index 4686a91e2e1e..c0372ad699cd 100644 --- a/tracer/src/Datadog.Trace/Tracer.cs +++ b/tracer/src/Datadog.Trace/Tracer.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. // @@ -16,6 +16,7 @@ using Datadog.Trace.Debugger; using Datadog.Trace.Debugger.SpanCodeOrigin; using Datadog.Trace.DogStatsd; +using Datadog.Trace.FeatureFlags; using Datadog.Trace.Logging.TracerFlare; using Datadog.Trace.Sampling; using Datadog.Trace.SourceGenerators; @@ -55,7 +56,7 @@ public class Tracer : IDatadogTracer, IDatadogOpenTracingTracer /// The created will be scoped specifically to this instance. ///
            internal Tracer(TracerSettings settings, IAgentWriter agentWriter, ITraceSampler sampler, IScopeManager scopeManager, IStatsdManager statsd, ITelemetryController telemetry = null, IDiscoveryService discoveryService = null) - : this(TracerManagerFactory.Instance.CreateTracerManager(settings, agentWriter, sampler, scopeManager, statsd, runtimeMetrics: null, logSubmissionManager: null, telemetry: telemetry ?? NullTelemetryController.Instance, discoveryService ?? NullDiscoveryService.Instance, dataStreamsManager: null, remoteConfigurationManager: null, dynamicConfigurationManager: null, tracerFlareManager: null, spanEventsManager: null)) + : this(TracerManagerFactory.Instance.CreateTracerManager(settings, agentWriter, sampler, scopeManager, statsd, runtimeMetrics: null, logSubmissionManager: null, telemetry: telemetry ?? NullTelemetryController.Instance, discoveryService ?? NullDiscoveryService.Instance, dataStreamsManager: null, remoteConfigurationManager: null, dynamicConfigurationManager: null, tracerFlareManager: null, spanEventsManager: null, featureFlags: null)) { } diff --git a/tracer/src/Datadog.Trace/TracerManager.cs b/tracer/src/Datadog.Trace/TracerManager.cs index aa224b5db74a..7aabf225ca48 100644 --- a/tracer/src/Datadog.Trace/TracerManager.cs +++ b/tracer/src/Datadog.Trace/TracerManager.cs @@ -19,6 +19,7 @@ using Datadog.Trace.ContinuousProfiler; using Datadog.Trace.DataStreamsMonitoring; using Datadog.Trace.DogStatsd; +using Datadog.Trace.FeatureFlags; using Datadog.Trace.LibDatadog.ServiceDiscovery; using Datadog.Trace.Logging; using Datadog.Trace.Logging.DirectSubmission; @@ -74,6 +75,7 @@ public TracerManager( IDynamicConfigurationManager dynamicConfigurationManager, ITracerFlareManager tracerFlareManager, ISpanEventsManager spanEventsManager, + FeatureFlagsModule featureFlagsModule, ITraceProcessor[] traceProcessors = null) { Settings = settings; @@ -103,6 +105,7 @@ public TracerManager( DynamicConfigurationManager = dynamicConfigurationManager; TracerFlareManager = tracerFlareManager; SpanEventsManager = spanEventsManager; + FeatureFlags = featureFlagsModule; SpanContextPropagator = SpanContextPropagatorFactory.GetSpanContextPropagator(settings.PropagationStyleInject, settings.PropagationStyleExtract, settings.PropagationExtractFirstOnly, settings.PropagationBehaviorExtract); UpdatePerTraceSettings(settings.Manager.InitialMutableSettings); @@ -177,6 +180,8 @@ public static TracerManager Instance public ISpanEventsManager SpanEventsManager { get; } + public FeatureFlagsModule FeatureFlags { get; } + public PerTraceSettings PerTraceSettings => Volatile.Read(ref _perTraceSettings); public SpanContextPropagator SpanContextPropagator { get; } @@ -304,10 +309,17 @@ private static async Task CleanUpOldTracerManager(TracerManager oldManager, Trac oldManager.TracerFlareManager.Dispose(); } + var featureFlagsReplaced = false; + if (oldManager.FeatureFlags != newManager.FeatureFlags && oldManager.FeatureFlags is not null) + { + featureFlagsReplaced = true; + oldManager.FeatureFlags.Dispose(); + } + Log.Information( exception: null, - "Replaced global instances. AgentWriter: {AgentWriterReplaced}, StatsD: {StatsDReplaced}, RuntimeMetricsWriter: {RuntimeMetricsWriterReplaced}, Discovery: {DiscoveryReplaced}, DataStreamsManager: {DataStreamsManagerReplaced}, RemoteConfigurationManager: {ConfigurationManagerReplaced}, DynamicConfigurationManager: {DynamicConfigurationManagerReplaced}, TracerFlareManager {TracerFlareManagerReplaced}", - new object[] { agentWriterReplaced, statsdReplaced, runtimeMetricsWriterReplaced, discoveryReplaced, dataStreamsReplaced, configurationManagerReplaced, dynamicConfigurationManagerReplaced, tracerFlareManagerReplaced }); + "Replaced global instances. AgentWriter: {AgentWriterReplaced}, StatsD: {StatsDReplaced}, RuntimeMetricsWriter: {RuntimeMetricsWriterReplaced}, Discovery: {DiscoveryReplaced}, DataStreamsManager: {DataStreamsManagerReplaced}, RemoteConfigurationManager: {ConfigurationManagerReplaced}, DynamicConfigurationManager: {DynamicConfigurationManagerReplaced}, TracerFlareManager {TracerFlareManagerReplaced}, FeatureFlags {FeatureFlagsReplaced}", + new object[] { agentWriterReplaced, statsdReplaced, runtimeMetricsWriterReplaced, discoveryReplaced, dataStreamsReplaced, configurationManagerReplaced, dynamicConfigurationManagerReplaced, tracerFlareManagerReplaced, featureFlagsReplaced }); } catch (Exception ex) { @@ -749,6 +761,8 @@ private static async Task RunShutdownTasksAsync(TracerManager instance, Timer he var dataStreamsTask = instance.DataStreamsManager?.DisposeAsync() ?? Task.CompletedTask; Log.Debug("Disposing RemoteConfigurationManager"); instance.RemoteConfigurationManager?.Dispose(); + Log.Debug("Disposing FeatureFlagsManager"); + instance.FeatureFlags?.Dispose(); Log.Debug("Waiting for disposals."); await Task.WhenAll(flushTracesTask, logSubmissionTask, discoveryService, dataStreamsTask).ConfigureAwait(false); diff --git a/tracer/src/Datadog.Trace/TracerManagerFactory.cs b/tracer/src/Datadog.Trace/TracerManagerFactory.cs index fa1adb240b5b..afd8f998e636 100644 --- a/tracer/src/Datadog.Trace/TracerManagerFactory.cs +++ b/tracer/src/Datadog.Trace/TracerManagerFactory.cs @@ -13,6 +13,7 @@ using Datadog.Trace.ContinuousProfiler; using Datadog.Trace.DataStreamsMonitoring; using Datadog.Trace.DogStatsd; +using Datadog.Trace.FeatureFlags; using Datadog.Trace.LibDatadog; using Datadog.Trace.LibDatadog.DataPipeline; using Datadog.Trace.LibDatadog.HandsOffConfiguration; @@ -61,7 +62,8 @@ internal TracerManager CreateTracerManager(TracerSettings settings, TracerManage remoteConfigurationManager: null, dynamicConfigurationManager: null, tracerFlareManager: null, - spanEventsManager: null); + spanEventsManager: null, + featureFlags: null); tracer.Settings.Manager.SubscribeToChanges(changes => { @@ -105,7 +107,8 @@ internal TracerManager CreateTracerManager( IRemoteConfigurationManager remoteConfigurationManager, IDynamicConfigurationManager dynamicConfigurationManager, ITracerFlareManager tracerFlareManager, - ISpanEventsManager spanEventsManager) + ISpanEventsManager spanEventsManager, + FeatureFlagsModule featureFlags) { settings ??= TracerSettings.FromDefaultSourcesInternal(); var result = GlobalConfigurationSource.CreationResult; @@ -186,6 +189,8 @@ internal TracerManager CreateTracerManager( } } + featureFlags = FeatureFlagsModule.Create(settings); + return CreateTracerManagerFrom( settings, agentWriter, @@ -202,7 +207,8 @@ internal TracerManager CreateTracerManager( remoteConfigurationManager, dynamicConfigurationManager, tracerFlareManager, - spanEventsManager); + spanEventsManager, + featureFlags); } protected virtual TelemetrySettings CreateTelemetrySettings(TracerSettings settings) => @@ -242,8 +248,9 @@ protected virtual TracerManager CreateTracerManagerFrom( IRemoteConfigurationManager remoteConfigurationManager, IDynamicConfigurationManager dynamicConfigurationManager, ITracerFlareManager tracerFlareManager, - ISpanEventsManager spanEventsManager) - => new TracerManager(settings, agentWriter, scopeManager, statsd, runtimeMetrics, logSubmissionManager, telemetry, discoveryService, dataStreamsManager, gitMetadataTagsProvider, traceSampler, spanSampler, remoteConfigurationManager, dynamicConfigurationManager, tracerFlareManager, spanEventsManager); + ISpanEventsManager spanEventsManager, + FeatureFlagsModule featureFlagsModule) + => new TracerManager(settings, agentWriter, scopeManager, statsd, runtimeMetrics, logSubmissionManager, telemetry, discoveryService, dataStreamsManager, gitMetadataTagsProvider, traceSampler, spanSampler, remoteConfigurationManager, dynamicConfigurationManager, tracerFlareManager, spanEventsManager, featureFlagsModule); protected virtual ITraceSampler GetSampler(TracerSettings settings) { diff --git a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs index c569bf6721d7..d4eb4a42cd44 100644 --- a/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs +++ b/tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/FeatureFlags/FeatureFlagsTests.cs @@ -80,7 +80,7 @@ public async Task FfeEnabled() { if (e.Value.PathAndQuery.EndsWith("api/v2/exposure")) { - eventsReceived++; + Interlocked.Increment(ref eventsReceived); e.Value.Headers["Content-Encoding"].Should().Be(MimeTypes.Json); var payload = JsonConvert.DeserializeObject(e.Value.BodyInJson); return; diff --git a/tracer/test/Datadog.Trace.Tests/TracerInstanceTest.cs b/tracer/test/Datadog.Trace.Tests/TracerInstanceTest.cs index 540ef8962d1d..20cf703090f5 100644 --- a/tracer/test/Datadog.Trace.Tests/TracerInstanceTest.cs +++ b/tracer/test/Datadog.Trace.Tests/TracerInstanceTest.cs @@ -115,7 +115,7 @@ internal LockedTracer() private class LockedTracerManager : TracerManager, ILockedTracer { public LockedTracerManager() - : base(new TracerSettings(), null, null, null, null, null, null, null, null, null, null, null, Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of()) + : base(new TracerSettings(), null, null, null, null, null, null, null, null, null, null, null, Mock.Of(), Mock.Of(), Mock.Of(), Mock.Of(), null) { } } diff --git a/tracer/test/Datadog.Trace.Tests/TracerManagerFactoryTests.cs b/tracer/test/Datadog.Trace.Tests/TracerManagerFactoryTests.cs index 9427a97eacb5..f78ad2ab5a8a 100644 --- a/tracer/test/Datadog.Trace.Tests/TracerManagerFactoryTests.cs +++ b/tracer/test/Datadog.Trace.Tests/TracerManagerFactoryTests.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. // @@ -143,7 +143,8 @@ private static TracerManager CreateTracerManager(TracerSettings settings) remoteConfigurationManager: null, dynamicConfigurationManager: null, tracerFlareManager: null, - spanEventsManager: null); + spanEventsManager: null, + featureFlags: null); static DirectLogSubmissionManager BuildLogSubmissionManager() => DirectLogSubmissionManager.Create( diff --git a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Evaluator.cs b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Evaluator.cs new file mode 100644 index 000000000000..d00780bf53df --- /dev/null +++ b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Evaluator.cs @@ -0,0 +1,36 @@ +using System; +using System.Diagnostics; +using System.Threading; +using Datadog.Trace.FeatureFlags; + +namespace Samples.FeatureFlags; +class Evaluator +{ + public static void Init() + { + Console.WriteLine("FeatureFlags SDK Sample"); + } + + public static (string? Value, string? Error)? Evaluate(string key) + { + var context = new EvaluationContext(key); + var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, Datadog.Trace.FeatureFlags.ValueType.STRING, "Not found", context); + + if (evaluation is null) + { + Console.WriteLine($"Eval ({key}) : (FeatureFlagsSdk is disabled)"); + return null; + } + + if (evaluation.Error is not null) + { + Console.WriteLine($"Eval ({key}) : "); + } + else + { + Console.WriteLine($"Eval ({key}) : "}>"); + } + + return (evaluation.Value as string, evaluation.Error); + } +} diff --git a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs index c55557dfa608..d61c4d720eba 100644 --- a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs +++ b/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs @@ -9,7 +9,7 @@ class Program private static void Main(string[] args) { - Console.WriteLine("FeatureFlags SDK Sample"); + Evaluator.Init(); if (!Datadog.Trace.FeatureFlags.FeatureFlagsSdk.IsAvailable()) { @@ -19,8 +19,8 @@ private static void Main(string[] args) Console.WriteLine($""); - var ev = Evaluate("nonexistent"); - if (ev != null && ev.Error is "FeatureFlagsSdk is disabled") + var ev = Evaluator.Evaluate("nonexistent"); + if (ev == null || ev.Value.Error is "FeatureFlagsSdk is disabled") { return; } @@ -41,32 +41,12 @@ private static void Main(string[] args) System.Threading.Thread.Sleep(1000); } - Evaluate("exposure-flag"); - Evaluate("simple-string"); - Evaluate("rule-based-flag"); - Evaluate("numeric-rule-flag"); - Evaluate("time-based-flag"); - - IEvaluation? Evaluate(string key) - { - var context = new EvaluationContext(key); - var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, Datadog.Trace.FeatureFlags.ValueType.STRING, "Not found", context); - - if (evaluation is null) - { - Console.WriteLine($"Eval ({key}) : "); - } - else if (evaluation.Error is not null) - { - Console.WriteLine($"Eval ({key}) : "); - } - else - { - Console.WriteLine($"Eval ({key}) : "}>"); - } + Evaluator.Evaluate("exposure-flag"); + Evaluator.Evaluate("simple-string"); + Evaluator.Evaluate("rule-based-flag"); + Evaluator.Evaluate("numeric-rule-flag"); + Evaluator.Evaluate("time-based-flag"); + } - return evaluation; - } - } } diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature/DatadogProvider.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature/DatadogProvider.cs index 5a4e2ac89ad9..88641ec72bb8 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature/DatadogProvider.cs +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature/DatadogProvider.cs @@ -130,7 +130,17 @@ public override Task> ResolveStructureValueAsync(string private static ResolutionDetails GetResolutionDetails(Datadog.Trace.FeatureFlags.IEvaluation? evaluation) { - if (evaluation == null) { return default!; } + if (evaluation == null) + { + return new ResolutionDetails( + null, + default, + ErrorType.ProviderNotReady, + default, + default, + "FeatureFlagsSdk is disabled", + null); + } var res = new ResolutionDetails( evaluation.FlagKey, (T)(evaluation.Value ?? default(T)!), diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature/Evaluator.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature/Evaluator.cs new file mode 100644 index 000000000000..20c0e7e2af5a --- /dev/null +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature/Evaluator.cs @@ -0,0 +1,41 @@ +using System; +using System.Threading; +using OpenFeature.Model; + +namespace Samples.FeatureFlags; + +class Evaluator +{ + static global::OpenFeature.FeatureClient client; + + public static void Init() + { + Console.WriteLine("OpenFeature FeatureFlags SDK Sample"); + + global::OpenFeature.Api.Instance.SetProviderAsync(new Datadog.FeatureFlags.OpenFeature.DatadogProvider()).Wait(); + client = global::OpenFeature.Api.Instance.GetClient(); + } + + public static (string? Value, string? Error)? Evaluate(string key) + { + var context = EvaluationContext.Builder().Set("targetingKey", key).Build(); + var evaluation = client.GetStringDetailsAsync(key, "Not found", context).Result; + + if (evaluation is null || string.IsNullOrEmpty(evaluation.FlagKey)) + { + Console.WriteLine($"Eval ({key}) : (FeatureFlagsSdk is disabled)"); + return null; + } + + if (evaluation.ErrorMessage is not null) + { + Console.WriteLine($"Eval ({key}) : "); + } + else + { + Console.WriteLine($"Eval ({key}) : "}>"); + } + + return (evaluation.Value, evaluation.ErrorMessage); + } +} diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature/Program.cs b/tracer/test/test-applications/feature-flags/Samples.OpenFeature/Program.cs deleted file mode 100644 index f646eab99623..000000000000 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature/Program.cs +++ /dev/null @@ -1,75 +0,0 @@ -using System; -using System.Threading; -using OpenFeature.Model; - -namespace Samples.OpenFeature; - -class Program -{ - - private static void Main(string[] args) - { - Console.WriteLine("OpenFeature 2.9 FeatureFlags SDK Sample"); - - global::OpenFeature.Api.Instance.SetProviderAsync(new Datadog.FeatureFlags.OpenFeature.DatadogProvider()).Wait(); - var client = global::OpenFeature.Api.Instance.GetClient(); - - if (!Datadog.Trace.FeatureFlags.FeatureFlagsSdk.IsAvailable()) - { - Console.WriteLine($""); - return; - } - - Console.WriteLine($""); - - var ev = Evaluate("nonexistent"); - if (ev != null && ev.ErrorMessage is "FeatureFlagsSdk is disabled") - { - return; - } - - - int configUpdates = 0; - Datadog.Trace.FeatureFlags.FeatureFlagsSdk.RegisterOnNewConfigEventHandler(() => Interlocked.Increment(ref configUpdates)); - - int attempts = 5; - while (configUpdates == 0) - { - if (attempts-- == 0) - { - Console.WriteLine($"No RC received"); - return; - } - Console.WriteLine($"Waiting for RC..."); - System.Threading.Thread.Sleep(1000); - } - - Evaluate("exposure-flag"); - Evaluate("simple-string"); - Evaluate("rule-based-flag"); - Evaluate("numeric-rule-flag"); - Evaluate("time-based-flag"); - - FlagEvaluationDetails? Evaluate(string key) - { - var context = EvaluationContext.Builder().Set("targetingKey", key).Build(); - var evaluation = client.GetStringDetailsAsync(key, "Not found", context).Result; - - if (evaluation is null) - { - Console.WriteLine($"Eval ({key}) : "); - } - else if (evaluation.ErrorMessage is not null) - { - Console.WriteLine($"Eval ({key}) : "); - } - else - { - Console.WriteLine($"Eval ({key}) : "}>"); - } - - return evaluation; - } - - } -} diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature/Samples.OpenFeature.csproj b/tracer/test/test-applications/feature-flags/Samples.OpenFeature/Samples.OpenFeature.csproj index da5eb46ced48..bae090bacbd4 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature/Samples.OpenFeature.csproj +++ b/tracer/test/test-applications/feature-flags/Samples.OpenFeature/Samples.OpenFeature.csproj @@ -8,6 +8,10 @@ 2.9.0 + + + + From b230e385ca97f75b7dd68f85f604d0218e0eeee1 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Fri, 19 Dec 2025 19:07:48 +0100 Subject: [PATCH 34/54] Fix trimming file --- .../Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml | 3 --- 1 file changed, 3 deletions(-) diff --git a/tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml b/tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml index a6bea9519727..e729b88100d6 100644 --- a/tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml +++ b/tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml @@ -231,7 +231,6 @@ - @@ -583,8 +582,6 @@ - - From e8a462d5c0dd8dda03b7a78db015adac221225c9 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Mon, 22 Dec 2025 13:41:33 +0100 Subject: [PATCH 35/54] PR comments --- .../FeatureFlagsSdkEvaluateIntegration.cs | 2 +- .../Datadog.Trace/FeatureFlags/Evaluation.cs | 21 ++++++------ .../FeatureFlags/FeatureFlagsModule.cs | 2 +- .../FeatureFlags/Rcm/FfeProduct.cs | 33 +++++++++++-------- .../Rcm/Model/ConditionOperator.cs | 1 + 5 files changed, 33 insertions(+), 26 deletions(-) diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs index ce1777a7d8cb..00ba9d4a501e 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs @@ -43,7 +43,7 @@ internal static CallTargetState OnMethodBegin(re return new CallTargetReturn(res.DuckCast()); } - private record struct State(string? Key, FeatureFlags.ValueType TargetType, object? DefaultValue, object? Context) + private sealed record State(string? Key, FeatureFlags.ValueType TargetType, object? DefaultValue, object? Context) { } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs b/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs index 50642a2d8217..6ea76f781430 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Evaluation.cs @@ -12,21 +12,20 @@ using System.Threading.Tasks; using System.Web; -namespace Datadog.Trace.FeatureFlags +namespace Datadog.Trace.FeatureFlags; + +internal sealed class Evaluation(string flagKey, object? value, EvaluationReason reason, string? variant = null, string? error = null, IDictionary? metadata = null) + : IEvaluation { - internal sealed class Evaluation(string flagKey, object? value, EvaluationReason reason, string? variant = null, string? error = null, IDictionary? metadata = null) - : IEvaluation - { - public string FlagKey { get; } = flagKey; + public string FlagKey { get; } = flagKey; - public object? Value { get; } = value; + public object? Value { get; } = value; - public EvaluationReason Reason { get; } = reason; + public EvaluationReason Reason { get; } = reason; - public string? Variant { get; } = variant; + public string? Variant { get; } = variant; - public string? Error { get; } = error; + public string? Error { get; } = error; - public IDictionary? FlagMetadata { get; } = metadata; - } + public IDictionary? FlagMetadata { get; } = metadata; } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index 1ee2d6db583e..752436104d29 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -8,10 +8,10 @@ using System; using System.Collections.Generic; using System.Threading; -using Datadog.Trace.AppSec.Rcm; using Datadog.Trace.Configuration; using Datadog.Trace.Exposure; using Datadog.Trace.FeatureFlags.Exposure.Model; +using Datadog.Trace.FeatureFlags.Rcm; using Datadog.Trace.FeatureFlags.Rcm.Model; using Datadog.Trace.Logging; using Datadog.Trace.RemoteConfigurationManagement; diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs index c37a111e1513..ef2056b5daea 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs @@ -14,7 +14,7 @@ using Datadog.Trace.RemoteConfigurationManagement; using Datadog.Trace.Vendors.Newtonsoft.Json.Linq; -namespace Datadog.Trace.AppSec.Rcm; +namespace Datadog.Trace.FeatureFlags.Rcm; internal sealed class FfeProduct { @@ -34,27 +34,34 @@ public ApplyDetails[] UpdateFromRcm(Dictionary List res = new List(); bool apply = false; - if (removedConfigsByProduct is not null && removedConfigsByProduct.TryGetValue(RcmProducts.FfeFlags, out var removedConfigs)) + try { - foreach (var removedConfig in removedConfigs) + if (removedConfigsByProduct is not null && removedConfigsByProduct.TryGetValue(RcmProducts.FfeFlags, out var removedConfigs)) { - apply |= (_serverConfigurations.RemoveAll((x) => x.Key == removedConfig.Path) > 0); + foreach (var removedConfig in removedConfigs) + { + apply |= (_serverConfigurations.RemoveAll((x) => x.Key == removedConfig.Path) > 0); + } } - } - if (configsByProduct.TryGetValue(RcmProducts.FfeFlags, out var ffeConfigs)) - { - foreach (var ffeConfig in ffeConfigs) + if (configsByProduct.TryGetValue(RcmProducts.FfeFlags, out var ffeConfigs)) { - var serverConfigFile = new NamedRawFile(ffeConfig.Path, ffeConfig.Contents).Deserialize(); - if (serverConfigFile.TypedFile is not null) + foreach (var ffeConfig in ffeConfigs) { - _serverConfigurations.Add(new KeyValuePair(ffeConfig.Path.Path, serverConfigFile.TypedFile)); - res.Insert(0, ApplyDetails.FromOk(ffeConfig.Path.Path)); - apply = true; + var serverConfigFile = new NamedRawFile(ffeConfig.Path, ffeConfig.Contents).Deserialize(); + if (serverConfigFile.TypedFile is not null) + { + _serverConfigurations.Add(new KeyValuePair(ffeConfig.Path.Path, serverConfigFile.TypedFile)); + res.Insert(0, ApplyDetails.FromOk(ffeConfig.Path.Path)); + apply = true; + } } } } + catch (Exception ex) + { + Log.Error(ex, "Error while updating FFE RCM config"); + } if (apply) { diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ConditionOperator.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ConditionOperator.cs index 62d8f01f6d0e..c2a0b6fb3cb3 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ConditionOperator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/Model/ConditionOperator.cs @@ -10,6 +10,7 @@ namespace Datadog.Trace.FeatureFlags.Rcm.Model; +/// Rule operator. Capitalized for json deserialization support internal enum ConditionOperator { LT, From 8c2de83b9e017731670348fdcbc5cc37dce8f37e Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Mon, 22 Dec 2025 19:18:01 +0100 Subject: [PATCH 36/54] PR comments --- Datadog.Trace.Samples.g.sln | 4 +- Datadog.Trace.sln | 4 +- .../FeatureFlags/EvaluationContext.cs | 9 +- .../FeatureFlags/EvaluationReason.cs | 16 ++-- .../FeatureFlags/FeatureFlagsEvaluator.cs | 85 +++++++------------ .../FeatureFlags/FeatureFlagsModule.cs | 2 +- .../FeatureFlags/IEvaluationContext.cs | 2 +- .../Datadog.Trace/FeatureFlags/ValueType.cs | 10 +-- .../FeatureFlagsHelpers.cs | 12 +-- .../FeatureFlagsEvaluatorTests.Bundle.cs | 35 ++++++-- .../FeatureFlagsEvaluatorTests.cs | 77 +++++++++-------- .../Samples.FeatureFlags/Evaluator.cs | 2 +- .../Samples.FeatureFlags/Program.cs | 0 .../Samples.FeatureFlags.csproj | 0 .../Samples.OpenFeature/DatadogProvider.cs | 10 +-- .../Samples.OpenFeature/Evaluator.cs | 0 .../Samples.OpenFeature.csproj | 0 17 files changed, 130 insertions(+), 138 deletions(-) rename tracer/test/test-applications/{feature-flags => integrations}/Samples.FeatureFlags/Evaluator.cs (93%) rename tracer/test/test-applications/{feature-flags => integrations}/Samples.FeatureFlags/Program.cs (100%) rename tracer/test/test-applications/{feature-flags => integrations}/Samples.FeatureFlags/Samples.FeatureFlags.csproj (100%) rename tracer/test/test-applications/{feature-flags => integrations}/Samples.OpenFeature/DatadogProvider.cs (95%) rename tracer/test/test-applications/{feature-flags => integrations}/Samples.OpenFeature/Evaluator.cs (100%) rename tracer/test/test-applications/{feature-flags => integrations}/Samples.OpenFeature/Samples.OpenFeature.csproj (100%) diff --git a/Datadog.Trace.Samples.g.sln b/Datadog.Trace.Samples.g.sln index 301603ec359d..ee202f71d615 100644 --- a/Datadog.Trace.Samples.g.sln +++ b/Datadog.Trace.Samples.g.sln @@ -451,9 +451,9 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.Quartz", "tracer\te EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.AzureFunctions.V4Isolated.HostLogsDisabled", "tracer\test\test-applications\azure-functions\Samples.AzureFunctions.V4Isolated.HostLogsDisabled\Samples.AzureFunctions.V4Isolated.HostLogsDisabled.csproj", "{C770F9F8-0430-587D-EB7A-8BEC2FE9B61C}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.FeatureFlags", "tracer\test\test-applications\feature-flags\Samples.FeatureFlags\Samples.FeatureFlags.csproj", "{D5A8ABB9-CB23-974E-F338-5D9172D96CD8}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.FeatureFlags", "tracer\test\test-applications\integrations\Samples.FeatureFlags\Samples.FeatureFlags.csproj", "{D5A8ABB9-CB23-974E-F338-5D9172D96CD8}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.OpenFeature", "tracer\test\test-applications\feature-flags\Samples.OpenFeature\Samples.OpenFeature.csproj", "{021D714E-1764-D76B-15B5-C9114FE934C2}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.OpenFeature", "tracer\test\test-applications\integrations\Samples.OpenFeature\Samples.OpenFeature.csproj", "{021D714E-1764-D76B-15B5-C9114FE934C2}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/Datadog.Trace.sln b/Datadog.Trace.sln index 57baebd0ed23..2d02a4b1e727 100644 --- a/Datadog.Trace.sln +++ b/Datadog.Trace.sln @@ -627,9 +627,9 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.AzureFunctions.V4Is EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "feature-flags", "feature-flags", "{D0C69381-F696-4113-BE7E-BA43468F431C}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.FeatureFlags", "tracer\test\test-applications\feature-flags\Samples.FeatureFlags\Samples.FeatureFlags.csproj", "{D5A8ABB9-CB23-974E-F338-5D9172D96CD8}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.FeatureFlags", "tracer\test\test-applications\integrations\Samples.FeatureFlags\Samples.FeatureFlags.csproj", "{D5A8ABB9-CB23-974E-F338-5D9172D96CD8}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.OpenFeature", "tracer\test\test-applications\feature-flags\Samples.OpenFeature\Samples.OpenFeature.csproj", "{021D714E-1764-D76B-15B5-C9114FE934C2}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.OpenFeature", "tracer\test\test-applications\integrations\Samples.OpenFeature\Samples.OpenFeature.csproj", "{021D714E-1764-D76B-15B5-C9114FE934C2}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Datadog.Trace.Tools.Analyzers.CodeFixes", "tracer\src\Datadog.Trace.Tools.Analyzers.CodeFixes\Datadog.Trace.Tools.Analyzers.CodeFixes.csproj", "{32521F0A-D52D-4DB1-86C4-3D72DEDA6E55}" EndProject diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs index f69bfff9e2b3..8d4a13d88ce9 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs @@ -29,13 +29,6 @@ public sealed class EvaluationContext(string key, IDictionary? /// Value key /// Returns Context Value or null public object? GetAttribute(string key) - { - if (Attributes is null || !Attributes.TryGetValue(key, out var res)) - { - return null; - } - - return res; - } + => Attributes.TryGetValue(key, out var res) ? res : null; } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationReason.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationReason.cs index be51f6be35a0..8553630f699e 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationReason.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationReason.cs @@ -15,26 +15,26 @@ namespace Datadog.Trace.FeatureFlags; public enum EvaluationReason { /// Default value - DEFAULT, + Default, /// Static value - STATIC, + Static, /// Targeting match - TARGETING_MATCH, + TargetingMatch, /// Split match - SPLIT, + Split, /// Target disabled - DISABLED, + Disabled, /// Cached result - CACHED, + Cached, /// Unknown reason - UNKNOWN, + Unknown, /// Error - ERROR + Error } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index 741297044f71..b9c90937a7a2 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -23,17 +23,7 @@ internal sealed class FeatureFlagsEvaluator { internal static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(FeatureFlagsEvaluator)); - private static readonly string[] DateFormats = - { - "MM-dd-yyyy HH:mm:ss", - "MM/dd/yyyy HH:mm:ss", - "yyyy-MM-dd HH:mm:ss", - "yyyy/MM/dd HH:mm:ss", - "yyyy-MM-dd'T'HH:mm:ss.fff'Z'", - "yyyy-MM-dd'T'HH:mm:ss'Z'", - "MM-dd-yyyy'T'HH:mm:ss.fff'Z'", - "MM-dd-yyyy'T'HH:mm:ss'Z'", - }; + internal static readonly string DateFormat = "yyyy-MM-dd'T'HH:mm:ss.fff'Z'"; private readonly ReportExposureDelegate? _onExposureEvent; private readonly ServerConfiguration? _config; @@ -66,7 +56,7 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default return new Evaluation( flagKey, defaultValue, - EvaluationReason.ERROR, + EvaluationReason.Error, error: "PROVIDER_NOT_READY", metadata: new Dictionary { @@ -79,7 +69,7 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default return new Evaluation( flagKey, defaultValue, - EvaluationReason.ERROR, + EvaluationReason.Error, error: "TARGETING_KEY_MISSING", metadata: new Dictionary { @@ -92,7 +82,7 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default return new Evaluation( flagKey, defaultValue, - EvaluationReason.ERROR, + EvaluationReason.Error, error: "FLAG_NOT_FOUND", metadata: new Dictionary { @@ -105,7 +95,7 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default return new Evaluation( flagKey, defaultValue, - EvaluationReason.DISABLED); + EvaluationReason.Disabled); } if (flag.VariationType != resultType) @@ -113,7 +103,7 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default return new Evaluation( flagKey, defaultValue, - EvaluationReason.ERROR, + EvaluationReason.Error, error: "TYPE_MISMATCH", metadata: new Dictionary { @@ -126,13 +116,7 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default return new Evaluation( flagKey, defaultValue, - EvaluationReason.ERROR, - error: "Missing allocations", - metadata: new Dictionary - { - ["errorCode"] = "GENERAL", - ["message"] = $"Missing allocations for flag {flag.Key}" - }); + EvaluationReason.Default); } var now = DateTime.UtcNow; @@ -157,18 +141,16 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default { foreach (var split in allocation.Splits) { - if (split.Shards is { Count: 0 }) - { - return ResolveVariant(flagKey, resultType, defaultValue, flag, split.VariationKey ?? string.Empty, allocation, context); - } - var allShardsMatch = true; - foreach (var shard in split.Shards!) + if (split.Shards is { Count: > 0 }) { - if (!MatchesShard(shard, targetingKey)) + foreach (var shard in split.Shards!) { - allShardsMatch = false; - break; + if (!MatchesShard(shard, targetingKey)) + { + allShardsMatch = false; + break; + } } } @@ -184,7 +166,7 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default return new Evaluation( flagKey, defaultValue, - EvaluationReason.DEFAULT); + EvaluationReason.Default); } catch (FormatException ex) { @@ -192,7 +174,7 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default return new Evaluation( flagKey, defaultValue, - EvaluationReason.ERROR, + EvaluationReason.Error, error: "TYPE_MISMATCH", metadata: new Dictionary { @@ -205,7 +187,7 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default return new Evaluation( flagKey, defaultValue, - EvaluationReason.ERROR, + EvaluationReason.Error, error: ex.Message, metadata: new Dictionary { @@ -226,7 +208,7 @@ private static bool IsAllocationActive(Allocation allocation, DateTime now) } var endDate = ParseDate(allocation.EndAt); - if (endDate.HasValue && now > endDate.Value) + if (endDate.HasValue && now >= endDate.Value) { return false; } @@ -436,17 +418,14 @@ private static string GetMd5Hash(string input) return null; } - foreach (var fmt in DateFormats) + if (DateTime.TryParseExact( + dateString, + DateFormat, + System.Globalization.CultureInfo.InvariantCulture, + System.Globalization.DateTimeStyles.AdjustToUniversal, + out var dt)) { - if (DateTime.TryParseExact( - dateString, - fmt, - System.Globalization.CultureInfo.InvariantCulture, - System.Globalization.DateTimeStyles.AdjustToUniversal, - out var dt)) - { - return dt; - } + return dt; } return null; @@ -475,12 +454,12 @@ private static string GetMd5Hash(string input) return default!; } - if (target == ValueType.STRING) + if (target == ValueType.String) { return Convert.ToString(value, CultureInfo.InvariantCulture); } - if (target == ValueType.BOOLEAN) + if (target == ValueType.Boolean) { if (value is IConvertible) { @@ -495,19 +474,19 @@ private static string GetMd5Hash(string input) return bool.Parse(value.ToString()!); } - if (target == ValueType.INTEGER) + if (target == ValueType.Integer) { var number = ParseDouble(value); return (int)number; } - if (target == ValueType.NUMERIC) + if (target == ValueType.Numeric) { var number = ParseDouble(value); return (double)number; } - if (target == ValueType.JSON) + if (target == ValueType.Json) { if (value is JObject) { @@ -613,7 +592,7 @@ private Evaluation ResolveVariant( return new Evaluation( flagKey, defaultValue, - EvaluationReason.ERROR, + EvaluationReason.Error, error: $"Variant not found for: {variationKey}", metadata: new Dictionary { @@ -634,7 +613,7 @@ private Evaluation ResolveVariant( var evaluation = new Evaluation( flagKey, mappedValue, - EvaluationReason.TARGETING_MATCH, + EvaluationReason.TargetingMatch, variant: variant.Key, metadata: metadata); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index 752436104d29..92d411ea60c1 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -70,7 +70,7 @@ internal Evaluation Evaluate(string flagKey, ValueType resultType, object? defau if (_evaluator is null) { Log.Debug("FeatureFlagsModule::Evaluate -> Evaluator is null (no config received)"); - return new Evaluation(flagKey, null, EvaluationReason.ERROR, null, "No config loaded"); + return new Evaluation(flagKey, null, EvaluationReason.Error, null, "No config loaded"); } Log.Debug("FeatureFlagsModule::Evaluate -> Returning Evaluation"); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs index 9208d6d28c8a..1eb7c65900e3 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs @@ -15,7 +15,7 @@ namespace Datadog.Trace.FeatureFlags; [Browsable(false)] public partial interface IEvaluationContext { - /// Gets the tareting key. + /// Gets the targeting key. string TargetingKey { get; } /// Gets context attributes. diff --git a/tracer/src/Datadog.Trace/FeatureFlags/ValueType.cs b/tracer/src/Datadog.Trace/FeatureFlags/ValueType.cs index 8eefadb666d8..14dae134d8c8 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/ValueType.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/ValueType.cs @@ -15,17 +15,17 @@ namespace Datadog.Trace.FeatureFlags; public enum ValueType { /// Integer numeric value - INTEGER, + Integer, /// Float numeric value - NUMERIC, + Numeric, /// Simple string - STRING, + String, /// Bool value - BOOLEAN, + Boolean, /// Json string value - JSON + Json } diff --git a/tracer/test/Datadog.Trace.TestHelpers/FeatureFlagsHelpers.cs b/tracer/test/Datadog.Trace.TestHelpers/FeatureFlagsHelpers.cs index f21e04d5c0c3..594581179b47 100644 --- a/tracer/test/Datadog.Trace.TestHelpers/FeatureFlagsHelpers.cs +++ b/tracer/test/Datadog.Trace.TestHelpers/FeatureFlagsHelpers.cs @@ -21,7 +21,7 @@ internal static Dictionary CreateAllFlags() { var flags = new Dictionary { - ["simple-string"] = CreateSimpleFlag("simple-string", ValueType.STRING, "test-value", "on"), + ["simple-string"] = CreateSimpleFlag("simple-string", ValueType.String, "test-value", "on"), ["rule-based-flag"] = CreateRuleBasedFlag(), ["numeric-rule-flag"] = CreateNumericRuleFlag(), ["time-based-flag"] = CreateTimeBasedFlag(), @@ -71,7 +71,7 @@ internal static Flag CreateRuleBasedFlag() var basicSplits = new List { new Split { Shards = new List(), VariationKey = "basic" } }; var basicAlloc = new Allocation { Key = "basic-alloc", Splits = basicSplits, DoLog = false }; - return new Flag { Key = "rule-based-flag", Enabled = true, VariationType = ValueType.STRING, Variations = variants, Allocations = new List { premiumAlloc, basicAlloc } }; + return new Flag { Key = "rule-based-flag", Enabled = true, VariationType = ValueType.String, Variations = variants, Allocations = new List { premiumAlloc, basicAlloc } }; } internal static Flag CreateNumericRuleFlag() @@ -94,7 +94,7 @@ internal static Flag CreateNumericRuleFlag() var regularSplits = new List { new Split { Shards = new List(), VariationKey = "regular" } }; var regularAlloc = new Allocation { Key = "regular-alloc", Splits = regularSplits, DoLog = false }; - return new Flag { Key = "numeric-rule-flag", Enabled = true, VariationType = ValueType.STRING, Variations = variants, Allocations = new List { vipAlloc, regularAlloc } }; + return new Flag { Key = "numeric-rule-flag", Enabled = true, VariationType = ValueType.String, Variations = variants, Allocations = new List { vipAlloc, regularAlloc } }; } internal static Flag CreateTimeBasedFlag() @@ -105,9 +105,9 @@ internal static Flag CreateTimeBasedFlag() }; var splits = new List { new Split { Shards = new List(), VariationKey = "time-limited" } }; - var alloc = new Allocation { Key = "time-alloc", StartAt = "2022-01-01T00:00:00Z", EndAt = "2022-12-31T23:59:59Z", Splits = splits, DoLog = false }; + var alloc = new Allocation { Key = "time-alloc", StartAt = "2022-01-01T00:00:00.000Z", EndAt = "2022-12-31T23:59:59.000Z", Splits = splits, DoLog = false }; - return new Flag { Key = "time-based-flag", Enabled = true, VariationType = ValueType.STRING, Variations = variants, Allocations = new List { alloc } }; + return new Flag { Key = "time-based-flag", Enabled = true, VariationType = ValueType.String, Variations = variants, Allocations = new List { alloc } }; } internal static Flag CreateExposureFlag() @@ -120,6 +120,6 @@ internal static Flag CreateExposureFlag() var splits = new List { new Split { VariationKey = "tracked", Shards = new List() } }; var alloc = new Allocation { Key = "exposure-alloc", Splits = splits, DoLog = true }; - return new Flag { Key = "exposure-flag", Enabled = true, VariationType = ValueType.STRING, Variations = variants, Allocations = new List { alloc } }; + return new Flag { Key = "exposure-flag", Enabled = true, VariationType = ValueType.String, Variations = variants, Allocations = new List { alloc } }; } } diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs index db3f65066e53..b97157f68b32 100644 --- a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs @@ -7,6 +7,7 @@ using System; using System.Collections.Generic; +using System.Drawing.Text; using Datadog.Trace.FeatureFlags; using Datadog.Trace.FeatureFlags.Rcm.Model; using Datadog.Trace.TestHelpers; @@ -57,11 +58,11 @@ public void BundledTest(string description, TestCase? testCase) void AssertEqual(object? expected, object? obj) { - if (type == Trace.FeatureFlags.ValueType.INTEGER && obj is int intObj) + if (type == Trace.FeatureFlags.ValueType.Integer && obj is int intObj) { Assert.Equal(Convert.ToInt32(expected), intObj); } - else if (type == Trace.FeatureFlags.ValueType.JSON) + else if (type == Trace.FeatureFlags.ValueType.Json) { if (obj is string jsonTxt) { @@ -83,11 +84,11 @@ private static Trace.FeatureFlags.ValueType GetVariationType(string? variationTy { return variationType switch { - "INTEGER" => Trace.FeatureFlags.ValueType.INTEGER, - "NUMERIC" => Trace.FeatureFlags.ValueType.NUMERIC, - "STRING" => Trace.FeatureFlags.ValueType.STRING, - "BOOLEAN" => Trace.FeatureFlags.ValueType.BOOLEAN, - "JSON" => Trace.FeatureFlags.ValueType.JSON, + "INTEGER" => Trace.FeatureFlags.ValueType.Integer, + "NUMERIC" => Trace.FeatureFlags.ValueType.Numeric, + "STRING" => Trace.FeatureFlags.ValueType.String, + "BOOLEAN" => Trace.FeatureFlags.ValueType.Boolean, + "JSON" => Trace.FeatureFlags.ValueType.Json, _ => throw new NotImplementedException(), }; } @@ -106,6 +107,9 @@ private static ServerConfiguration ReadConfig() if (flag.Value.Allocations is null) { continue; } foreach (var allocation in flag.Value.Allocations) { + allocation.StartAt = FixDateString(allocation.StartAt); + allocation.EndAt = FixDateString(allocation.EndAt); + if (allocation.Rules is null) { continue; } foreach (var rule in allocation.Rules) { @@ -120,6 +124,23 @@ private static ServerConfiguration ReadConfig() } } + static string? FixDateString(string? dateString) + { + if (string.IsNullOrEmpty(dateString)) { return null; } + + if (DateTime.TryParseExact( + dateString!, + "MM/dd/yyyy HH:mm:ss", + System.Globalization.CultureInfo.InvariantCulture, + System.Globalization.DateTimeStyles.AdjustToUniversal, + out var dt)) + { + return dt.ToString(FeatureFlagsEvaluator.DateFormat); + } + + return dateString; + } + var config = new ServerConfiguration { Flags = flags }; return config; diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs index 0d9eaee3aab3..9b4e7c9370b4 100644 --- a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs @@ -70,29 +70,29 @@ public void MapValueTests(object? input, object? expected) { if (expected is null || expected is string) { - var res = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.STRING, input); + var res = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.String, input); Assert.Equal(expected, res); } else if (expected is int expectedInt) { - var res = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.INTEGER, input); + var res = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.Integer, input); Assert.Equal(expected, res); } else if (expected is double expectedDouble) { - var res = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.NUMERIC, input); + var res = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.Numeric, input); Assert.Equal(expected, res); } else if (expected is bool expectedBool) { - var res = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.BOOLEAN, input); + var res = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.Boolean, input); Assert.Equal(expected, res); } else if (expected is System.Type) { try { - _ = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.STRING, input); + _ = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.String, input); } catch (Exception res) { @@ -111,10 +111,10 @@ public void EvaluateWithoutConfigReturnsProviderNotReadyAndDefault() var evaluator = new FeatureFlagsEvaluator(null, null, 1000); var ctx = new EvaluationContext("target"); - var result = evaluator.Evaluate("test", Trace.FeatureFlags.ValueType.INTEGER, 23, ctx); + var result = evaluator.Evaluate("test", Trace.FeatureFlags.ValueType.Integer, 23, ctx); Assert.Equal(23, result.Value); - Assert.Equal(EvaluationReason.ERROR, result.Reason); + Assert.Equal(EvaluationReason.Error, result.Reason); Assert.Equal("PROVIDER_NOT_READY", result.Error); } @@ -124,10 +124,10 @@ public void EvaluateWithMissingTargetingKeyReturnsTargetingKeyMissing() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration(), 1000); var ctx = new EvaluationContext(string.Empty); // no targetingKey - var result = evaluator.Evaluate("flag", Trace.FeatureFlags.ValueType.STRING, "default", ctx); + var result = evaluator.Evaluate("flag", Trace.FeatureFlags.ValueType.String, "default", ctx); Assert.Equal("default", result.Value); - Assert.Equal(EvaluationReason.ERROR, result.Reason); + Assert.Equal(EvaluationReason.Error, result.Reason); Assert.Equal("TARGETING_KEY_MISSING", result.Error); } @@ -136,10 +136,10 @@ public void EvaluateWithUnknownFlagReturnsFlagNotFound() { var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration(), 1000); var ctx = new EvaluationContext("user-123"); - var result = evaluator.Evaluate("unknown", Trace.FeatureFlags.ValueType.STRING, "default", ctx); + var result = evaluator.Evaluate("unknown", Trace.FeatureFlags.ValueType.String, "default", ctx); Assert.Equal("default", result.Value); - Assert.Equal(EvaluationReason.ERROR, result.Reason); + Assert.Equal(EvaluationReason.Error, result.Reason); Assert.Equal("FLAG_NOT_FOUND", result.Error); } @@ -148,15 +148,15 @@ public void EvaluateDisabledFlagReturnsDisabledReason() { var flags = new Dictionary { - ["disabled-flag"] = new Flag { Key = "disabled-flag", Enabled = false, VariationType = ValueType.BOOLEAN } + ["disabled-flag"] = new Flag { Key = "disabled-flag", Enabled = false, VariationType = ValueType.Boolean } }; var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user"); - var result = evaluator.Evaluate("disabled-flag", Trace.FeatureFlags.ValueType.BOOLEAN, true, ctx); + var result = evaluator.Evaluate("disabled-flag", Trace.FeatureFlags.ValueType.Boolean, true, ctx); Assert.Equal(true, result.Value); - Assert.Equal(EvaluationReason.DISABLED, result.Reason); + Assert.Equal(EvaluationReason.Disabled, result.Reason); Assert.Null(result.Error); } @@ -165,43 +165,42 @@ public void EvaluateFlagWithTypeMismatchReturnsTypeMismatchError() { var flags = new Dictionary { - ["null-allocation"] = new Flag { Key = "target", Enabled = true, VariationType = ValueType.STRING }, - ["empty-allocation"] = new Flag { Key = "target", Enabled = true, VariationType = ValueType.STRING, Allocations = new List() }, + ["null-allocation"] = new Flag { Key = "target", Enabled = true, VariationType = ValueType.String }, + ["empty-allocation"] = new Flag { Key = "target", Enabled = true, VariationType = ValueType.String, Allocations = new List() }, }; var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("allocation"); - var result1 = evaluator.Evaluate("null-allocation", Trace.FeatureFlags.ValueType.BOOLEAN, 23, ctx); + var result1 = evaluator.Evaluate("null-allocation", Trace.FeatureFlags.ValueType.Boolean, 23, ctx); Assert.Equal(23, result1.Value); - Assert.Equal(EvaluationReason.ERROR, result1.Reason); + Assert.Equal(EvaluationReason.Error, result1.Reason); Assert.Equal("TYPE_MISMATCH", result1.FlagMetadata?["errorCode"]); - var result2 = evaluator.Evaluate("empty-allocation", Trace.FeatureFlags.ValueType.NUMERIC, 23, ctx); + var result2 = evaluator.Evaluate("empty-allocation", Trace.FeatureFlags.ValueType.Numeric, 23, ctx); Assert.Equal(23, result2.Value); - Assert.Equal(EvaluationReason.ERROR, result2.Reason); + Assert.Equal(EvaluationReason.Error, result2.Reason); Assert.Equal("TYPE_MISMATCH", result2.FlagMetadata?["errorCode"]); } [Fact] - public void EvaluateFlagWithoutAllocationsReturnsGeneralError() + public void EvaluateFlagWithoutAllocationsReturnsDefaultValue() { var flags = new Dictionary { - ["null-allocation"] = new Flag { Key = "target", Enabled = true, VariationType = ValueType.STRING }, - ["empty-allocation"] = new Flag { Key = "target", Enabled = true, VariationType = ValueType.STRING, Allocations = new List() }, + ["null-allocation"] = new Flag { Key = "target", Enabled = true, VariationType = ValueType.String }, + ["empty-allocation"] = new Flag { Key = "target", Enabled = true, VariationType = ValueType.String, Allocations = new List() }, }; var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("allocation"); - var result1 = evaluator.Evaluate("null-allocation", Trace.FeatureFlags.ValueType.STRING, 23, ctx); + var result1 = evaluator.Evaluate("null-allocation", Trace.FeatureFlags.ValueType.String, 23, ctx); Assert.Equal(23, result1.Value); - Assert.Equal(EvaluationReason.ERROR, result1.Reason); + Assert.Equal(EvaluationReason.Error, result1.Reason); Assert.Equal("GENERAL", result1.FlagMetadata?["errorCode"]); - var result2 = evaluator.Evaluate("empty-allocation", Trace.FeatureFlags.ValueType.STRING, 23, ctx); + var result2 = evaluator.Evaluate("empty-allocation", Trace.FeatureFlags.ValueType.String, 23, ctx); Assert.Equal(23, result2.Value); - Assert.Equal(EvaluationReason.ERROR, result2.Reason); - Assert.Equal("GENERAL", result2.FlagMetadata?["errorCode"]); + Assert.Equal(EvaluationReason.Default, result2.Reason); } // --------------------------------------------------------------------- @@ -265,16 +264,16 @@ public void EvaluateSimpleStringFlagReturnsTargetingMatch() { var flags = new Dictionary { - ["simple-string"] = FeatureFlagsHelpers.CreateSimpleFlag("simple-string", ValueType.STRING, "test-value", "on") + ["simple-string"] = FeatureFlagsHelpers.CreateSimpleFlag("simple-string", ValueType.String, "test-value", "on") }; var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user-123"); - var result = evaluator.Evaluate("simple-string", Trace.FeatureFlags.ValueType.STRING, "default", ctx); + var result = evaluator.Evaluate("simple-string", Trace.FeatureFlags.ValueType.String, "default", ctx); Assert.Equal("test-value", result.Value); - Assert.Equal(EvaluationReason.TARGETING_MATCH, result.Reason); + Assert.Equal(EvaluationReason.TargetingMatch, result.Reason); Assert.Equal("on", result.Variant); } @@ -289,10 +288,10 @@ public void EvaluateRuleBasedFlagMatchesEmailPremium() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user-premium", new Dictionary { { "email", "john@company.com" } }); - var result = evaluator.Evaluate("rule-based-flag", Trace.FeatureFlags.ValueType.STRING, "default", ctx); + var result = evaluator.Evaluate("rule-based-flag", Trace.FeatureFlags.ValueType.String, "default", ctx); Assert.Equal("premium", result.Value); - Assert.Equal(EvaluationReason.TARGETING_MATCH, result.Reason); + Assert.Equal(EvaluationReason.TargetingMatch, result.Reason); Assert.Equal("premium", result.Variant); } @@ -307,10 +306,10 @@ public void EvaluateNumericRuleFlagMatchesScoreGte800() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user-vip", new Dictionary { { "score", 850 } }); - var result = evaluator.Evaluate("numeric-rule-flag", Trace.FeatureFlags.ValueType.STRING, "default", ctx); + var result = evaluator.Evaluate("numeric-rule-flag", Trace.FeatureFlags.ValueType.String, "default", ctx); Assert.Equal("vip", result.Value); - Assert.Equal(EvaluationReason.TARGETING_MATCH, result.Reason); + Assert.Equal(EvaluationReason.TargetingMatch, result.Reason); Assert.Equal("vip", result.Variant); } @@ -325,10 +324,10 @@ public void EvaluateTimeBasedFlagWithExpiredAllocationReturnsDefaultReason() var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user"); - var result = evaluator.Evaluate("time-based-flag", Trace.FeatureFlags.ValueType.STRING, "default", ctx); + var result = evaluator.Evaluate("time-based-flag", Trace.FeatureFlags.ValueType.String, "default", ctx); Assert.Equal("default", result.Value); - Assert.Equal(EvaluationReason.DEFAULT, result.Reason); + Assert.Equal(EvaluationReason.Default, result.Reason); } [Fact] @@ -343,10 +342,10 @@ public void EvaluateExposureFlagLogsExposureEvent() var evaluator = new FeatureFlagsEvaluator((in e) => events.Add(e), new ServerConfiguration { Flags = flags }); var ctx = new EvaluationContext("user-123"); - var result = evaluator.Evaluate("exposure-flag", Trace.FeatureFlags.ValueType.STRING, "default", ctx); + var result = evaluator.Evaluate("exposure-flag", Trace.FeatureFlags.ValueType.String, "default", ctx); Assert.Equal("tracked-value", result.Value); - Assert.Equal(EvaluationReason.TARGETING_MATCH, result.Reason); + Assert.Equal(EvaluationReason.TargetingMatch, result.Reason); Assert.Equal("tracked", result.Variant); // DoLog=true -> one exposure event diff --git a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Evaluator.cs b/tracer/test/test-applications/integrations/Samples.FeatureFlags/Evaluator.cs similarity index 93% rename from tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Evaluator.cs rename to tracer/test/test-applications/integrations/Samples.FeatureFlags/Evaluator.cs index d00780bf53df..672861cd1116 100644 --- a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Evaluator.cs +++ b/tracer/test/test-applications/integrations/Samples.FeatureFlags/Evaluator.cs @@ -14,7 +14,7 @@ public static void Init() public static (string? Value, string? Error)? Evaluate(string key) { var context = new EvaluationContext(key); - var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, Datadog.Trace.FeatureFlags.ValueType.STRING, "Not found", context); + var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, Datadog.Trace.FeatureFlags.ValueType.String, "Not found", context); if (evaluation is null) { diff --git a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs b/tracer/test/test-applications/integrations/Samples.FeatureFlags/Program.cs similarity index 100% rename from tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Program.cs rename to tracer/test/test-applications/integrations/Samples.FeatureFlags/Program.cs diff --git a/tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Samples.FeatureFlags.csproj b/tracer/test/test-applications/integrations/Samples.FeatureFlags/Samples.FeatureFlags.csproj similarity index 100% rename from tracer/test/test-applications/feature-flags/Samples.FeatureFlags/Samples.FeatureFlags.csproj rename to tracer/test/test-applications/integrations/Samples.FeatureFlags/Samples.FeatureFlags.csproj diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature/DatadogProvider.cs b/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs similarity index 95% rename from tracer/test/test-applications/feature-flags/Samples.OpenFeature/DatadogProvider.cs rename to tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs index 88641ec72bb8..f4198a83312d 100644 --- a/tracer/test/test-applications/feature-flags/Samples.OpenFeature/DatadogProvider.cs +++ b/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs @@ -37,7 +37,7 @@ public override Task> ResolveBooleanValueAsync(string fl return Task.Run( () => { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.BOOLEAN, defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Boolean, defaultValue, GetContext(context)); return GetResolutionDetails(res); }, cancellationToken); @@ -54,7 +54,7 @@ public override Task> ResolveDoubleValueAsync(string f return Task.Run( () => { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.NUMERIC, defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Numeric, defaultValue, GetContext(context)); return GetResolutionDetails(res); }, cancellationToken); @@ -71,7 +71,7 @@ public override Task> ResolveIntegerValueAsync(string fla return Task.Run( () => { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.INTEGER, defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Integer, defaultValue, GetContext(context)); return GetResolutionDetails(res); }, cancellationToken); @@ -88,7 +88,7 @@ public override Task> ResolveStringValueAsync(string f return Task.Run( () => { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.STRING, defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.String, defaultValue, GetContext(context)); return GetResolutionDetails(res); }, cancellationToken); @@ -105,7 +105,7 @@ public override Task> ResolveStructureValueAsync(string return Task.Run( () => { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.JSON, defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Json, defaultValue, GetContext(context)); return GetResolutionDetails(res); }, cancellationToken); diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature/Evaluator.cs b/tracer/test/test-applications/integrations/Samples.OpenFeature/Evaluator.cs similarity index 100% rename from tracer/test/test-applications/feature-flags/Samples.OpenFeature/Evaluator.cs rename to tracer/test/test-applications/integrations/Samples.OpenFeature/Evaluator.cs diff --git a/tracer/test/test-applications/feature-flags/Samples.OpenFeature/Samples.OpenFeature.csproj b/tracer/test/test-applications/integrations/Samples.OpenFeature/Samples.OpenFeature.csproj similarity index 100% rename from tracer/test/test-applications/feature-flags/Samples.OpenFeature/Samples.OpenFeature.csproj rename to tracer/test/test-applications/integrations/Samples.OpenFeature/Samples.OpenFeature.csproj From c851f5a1b764d6bea6e2542121bcad484f32a323 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Mon, 22 Dec 2025 19:26:23 +0100 Subject: [PATCH 37/54] PR Comments --- .../FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs | 3 --- 1 file changed, 3 deletions(-) diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs index b97157f68b32..96fed52442f3 100644 --- a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.Bundle.cs @@ -38,9 +38,6 @@ public void BundledTest(string description, TestCase? testCase) var evaluator = new FeatureFlagsEvaluator(null, _config); var ctx = new EvaluationContext(testCase.TargetingKey ?? string.Empty, testCase.Attributes); - // Not supported format - // Skip.If(testCase.VariationType == "JSON", "JSON result format not supported"); - var type = GetVariationType(testCase.VariationType); var result = evaluator.Evaluate(testCase.Flag, type, testCase.DefaultValue, ctx); From c1c3be8601e35d83a5a8f41a0778a788b973883e Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Tue, 23 Dec 2025 12:15:22 +0100 Subject: [PATCH 38/54] PR Comments --- .../FeatureFlagsSdkEvaluateIntegration.cs | 6 +- ...isterOnNewConfigEventHandlerIntegration.cs | 12 ++- .../FeatureFlags/FeatureFlagsEvaluator.cs | 37 ++++--- .../FeatureFlags/FeatureFlagsModule.cs | 2 +- .../Samples.OpenFeature/DatadogProvider.cs | 101 +++++++++--------- 5 files changed, 87 insertions(+), 71 deletions(-) diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs index 00ba9d4a501e..63bb8d462f6b 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs @@ -31,7 +31,7 @@ namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual; [EditorBrowsable(EditorBrowsableState.Never)] public sealed class FeatureFlagsSdkEvaluateIntegration { - internal static CallTargetState OnMethodBegin(ref string? key, ref TTargetType targetType, ref object? defaultValue, ref TContext? context) + internal static CallTargetState OnMethodBegin(ref string key, ref TTargetType targetType, ref object? defaultValue, ref TContext? context) { return new CallTargetState(null, new State(key, (FeatureFlags.ValueType)(Convert.ToInt32(targetType)), defaultValue, context)); } @@ -39,11 +39,11 @@ internal static CallTargetState OnMethodBegin(re internal static CallTargetReturn OnMethodEnd(TReturn? returnValue, Exception? exception, in CallTargetState state) { var parameters = (State)state.State!; - var res = TracerManager.Instance.FeatureFlags?.Evaluate(parameters.Key!, parameters.TargetType, parameters.DefaultValue, parameters.Context.DuckCast()!); + var res = TracerManager.Instance.FeatureFlags?.Evaluate(parameters.Key, parameters.TargetType, parameters.DefaultValue, parameters.Context.DuckCast()); return new CallTargetReturn(res.DuckCast()); } - private sealed record State(string? Key, FeatureFlags.ValueType TargetType, object? DefaultValue, object? Context) + private sealed record State(string Key, FeatureFlags.ValueType TargetType, object? DefaultValue, object? Context) { } } diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs index d2e70fd95f95..a89f728281bb 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs @@ -32,7 +32,17 @@ public sealed class FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration { internal static CallTargetState OnMethodBegin(ref Action? onNewConfig) { + return new CallTargetState(null, onNewConfig); + } + + internal static CallTargetReturn OnMethodEnd(Exception? exception, in CallTargetState state) + { + if (state.State is not Action onNewConfig) + { + throw new ArgumentNullException(); + } + TracerManager.Instance.FeatureFlags?.RegisterOnNewConfigEventHandler(onNewConfig); - return CallTargetState.GetDefault(); + return CallTargetReturn.GetDefault(); } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index b9c90937a7a2..6a78101e78e4 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -175,10 +175,10 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default flagKey, defaultValue, EvaluationReason.Error, - error: "TYPE_MISMATCH", + error: "PARSE_ERROR", metadata: new Dictionary { - ["errorCode"] = "TYPE_MISMATCH" + ["errorCode"] = "PARSE_ERROR" }); } catch (Exception ex) @@ -248,14 +248,14 @@ private static bool EvaluateCondition(ConditionConfiguration condition, IEvaluat { if (condition.Operator is null) { - return false; + throw new FormatException("Condition operator can not be null"); } if (condition.Operator == ConditionOperator.IS_NULL) { var value = ResolveAttribute(condition.Attribute, context); var isNull = value == null; - var expectedNull = condition.Value is bool b ? b : true; + var expectedNull = condition.Value is bool b ? b : throw new FormatException("Bool value expected"); return isNull == expectedNull; } @@ -292,7 +292,7 @@ private static bool MatchesRegex(object attributeValue, object? conditionValue) { if (conditionValue is null) { - return false; + throw new FormatException("Condition value can not be null"); } try @@ -323,7 +323,7 @@ private static bool IsOneOf(object attributeValue, object? conditionValue) foreach (var value in enumerable) { - if (ValuesEqual(attributeValue, value)) + if (CompareString(attributeValue, value)) { return true; } @@ -332,7 +332,7 @@ private static bool IsOneOf(object attributeValue, object? conditionValue) return false; } - private static bool ValuesEqual(object a, object? b) + private static bool CompareString(object a, object? b) { if (b is null) { @@ -349,19 +349,28 @@ private static bool ValuesEqual(object a, object? b) return aTxt.Equals(bTxt); } - if (a is IConvertible || b is IConvertible) + return string.Equals(ToString(a), ToString(b), StringComparison.Ordinal); + + static string? ToString(object obj) { - return CompareNumber(a, b, (first, second) => Math.Abs(first - second) < double.Epsilon); - } + if (obj is bool boolObj) + { + return boolObj switch + { + true => "true", + _ => "false", + }; + } - return string.Equals(Convert.ToString(a), Convert.ToString(b), StringComparison.Ordinal); + return Convert.ToString(obj); + } } private static bool CompareNumber(object attributeValue, object? conditionValue, NumberEquality comparator) { if (conditionValue is null) { - return false; + throw new FormatException("Condition value must not be null"); } var a = ParseDouble(attributeValue); @@ -428,7 +437,7 @@ private static string GetMd5Hash(string input) return dt; } - return null; + throw new FormatException("Wrong date format"); } private static object? ResolveAttribute(string? name, IEvaluationContext? context) @@ -596,7 +605,7 @@ private Evaluation ResolveVariant( error: $"Variant not found for: {variationKey}", metadata: new Dictionary { - ["errorCode"] = "GENERAL", + ["errorCode"] = "PARSE_ERROR", ["message"] = $"Variant not found for: {variationKey}" }); } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index 92d411ea60c1..df1a2a7c74fb 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -65,7 +65,7 @@ internal void RegisterOnNewConfigEventHandler(Action? onNewConfig) _onNewConfigEventHander = onNewConfig; } - internal Evaluation Evaluate(string flagKey, ValueType resultType, object? defaultValue, IEvaluationContext context) + internal Evaluation Evaluate(string flagKey, ValueType resultType, object? defaultValue, IEvaluationContext? context) { if (_evaluator is null) { diff --git a/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs b/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs index f4198a83312d..52e8ecb3414b 100644 --- a/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs +++ b/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs @@ -34,13 +34,9 @@ public class DatadogProvider : global::OpenFeature.FeatureProvider /// Returns the evaluation result public override Task> ResolveBooleanValueAsync(string flagKey, bool defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { - return Task.Run( - () => - { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Boolean, defaultValue, GetContext(context)); - return GetResolutionDetails(res); - }, - cancellationToken); + cancellationToken.ThrowIfCancellationRequested(); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Boolean, defaultValue, GetContext(context)); + return Task.FromResult(GetResolutionDetails(res)); } /// Resolve flag as double @@ -51,13 +47,9 @@ public override Task> ResolveBooleanValueAsync(string fl /// Returns the evaluation result public override Task> ResolveDoubleValueAsync(string flagKey, double defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { - return Task.Run( - () => - { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Numeric, defaultValue, GetContext(context)); - return GetResolutionDetails(res); - }, - cancellationToken); + cancellationToken.ThrowIfCancellationRequested(); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Numeric, defaultValue, GetContext(context)); + return Task.FromResult(GetResolutionDetails(res)); } /// Resolve flag as integer @@ -68,13 +60,9 @@ public override Task> ResolveDoubleValueAsync(string f /// Returns the evaluation result public override Task> ResolveIntegerValueAsync(string flagKey, int defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { - return Task.Run( - () => - { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Integer, defaultValue, GetContext(context)); - return GetResolutionDetails(res); - }, - cancellationToken); + cancellationToken.ThrowIfCancellationRequested(); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Integer, defaultValue, GetContext(context)); + return Task.FromResult(GetResolutionDetails(res)); } /// Resolve flag as string @@ -85,13 +73,9 @@ public override Task> ResolveIntegerValueAsync(string fla /// Returns the evaluation result public override Task> ResolveStringValueAsync(string flagKey, string defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { - return Task.Run( - () => - { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.String, defaultValue, GetContext(context)); - return GetResolutionDetails(res); - }, - cancellationToken); + cancellationToken.ThrowIfCancellationRequested(); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.String, defaultValue, GetContext(context)); + return Task.FromResult(GetResolutionDetails(res)); } /// Resolve flag as Value @@ -102,35 +86,35 @@ public override Task> ResolveStringValueAsync(string f /// Returns the evaluation result public override Task> ResolveStructureValueAsync(string flagKey, Value defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { - return Task.Run( - () => - { - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Json, defaultValue, GetContext(context)); - return GetResolutionDetails(res); - }, - cancellationToken); + cancellationToken.ThrowIfCancellationRequested(); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Json, defaultValue, GetContext(context)); + return Task.FromResult(GetResolutionDetails(res)); } private static Datadog.Trace.FeatureFlags.IEvaluationContext? GetContext(EvaluationContext? context) { - if (context == null) { return new Datadog.Trace.FeatureFlags.EvaluationContext(string.Empty); } + if (context == null) + { + return null; + } + var values = context.AsDictionary().Select(p => new KeyValuePair(p.Key, ToObject(p.Value))).ToDictionary(p => p.Key, p => p.Value); - var res = new Datadog.Trace.FeatureFlags.EvaluationContext(context.TargetingKey!, values); + var res = new Datadog.Trace.FeatureFlags.EvaluationContext(context.TargetingKey ?? string.Empty, values); return res; } - private static object? ToObject(Value value) + private static object? ToObject(Value value) => value switch { - if (value == null) { return null; } - else if (value.IsBoolean) { return value.AsBoolean; } - else if (value.IsString) { return value.AsString; } - else if (value.IsNumber) { return value.AsDouble; } - else { return value.AsObject; } - } + null => null, + { IsBoolean: true } => value.AsBoolean, + { IsString: true } => value.AsString, + { IsNumber: true } => value.AsDouble, + _ => value.AsObject, + }; private static ResolutionDetails GetResolutionDetails(Datadog.Trace.FeatureFlags.IEvaluation? evaluation) { - if (evaluation == null) + if (evaluation is null) { return new ResolutionDetails( null, @@ -141,24 +125,37 @@ private static ResolutionDetails GetResolutionDetails(Datadog.Trace.Featur "FeatureFlagsSdk is disabled", null); } + var res = new ResolutionDetails( evaluation.FlagKey, - (T)(evaluation.Value ?? default(T)!), - ToErrorType(evaluation.Reason), + (T)(evaluation.Value!), + ToErrorType(evaluation.Reason, evaluation.Error), evaluation.Reason.ToString(), evaluation.Variant, evaluation.Error, - ToMetadata(evaluation.FlagMetadata!)); + ToMetadata(evaluation.FlagMetadata)); return res; } - private static ErrorType ToErrorType(Datadog.Trace.FeatureFlags.EvaluationReason reason) + private static ErrorType ToErrorType(Datadog.Trace.FeatureFlags.EvaluationReason reason, string? errorMessage) { - return ErrorType.None; // TODO: Map error types properly + return errorMessage switch + { + "FLAG_NOT_FOUND" => ErrorType.FlagNotFound, + "INVALID_CONTEXT" => ErrorType.InvalidContext, + "PARSE_ERROR" => ErrorType.ParseError, + "PROVIDER_FATAL" => ErrorType.ProviderFatal, + "PROVIDER_NOT_READY" => ErrorType.ProviderNotReady, + "TARGETING_KEY_MISSING" => ErrorType.TargetingKeyMissing, + "TYPE_MISMATCH" => ErrorType.TypeMismatch, + "GENERAL" => ErrorType.General, + _ => ErrorType.None, + }; } - private static ImmutableMetadata ToMetadata(IDictionary metadata) + private static ImmutableMetadata ToMetadata(IDictionary? metadata) { - return default!; // TODO: Map metadata properly + var dic = (metadata ?? new Dictionary()).ToDictionary(p => p.Key, p => (object)p.Value); + return new ImmutableMetadata(dic); } } From 6b880ef02e134de9a0c4af23b7b020f207c7073d Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Tue, 23 Dec 2025 12:35:26 +0100 Subject: [PATCH 39/54] MOAR PR comments --- .../FeatureFlags/FeatureFlagsEvaluator.cs | 35 +++++++++---------- .../FeatureFlags/FeatureFlagsModule.cs | 4 +-- .../FeatureFlagsEvaluatorTests.cs | 6 ++-- 3 files changed, 21 insertions(+), 24 deletions(-) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index 6a78101e78e4..1ae21e37a471 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -27,13 +27,11 @@ internal sealed class FeatureFlagsEvaluator private readonly ReportExposureDelegate? _onExposureEvent; private readonly ServerConfiguration? _config; - private readonly long _timeoutMs; - public FeatureFlagsEvaluator(ReportExposureDelegate? onExposureEvent, ServerConfiguration? config, long timeoutMs = 1000) + public FeatureFlagsEvaluator(ReportExposureDelegate? onExposureEvent, ServerConfiguration? config) { _onExposureEvent = onExposureEvent; _config = config; - _timeoutMs = timeoutMs; if (_config is null) { Log.Debug("Creating Evaluator without config"); @@ -156,7 +154,7 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default if (allShardsMatch) { - return ResolveVariant(flagKey, resultType, defaultValue, flag, split.VariationKey ?? string.Empty, allocation, context); + return ResolveVariant(flagKey, resultType, defaultValue, flag, split.VariationKey ?? string.Empty, allocation, now, context); } } } @@ -170,7 +168,6 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default } catch (FormatException ex) { - Log.Debug(ex, "Evaluation failed for key {Key}", flagKey); return new Evaluation( flagKey, defaultValue, @@ -178,12 +175,12 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default error: "PARSE_ERROR", metadata: new Dictionary { - ["errorCode"] = "PARSE_ERROR" + ["errorCode"] = "PARSE_ERROR", + ["message"] = ex.Message }); } catch (Exception ex) { - Log.Debug(ex, "Evaluation failed for key {Key}", flagKey); return new Evaluation( flagKey, defaultValue, @@ -548,7 +545,7 @@ private static double ParseDouble(object value) foreach (var key in keys) { var stack = new Stack(); - stack.Push(new FlattenEntry(key, context.GetAttribute(key))); + stack.Push(new FlattenEntry(key, context.GetAttribute(key), 1)); while (stack.Count > 0) { @@ -565,19 +562,23 @@ private static double ParseDouble(object value) { for (var i = 0; i < list.Count; i++) { - stack.Push(new FlattenEntry($"{entry.Key}[{i}]", list[i])); + stack.Push(new FlattenEntry($"{entry.Key}[{i}]", list[i], entry.Level + 1)); } } else if (value is IDictionary dict) { foreach (var pairKey in dict.Keys) { - stack.Push(new FlattenEntry($"{entry.Key}.{pairKey}", dict[pairKey!])); + stack.Push(new FlattenEntry($"{entry.Key}.{pairKey}", dict[pairKey!], entry.Level + 1)); } } else { - result[entry.Key] = value; + // Do not overwrite existing keys + if (!result.ContainsKey(entry.Key)) + { + result[entry.Key] = value; + } } } } @@ -594,6 +595,7 @@ private Evaluation ResolveVariant( Flag flag, string variationKey, Allocation allocation, + DateTime evalTime, IEvaluationContext? context) { if (flag.Variations is null || !flag.Variations.TryGetValue(variationKey, out var variant) || variant == null) @@ -629,7 +631,7 @@ private Evaluation ResolveVariant( var doLog = allocation.DoLog.HasValue && allocation.DoLog.Value; if (doLog) { - DispatchExposure(flagKey, evaluation, context); + DispatchExposure(flagKey, evaluation, evalTime, context); } return evaluation; @@ -638,6 +640,7 @@ private Evaluation ResolveVariant( private void DispatchExposure( string flagKey, Evaluation evaluation, + DateTime evalTime, IEvaluationContext? context) { var allocationKey = AllocationKey(evaluation); @@ -648,9 +651,8 @@ private void DispatchExposure( return; } - Log.Debug("FeatureFlagsEvaluator::DispatchExposure -> FlagKey: {FlagKey}", flagKey); var evt = new Exposure.Model.ExposureEvent( - DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(), + new DateTimeOffset(evalTime).ToUnixTimeMilliseconds(), new Exposure.Model.Allocation(allocationKey), new Exposure.Model.Flag(flagKey), new Exposure.Model.Variant(variantKey), @@ -659,11 +661,8 @@ private void DispatchExposure( _onExposureEvent?.Invoke(in evt); } - private sealed class FlattenEntry(string key, object? value) + private record struct FlattenEntry(string Key, object? Value, int Level) { - public string Key { get; } = key; - - public object? Value { get; } = value; } #pragma warning disable SA1201 // Elements should appear in the correct order diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index df1a2a7c74fb..f4e4dfbf79a6 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -43,8 +43,6 @@ internal FeatureFlagsModule(TracerSettings settings, IRcmSubscriptionManager? rc } } - public long Timeout { get; set; } = 1000; - public static FeatureFlagsModule? Create(TracerSettings settings, IRcmSubscriptionManager? rcmSubscriptionManager = null) { if (settings.IsFlaggingProviderEnabled) @@ -85,7 +83,7 @@ private void UpdateRemoteConfig(List> // Feed configs to the rules evaluator if (list.Count > 0) { - Interlocked.Exchange(ref _evaluator, new FeatureFlagsEvaluator(ReportExposure, list[0].Value, Timeout)); + Interlocked.Exchange(ref _evaluator, new FeatureFlagsEvaluator(ReportExposure, list[0].Value)); _onNewConfigEventHander?.Invoke(); } } diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs index 9b4e7c9370b4..92cf2605240e 100644 --- a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs @@ -108,7 +108,7 @@ public void MapValueTests(object? input, object? expected) [Fact] public void EvaluateWithoutConfigReturnsProviderNotReadyAndDefault() { - var evaluator = new FeatureFlagsEvaluator(null, null, 1000); + var evaluator = new FeatureFlagsEvaluator(null, null); var ctx = new EvaluationContext("target"); var result = evaluator.Evaluate("test", Trace.FeatureFlags.ValueType.Integer, 23, ctx); @@ -121,7 +121,7 @@ public void EvaluateWithoutConfigReturnsProviderNotReadyAndDefault() [Fact] public void EvaluateWithMissingTargetingKeyReturnsTargetingKeyMissing() { - var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration(), 1000); + var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration()); var ctx = new EvaluationContext(string.Empty); // no targetingKey var result = evaluator.Evaluate("flag", Trace.FeatureFlags.ValueType.String, "default", ctx); @@ -134,7 +134,7 @@ public void EvaluateWithMissingTargetingKeyReturnsTargetingKeyMissing() [Fact] public void EvaluateWithUnknownFlagReturnsFlagNotFound() { - var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration(), 1000); + var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration()); var ctx = new EvaluationContext("user-123"); var result = evaluator.Evaluate("unknown", Trace.FeatureFlags.ValueType.String, "default", ctx); From 45f6243f0603943b0e3423873f148d0fe0146c93 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Tue, 23 Dec 2025 12:50:31 +0100 Subject: [PATCH 40/54] Removed logical solution folder --- Datadog.Trace.sln | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/Datadog.Trace.sln b/Datadog.Trace.sln index 2d02a4b1e727..d1fd19cbe9bd 100644 --- a/Datadog.Trace.sln +++ b/Datadog.Trace.sln @@ -625,8 +625,6 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.Quartz", "tracer\te EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.AzureFunctions.V4Isolated.HostLogsDisabled", "tracer\test\test-applications\azure-functions\Samples.AzureFunctions.V4Isolated.HostLogsDisabled\Samples.AzureFunctions.V4Isolated.HostLogsDisabled.csproj", "{C770F9F8-0430-587D-EB7A-8BEC2FE9B61C}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "feature-flags", "feature-flags", "{D0C69381-F696-4113-BE7E-BA43468F431C}" -EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.FeatureFlags", "tracer\test\test-applications\integrations\Samples.FeatureFlags\Samples.FeatureFlags.csproj", "{D5A8ABB9-CB23-974E-F338-5D9172D96CD8}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Samples.OpenFeature", "tracer\test\test-applications\integrations\Samples.OpenFeature\Samples.OpenFeature.csproj", "{021D714E-1764-D76B-15B5-C9114FE934C2}" @@ -1779,9 +1777,8 @@ Global {59A9EDCD-6892-4817-8957-54DE84BDCAFB} = {BAF8F246-3645-42AD-B1D0-0F7EAFBAB34A} {CF69BC17-1527-425A-9B02-8E223BC31DB8} = {BAF8F246-3645-42AD-B1D0-0F7EAFBAB34A} {C770F9F8-0430-587D-EB7A-8BEC2FE9B61C} = {C4C1E313-C7C1-4490-AECE-0DD0062380A4} - {D0C69381-F696-4113-BE7E-BA43468F431C} = {9518425A-36A5-4B8F-B0B8-6137DB88441D} - {D5A8ABB9-CB23-974E-F338-5D9172D96CD8} = {D0C69381-F696-4113-BE7E-BA43468F431C} - {021D714E-1764-D76B-15B5-C9114FE934C2} = {D0C69381-F696-4113-BE7E-BA43468F431C} + {D5A8ABB9-CB23-974E-F338-5D9172D96CD8} = {BAF8F246-3645-42AD-B1D0-0F7EAFBAB34A} + {021D714E-1764-D76B-15B5-C9114FE934C2} = {BAF8F246-3645-42AD-B1D0-0F7EAFBAB34A} {32521F0A-D52D-4DB1-86C4-3D72DEDA6E55} = {9E5F0022-0A50-40BF-AC6A-C3078585ECAB} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution @@ -1817,7 +1814,6 @@ Global tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{2f3b6271-b9a3-48a3-9db6-847f3ef41f0a}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{303f8e41-691f-4453-ab7d-88a0036c0465}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{31d192af-5454-4d91-97e1-889723aad309}*SharedItemsImports = 5 - tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{32193a01-04dd-463b-a84a-9a93167958a4}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{3493346b-44f6-4f50-8fb4-51d0090df544}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{34b67004-7249-4ef1-8e12-6e6da37ea6be}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{3538ef5e-377e-430a-afb8-f2db5faede95}*SharedItemsImports = 5 @@ -1838,7 +1834,6 @@ Global tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{536f1d82-d40c-4e33-b7fa-76a0f17bf672}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{560e1104-9a6e-41e7-ab3d-85ba2740a0f7}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{56de0d44-e9e5-48da-baea-2934b1e28d4e}*SharedItemsImports = 5 - tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{59a9edcd-6892-4817-8957-54de84bdcafb}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{5a806f4b-39e7-4f38-b36f-f5cfc4f8760a}*SharedItemsImports = 13 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{5c2829c2-ed0d-414c-b5a0-2bfdca07b493}*SharedItemsImports = 5 tracer\test\test-applications\Samples.Shared\Samples.Shared.projitems*{5d2c6b9c-fce2-4e46-b4ed-bc3b11cfbb3c}*SharedItemsImports = 5 From 9e4ddee730fc4f6c149993c998328a51dbca8fd0 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Wed, 24 Dec 2025 10:31:13 +0100 Subject: [PATCH 41/54] PR comments --- Datadog.Trace.Samples.g.sln | 9 +- .../PackageVersionsGeneratorDefinitions.json | 3 +- .../FeatureFlags/FeatureFlagsSdk.cs | 6 +- ...isterOnNewConfigEventHandlerIntegration.cs | 9 +- .../ClrProfiler/Instrumentation.cs | 5 - .../FeatureFlags/Exposure/ExposureApi.cs | 105 +++++++++--------- .../FeatureFlags/Exposure/Model/Allocation.cs | 2 +- .../Exposure/Model/ExposureEvent.cs | 2 +- .../FeatureFlags/Exposure/Model/Flag.cs | 2 +- .../FeatureFlags/Exposure/Model/Subject.cs | 2 +- .../FeatureFlags/Exposure/Model/Variant.cs | 2 +- .../FeatureFlags/FeatureFlagsEvaluator.cs | 18 ++- .../FeatureFlags/FeatureFlagsModule.cs | 33 +++--- .../FeatureFlags/Rcm/FfeProduct.cs | 10 +- .../src/Datadog.Trace/TracerManagerFactory.cs | 2 +- .../FeatureFlagsEvaluatorTests.cs | 3 +- .../Samples.OpenFeature.csproj | 2 +- 17 files changed, 103 insertions(+), 112 deletions(-) diff --git a/Datadog.Trace.Samples.g.sln b/Datadog.Trace.Samples.g.sln index ee202f71d615..117de35c9664 100644 --- a/Datadog.Trace.Samples.g.sln +++ b/Datadog.Trace.Samples.g.sln @@ -129,10 +129,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Generated", "Generated", "{ tracer\build\supported_calltargets.g.json = tracer\build\supported_calltargets.g.json EndProjectSection EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "feature-flags", "feature-flags", "{D0C69381-F696-4113-BE7E-BA43468F431C}" - ProjectSection(SolutionItems) = preProject - EndProjectSection -EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Samples.ExampleLibrary", "tracer\test\test-applications\integrations\dependency-libs\Samples.ExampleLibrary\Samples.ExampleLibrary.csproj", "{FDB5C8D0-018D-4FF9-9680-C6A5078F819B}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Samples.ExampleLibraryTracer", "tracer\test\test-applications\integrations\dependency-libs\Samples.ExampleLibraryTracer\Samples.ExampleLibraryTracer.csproj", "{4B243CF1-4269-45C6-A238-1A9BFA58B8CC}" @@ -1117,7 +1113,6 @@ Global {16427BFB-B4C6-46A9-A290-8EA51FF73FEA} = {9518425A-36A5-4B8F-B0B8-6137DB88441D} {0884B566-D22E-498C-BAA9-26D50ABCAE3A} = {16427BFB-B4C6-46A9-A290-8EA51FF73FEA} {E1B0F72C-991A-409D-9266-DE5ED1BD940E} = {A0C5FBBB-CFB2-4FB9-B8F0-55676E9DCF06} - {D0C69381-F696-4113-BE7E-BA43468F431C} = {9518425A-36A5-4B8F-B0B8-6137DB88441D} {FDB5C8D0-018D-4FF9-9680-C6A5078F819B} = {8683D82A-2BBE-4199-9C36-C59F48804F90} {4B243CF1-4269-45C6-A238-1A9BFA58B8CC} = {8683D82A-2BBE-4199-9C36-C59F48804F90} {086FF8A0-9CEE-470A-9751-78B0F1340649} = {BAF8F246-3645-42AD-B1D0-0F7EAFBAB34A} @@ -1277,7 +1272,7 @@ Global {59A9EDCD-6892-4817-8957-54DE84BDCAFB} = {BAF8F246-3645-42AD-B1D0-0F7EAFBAB34A} {CF69BC17-1527-425A-9B02-8E223BC31DB8} = {BAF8F246-3645-42AD-B1D0-0F7EAFBAB34A} {C770F9F8-0430-587D-EB7A-8BEC2FE9B61C} = {C4C1E313-C7C1-4490-AECE-0DD0062380A4} - {D5A8ABB9-CB23-974E-F338-5D9172D96CD8} = {D0C69381-F696-4113-BE7E-BA43468F431C} - {021D714E-1764-D76B-15B5-C9114FE934C2} = {D0C69381-F696-4113-BE7E-BA43468F431C} + {D5A8ABB9-CB23-974E-F338-5D9172D96CD8} = {BAF8F246-3645-42AD-B1D0-0F7EAFBAB34A} + {021D714E-1764-D76B-15B5-C9114FE934C2} = {BAF8F246-3645-42AD-B1D0-0F7EAFBAB34A} EndGlobalSection EndGlobal diff --git a/tracer/build/PackageVersionsGeneratorDefinitions.json b/tracer/build/PackageVersionsGeneratorDefinitions.json index 48defb175130..d1e1b289b06d 100644 --- a/tracer/build/PackageVersionsGeneratorDefinitions.json +++ b/tracer/build/PackageVersionsGeneratorDefinitions.json @@ -968,10 +968,9 @@ "IntegrationName": "OpenFeature", "SampleProjectName": "Samples.OpenFeature", "NugetPackageSearchName": "OpenFeature", - "MinVersion": "1.0.0", + "MinVersion": "2.0.0", "MaxVersionExclusive": "3.0.0", "SpecificVersions": [ - "1.0.*", "2.0.*", "2.10.*" ] diff --git a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs index e1719de30e65..05879efa9302 100644 --- a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs +++ b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs @@ -32,16 +32,16 @@ public static void RegisterOnNewConfigEventHandler(Action onNewConfig) } /// - /// Sets the details of a successful login on the local root span + /// Returns the evaluation of the requested flag key /// /// Returns the evaluation result - /// The feature flag key to evaluate + /// The feature flag key to evaluate /// The desired result type /// The default value /// The evaluation context [Instrumented] [MethodImpl(MethodImplOptions.NoInlining)] - public static IEvaluation? Evaluate(string key, ValueType targetType, object? defaultValue, IEvaluationContext? context) + public static IEvaluation? Evaluate(string flagKey, ValueType targetType, object? defaultValue, IEvaluationContext? context) { return null; } diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs index a89f728281bb..15d0c16348d9 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs @@ -37,12 +37,15 @@ internal static CallTargetState OnMethodBegin(ref Action? onNewConfig) internal static CallTargetReturn OnMethodEnd(Exception? exception, in CallTargetState state) { - if (state.State is not Action onNewConfig) + if (state.State is Action onNewConfig) { - throw new ArgumentNullException(); + TracerManager.Instance.FeatureFlags?.RegisterOnNewConfigEventHandler(onNewConfig); + } + else + { + exception = new ArgumentException(); } - TracerManager.Instance.FeatureFlags?.RegisterOnNewConfigEventHandler(onNewConfig); return CallTargetReturn.GetDefault(); } } diff --git a/tracer/src/Datadog.Trace/ClrProfiler/Instrumentation.cs b/tracer/src/Datadog.Trace/ClrProfiler/Instrumentation.cs index 6a8e383f1dbe..b564f9d19781 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/Instrumentation.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/Instrumentation.cs @@ -16,14 +16,9 @@ using Datadog.Trace.Configuration; using Datadog.Trace.ContinuousProfiler; using Datadog.Trace.Debugger; -using Datadog.Trace.Debugger.ExceptionAutoInstrumentation; using Datadog.Trace.Debugger.Helpers; using Datadog.Trace.DiagnosticListeners; -using Datadog.Trace.FeatureFlags; -using Datadog.Trace.Iast.Dataflow; using Datadog.Trace.Logging; -using Datadog.Trace.Processors; -using Datadog.Trace.RemoteConfigurationManagement; using Datadog.Trace.ServiceFabric; using Datadog.Trace.Telemetry; using Datadog.Trace.Telemetry.Metrics; diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs index 99d540ef05a6..60b28cd142f8 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs @@ -16,6 +16,8 @@ using Datadog.Trace.FeatureFlags.Exposure.Model; using Datadog.Trace.HttpOverStreams; using Datadog.Trace.Logging; +using Datadog.Trace.VendoredMicrosoftCode.System.Diagnostics.CodeAnalysis; +using Datadog.Trace.Vendors.dnlib; using Datadog.Trace.Vendors.Newtonsoft.Json; namespace Datadog.Trace.Exposure @@ -24,55 +26,69 @@ internal sealed class ExposureApi : IDisposable { internal static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(ExposureApi)); - public const string ExposurePath = "api/v2/exposure"; + public const string ExposurePath = "evp_proxy/v2/api/v2/exposure"; private readonly TaskCompletionSource _processExit = new(); private readonly TimeSpan _sendInterval = TimeSpan.FromSeconds(10); private readonly Queue _exposures = new Queue(); - private IApiRequestFactory? _apiRequestFactory = null; - private Dictionary _context = new Dictionary(); + + private IApiRequestFactory? _apiRequestFactory; + private Dictionary? _context; private int _started = 0; - private ExposureApi(TracerSettings tracerSettings) + internal ExposureApi(TracerSettings tracerSettings) { - UpdateSettings(tracerSettings.Manager.InitialExporterSettings, tracerSettings.Manager.InitialMutableSettings); - tracerSettings.Manager.SubscribeToChanges(settingChanges => UpdateSettings(settingChanges.UpdatedExporter ?? settingChanges.PreviousExporter, settingChanges.UpdatedMutable ?? settingChanges.PreviousMutable)); - } + UpdateApi(tracerSettings.Manager.InitialExporterSettings); + UpdateContext(tracerSettings.Manager.InitialMutableSettings); - private void UpdateSettings(ExporterSettings exporterSettings, MutableSettings settings) - { - Log.Debug("ExposureApi::UpdateSettings -> Applyting settings"); - var apiRequestFactory = AgentTransportStrategy.Get( - exporterSettings, - productName: "FeatureFlags exposure", - tcpTimeout: TimeSpan.FromSeconds(5), - AgentHttpHeaderNames.MinimalHeaders, - () => new MinimalAgentHeaderHelper(), - uri => uri); - Interlocked.Exchange(ref _apiRequestFactory, apiRequestFactory); - - var context = new Dictionary + tracerSettings.Manager.SubscribeToChanges(changes => { - { "service", settings.ServiceName ?? "unknown" }, - { "env", settings.Environment ?? "unknown" }, - { "version", settings.ServiceVersion ?? "unknown" } - }; - Interlocked.Exchange(ref _context, context); - } + if (changes.UpdatedExporter is { } exporter) + { + UpdateApi(exporter); + } - public static ExposureApi Create(TracerSettings tracerSettings) - { - return new ExposureApi(tracerSettings); + if (changes.UpdatedMutable is { } mutable) + { + UpdateContext(mutable); + } + }); + + [MemberNotNull(nameof(_apiRequestFactory))] + void UpdateApi(ExporterSettings exporterSettings) + { + Log.Debug("ExposureApi::UpdateApi-> Applying settings"); + var apiRequestFactory = AgentTransportStrategy.Get( + exporterSettings, + productName: "FeatureFlags exposure", + tcpTimeout: TimeSpan.FromSeconds(5), + AgentHttpHeaderNames.MinimalHeaders, + () => new MinimalAgentHeaderHelper(), + uri => uri); + Interlocked.Exchange(ref _apiRequestFactory, apiRequestFactory); + } + + [MemberNotNull(nameof(_context))] + void UpdateContext(MutableSettings settings) + { + Log.Debug("ExposureApi::UpdateContext -> Applying settings"); + var context = new Dictionary + { + { "service", settings.DefaultServiceName }, + { "env", settings.Environment ?? "unknown" }, + { "version", settings.ServiceVersion ?? "unknown" } + }; + Interlocked.Exchange(ref _context, context); + } } public void Dispose() { - try { _processExit.TrySetResult(true); } - catch { } + _processExit.TrySetResult(true); } public void TryToStartSendLoopIfNotStarted() { - if (_started != 0 || Interlocked.Exchange(ref _started, 1) != 0) + if (Interlocked.CompareExchange(ref _started, 1, 0) != 0) { return; } @@ -90,10 +106,12 @@ private async Task SendLoopAsync() var apiRequestFactory = _apiRequestFactory; if (apiRequestFactory is not null) { - var uri = apiRequestFactory.GetEndpoint($"evp_proxy/v2/{ExposurePath}"); + var uri = apiRequestFactory.GetEndpoint(ExposurePath); if (_exposures.Count > 0) { - await SendBatchAsync(apiRequestFactory, uri).ConfigureAwait(false); + var request = apiRequestFactory.Create(uri); + var payload = GetPayload(); + using var response = await request.PostAsync(payload, MimeTypes.Json).ConfigureAwait(false); } } } @@ -115,29 +133,14 @@ private async Task SendLoopAsync() } } - private async Task SendBatchAsync(IApiRequestFactory apiRequestFactory, Uri uri) - { - try - { - var request = apiRequestFactory.Create(uri); - var payload = GetPayload(); - using var response = await request.PostAsync(payload, MimeTypes.Json) - .ConfigureAwait(false); - } - catch (Exception ex) - { - Log.Error(ex, "Error in Feature Flags exposures reporting loop"); - } - } - private ArraySegment GetPayload() { ExposuresRequest request; lock (_exposures) { - var exposures = _exposures.ToList(); + List exposures = [.. _exposures]; _exposures.Clear(); - request = new ExposuresRequest(_context, exposures); + request = new ExposuresRequest(_context!, exposures); } string json = JsonConvert.SerializeObject(request); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Allocation.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Allocation.cs index 1a9d504f7294..a5120acede8d 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Allocation.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Allocation.cs @@ -11,4 +11,4 @@ namespace Datadog.Trace.FeatureFlags.Exposure.Model; -internal sealed record Allocation(string Key); +internal readonly record struct Allocation(string Key); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/ExposureEvent.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/ExposureEvent.cs index c3665ab00cfe..24ab9f44659d 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/ExposureEvent.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/ExposureEvent.cs @@ -11,4 +11,4 @@ namespace Datadog.Trace.FeatureFlags.Exposure.Model; -internal sealed record ExposureEvent(long TimeStamp, Allocation Allocation, Flag Flag, Variant Variant, Subject Subject); +internal readonly record struct ExposureEvent(long TimeStamp, Allocation Allocation, Flag Flag, Variant Variant, Subject Subject); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Flag.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Flag.cs index 4e65edd22b5c..4d46172896e7 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Flag.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Flag.cs @@ -11,4 +11,4 @@ namespace Datadog.Trace.FeatureFlags.Exposure.Model; -internal sealed record Flag(string Key); +internal readonly record struct Flag(string Key); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Subject.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Subject.cs index 51ece8f246a8..6733f9bf2e1b 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Subject.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Subject.cs @@ -11,4 +11,4 @@ namespace Datadog.Trace.FeatureFlags.Exposure.Model; -internal sealed record Subject(string Id, IDictionary Attributes); +internal readonly record struct Subject(string Id, IDictionary Attributes); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Variant.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Variant.cs index 338b800e6e5a..d6bfa27aa31f 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Variant.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/Model/Variant.cs @@ -11,4 +11,4 @@ namespace Datadog.Trace.FeatureFlags.Exposure.Model; -internal sealed record Variant(string Key); +internal readonly record struct Variant(string Key); diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index 1ae21e37a471..59bbd241338a 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -62,7 +62,7 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default }); } - if (string.IsNullOrEmpty(context?.TargetingKey)) + if (StringUtil.IsNullOrEmpty(context?.TargetingKey)) { return new Evaluation( flagKey, @@ -109,7 +109,7 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default }); } - if (flag.Allocations is { Count: 0 }) + if (flag.Allocations is null or { Count: 0 }) { return new Evaluation( flagKey, @@ -120,16 +120,16 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default var now = DateTime.UtcNow; var targetingKey = context?.TargetingKey ?? string.Empty; - foreach (var allocation in flag.Allocations!) + foreach (var allocation in flag.Allocations) { if (!IsAllocationActive(allocation, now)) { continue; } - if (allocation.Rules is { Count: > 0 }) + if (allocation.Rules is { Count: > 0 } allocationRules) { - if (!EvaluateRules(allocation.Rules!, context)) + if (!EvaluateRules(allocationRules, context)) { continue; } @@ -140,9 +140,9 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default foreach (var split in allocation.Splits) { var allShardsMatch = true; - if (split.Shards is { Count: > 0 }) + if (split.Shards is { Count: > 0 } splitShards) { - foreach (var shard in split.Shards!) + foreach (var shard in splitShards) { if (!MatchesShard(shard, targetingKey)) { @@ -194,8 +194,6 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default } } - // --------- helpers ---------- - private static bool IsAllocationActive(Allocation allocation, DateTime now) { var startDate = ParseDate(allocation.StartAt); @@ -213,7 +211,7 @@ private static bool IsAllocationActive(Allocation allocation, DateTime now) return true; } - private static bool EvaluateRules(IEnumerable rules, IEvaluationContext? context) + private static bool EvaluateRules(List rules, IEvaluationContext? context) { foreach (var rule in rules) { diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index f4e4dfbf79a6..a87a6a96f1be 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -23,31 +23,29 @@ internal sealed class FeatureFlagsModule : IDisposable internal static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(FeatureFlagsModule)); private readonly IRcmSubscriptionManager _rcmSubscriptionManager; - private ISubscription? _rcmSubscription = null; - private FfeProduct? _ffeProduct = null; - private Action? _onNewConfigEventHander = null; - private ExposureApi? _exposureApi = null; + private readonly ISubscription _rcmSubscription; + private readonly FfeProduct _ffeProduct; + private readonly ExposureApi _exposureApi; + private Action? _onNewConfigEventHander = null; private FeatureFlagsEvaluator? _evaluator = null; - internal FeatureFlagsModule(TracerSettings settings, IRcmSubscriptionManager? rcmSubscriptionManager = null) + internal FeatureFlagsModule(TracerSettings settings, IRcmSubscriptionManager rcmSubscriptionManager) { Log.Debug("FeatureFlagsModule ENABLED"); - _rcmSubscriptionManager = rcmSubscriptionManager ?? RcmSubscriptionManager.Instance; - _exposureApi = ExposureApi.Create(settings); + _rcmSubscriptionManager = rcmSubscriptionManager; + _exposureApi = new ExposureApi(settings); _ffeProduct = new FfeProduct(UpdateRemoteConfig); - if (Interlocked.Exchange(ref _rcmSubscription, new Subscription(_ffeProduct.UpdateFromRcm, RcmProducts.FfeFlags)) == null) - { - _rcmSubscriptionManager.SubscribeToChanges(_rcmSubscription!); - _rcmSubscriptionManager.SetCapability(RcmCapabilitiesIndices.FfeFlagConfigurationRules, true); - } + _rcmSubscription = new Subscription(_ffeProduct.UpdateFromRcm, RcmProducts.FfeFlags); + _rcmSubscriptionManager.SubscribeToChanges(_rcmSubscription!); + _rcmSubscriptionManager.SetCapability(RcmCapabilitiesIndices.FfeFlagConfigurationRules, true); } - public static FeatureFlagsModule? Create(TracerSettings settings, IRcmSubscriptionManager? rcmSubscriptionManager = null) + public static FeatureFlagsModule? Create(TracerSettings settings, IRcmSubscriptionManager rcmSubscriptionManager) { if (settings.IsFlaggingProviderEnabled) { - return new FeatureFlagsModule(settings, rcmSubscriptionManager ?? RcmSubscriptionManager.Instance); + return new FeatureFlagsModule(settings, rcmSubscriptionManager); } return null; @@ -55,7 +53,7 @@ internal FeatureFlagsModule(TracerSettings settings, IRcmSubscriptionManager? rc public void Dispose() { - _exposureApi?.Dispose(); + _exposureApi.Dispose(); } internal void RegisterOnNewConfigEventHandler(Action? onNewConfig) @@ -65,14 +63,15 @@ internal void RegisterOnNewConfigEventHandler(Action? onNewConfig) internal Evaluation Evaluate(string flagKey, ValueType resultType, object? defaultValue, IEvaluationContext? context) { - if (_evaluator is null) + var evaluator = Volatile.Read(ref _evaluator); + if (evaluator is null) { Log.Debug("FeatureFlagsModule::Evaluate -> Evaluator is null (no config received)"); return new Evaluation(flagKey, null, EvaluationReason.Error, null, "No config loaded"); } Log.Debug("FeatureFlagsModule::Evaluate -> Returning Evaluation"); - return _evaluator.Evaluate(flagKey, resultType, defaultValue, context); + return evaluator.Evaluate(flagKey, resultType, defaultValue, context); } private void UpdateRemoteConfig(List> list) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs index ef2056b5daea..58b1317341af 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs @@ -57,17 +57,17 @@ public ApplyDetails[] UpdateFromRcm(Dictionary } } } + + if (apply) + { + _onNewConfig?.Invoke(_serverConfigurations); + } } catch (Exception ex) { Log.Error(ex, "Error while updating FFE RCM config"); } - if (apply) - { - _onNewConfig?.Invoke(_serverConfigurations); - } - return [.. res]; } } diff --git a/tracer/src/Datadog.Trace/TracerManagerFactory.cs b/tracer/src/Datadog.Trace/TracerManagerFactory.cs index afd8f998e636..829d56b42c62 100644 --- a/tracer/src/Datadog.Trace/TracerManagerFactory.cs +++ b/tracer/src/Datadog.Trace/TracerManagerFactory.cs @@ -189,7 +189,7 @@ internal TracerManager CreateTracerManager( } } - featureFlags = FeatureFlagsModule.Create(settings); + featureFlags = FeatureFlagsModule.Create(settings, RcmSubscriptionManager.Instance); return CreateTracerManagerFrom( settings, diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs index 92cf2605240e..181af1a688d0 100644 --- a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs @@ -195,8 +195,7 @@ public void EvaluateFlagWithoutAllocationsReturnsDefaultValue() var result1 = evaluator.Evaluate("null-allocation", Trace.FeatureFlags.ValueType.String, 23, ctx); Assert.Equal(23, result1.Value); - Assert.Equal(EvaluationReason.Error, result1.Reason); - Assert.Equal("GENERAL", result1.FlagMetadata?["errorCode"]); + Assert.Equal(EvaluationReason.Default, result1.Reason); var result2 = evaluator.Evaluate("empty-allocation", Trace.FeatureFlags.ValueType.String, 23, ctx); Assert.Equal(23, result2.Value); diff --git a/tracer/test/test-applications/integrations/Samples.OpenFeature/Samples.OpenFeature.csproj b/tracer/test/test-applications/integrations/Samples.OpenFeature/Samples.OpenFeature.csproj index bae090bacbd4..3093080a4a33 100644 --- a/tracer/test/test-applications/integrations/Samples.OpenFeature/Samples.OpenFeature.csproj +++ b/tracer/test/test-applications/integrations/Samples.OpenFeature/Samples.OpenFeature.csproj @@ -5,7 +5,7 @@ false false enable - 2.9.0 + 2.0.0 From 350d882f36f7a8b4c4f6847f5f340f791088e78e Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Wed, 24 Dec 2025 11:15:52 +0100 Subject: [PATCH 42/54] Removed EvaluationContext implementation from public api --- .../Datadog.Trace.Manual.csproj | 1 - .../FeatureFlags/EvaluationContext.cs | 2 +- .../Samples.FeatureFlags/Evaluator.cs | 12 ++++++++++++ .../Samples.OpenFeature/DatadogProvider.cs | 16 ++++++++++++++-- 4 files changed, 27 insertions(+), 4 deletions(-) diff --git a/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj b/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj index 25ffc0fb8293..8934c3560fc0 100644 --- a/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj +++ b/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj @@ -28,7 +28,6 @@ - diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs index 8d4a13d88ce9..b502338a30f3 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs @@ -16,7 +16,7 @@ namespace Datadog.Trace.FeatureFlags /// Context optional parameters [EditorBrowsable(EditorBrowsableState.Never)] [Browsable(false)] - public sealed class EvaluationContext(string key, IDictionary? values = null) + internal sealed class EvaluationContext(string key, IDictionary? values = null) : IEvaluationContext { /// Gets the Context Targeting Key diff --git a/tracer/test/test-applications/integrations/Samples.FeatureFlags/Evaluator.cs b/tracer/test/test-applications/integrations/Samples.FeatureFlags/Evaluator.cs index 672861cd1116..6fadd7b6aff3 100644 --- a/tracer/test/test-applications/integrations/Samples.FeatureFlags/Evaluator.cs +++ b/tracer/test/test-applications/integrations/Samples.FeatureFlags/Evaluator.cs @@ -1,4 +1,5 @@ using System; +using System.Collections.Generic; using System.Diagnostics; using System.Threading; using Datadog.Trace.FeatureFlags; @@ -33,4 +34,15 @@ public static (string? Value, string? Error)? Evaluate(string key) return (evaluation.Value as string, evaluation.Error); } + + class EvaluationContext(string key, IDictionary? values = null) + : IEvaluationContext + { + public string TargetingKey { get; } = key; + + public IDictionary Attributes { get; } = values ?? new Dictionary(); + + public object? GetAttribute(string key) + => Attributes.TryGetValue(key, out var res) ? res : null; + } } diff --git a/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs b/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs index 52e8ecb3414b..6b92749c367b 100644 --- a/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs +++ b/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs @@ -10,6 +10,7 @@ using System.Linq; using System.Threading; using System.Threading.Tasks; +using Datadog.Trace.FeatureFlags; using OpenFeature.Constant; using OpenFeature.Model; @@ -91,7 +92,7 @@ public override Task> ResolveStructureValueAsync(string return Task.FromResult(GetResolutionDetails(res)); } - private static Datadog.Trace.FeatureFlags.IEvaluationContext? GetContext(EvaluationContext? context) + private static IEvaluationContext? GetContext(EvaluationContext? context) { if (context == null) { @@ -99,7 +100,7 @@ public override Task> ResolveStructureValueAsync(string } var values = context.AsDictionary().Select(p => new KeyValuePair(p.Key, ToObject(p.Value))).ToDictionary(p => p.Key, p => p.Value); - var res = new Datadog.Trace.FeatureFlags.EvaluationContext(context.TargetingKey ?? string.Empty, values); + var res = new Context(context.TargetingKey ?? string.Empty, values); return res; } @@ -158,4 +159,15 @@ private static ImmutableMetadata ToMetadata(IDictionary? metadat var dic = (metadata ?? new Dictionary()).ToDictionary(p => p.Key, p => (object)p.Value); return new ImmutableMetadata(dic); } + + class Context(string key, IDictionary? values = null) + : IEvaluationContext + { + public string TargetingKey { get; } = key; + + public IDictionary Attributes { get; } = values ?? new Dictionary(); + + public object? GetAttribute(string key) + => Attributes.TryGetValue(key, out var res) ? res : null; + } } From 498d7bc59376a0995ba2d53f3edc686199961f31 Mon Sep 17 00:00:00 2001 From: Andrew Lock Date: Wed, 24 Dec 2025 11:16:40 +0000 Subject: [PATCH 43/54] Fix attribute import and nullability --- .../FeatureFlags/Exposure/ExposureApi.cs | 23 ++++++++----------- 1 file changed, 10 insertions(+), 13 deletions(-) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs index 60b28cd142f8..a6caec2c7ca0 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs @@ -6,6 +6,7 @@ using System; using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; using System.Linq; using System.Text; using System.Threading; @@ -16,7 +17,6 @@ using Datadog.Trace.FeatureFlags.Exposure.Model; using Datadog.Trace.HttpOverStreams; using Datadog.Trace.Logging; -using Datadog.Trace.VendoredMicrosoftCode.System.Diagnostics.CodeAnalysis; using Datadog.Trace.Vendors.dnlib; using Datadog.Trace.Vendors.Newtonsoft.Json; @@ -31,8 +31,8 @@ internal sealed class ExposureApi : IDisposable private readonly TimeSpan _sendInterval = TimeSpan.FromSeconds(10); private readonly Queue _exposures = new Queue(); - private IApiRequestFactory? _apiRequestFactory; - private Dictionary? _context; + private IApiRequestFactory _apiRequestFactory; + private Dictionary _context; private int _started = 0; internal ExposureApi(TracerSettings tracerSettings) @@ -64,7 +64,7 @@ void UpdateApi(ExporterSettings exporterSettings) AgentHttpHeaderNames.MinimalHeaders, () => new MinimalAgentHeaderHelper(), uri => uri); - Interlocked.Exchange(ref _apiRequestFactory, apiRequestFactory); + Interlocked.Exchange(ref _apiRequestFactory!, apiRequestFactory); } [MemberNotNull(nameof(_context))] @@ -77,7 +77,7 @@ void UpdateContext(MutableSettings settings) { "env", settings.Environment ?? "unknown" }, { "version", settings.ServiceVersion ?? "unknown" } }; - Interlocked.Exchange(ref _context, context); + Interlocked.Exchange(ref _context!, context); } } @@ -104,15 +104,12 @@ private async Task SendLoopAsync() try { var apiRequestFactory = _apiRequestFactory; - if (apiRequestFactory is not null) + var uri = apiRequestFactory.GetEndpoint(ExposurePath); + if (_exposures.Count > 0) { - var uri = apiRequestFactory.GetEndpoint(ExposurePath); - if (_exposures.Count > 0) - { - var request = apiRequestFactory.Create(uri); - var payload = GetPayload(); - using var response = await request.PostAsync(payload, MimeTypes.Json).ConfigureAwait(false); - } + var request = apiRequestFactory.Create(uri); + var payload = GetPayload(); + using var response = await request.PostAsync(payload, MimeTypes.Json).ConfigureAwait(false); } } catch (Exception ex) From 45d2d797b3209b96cfa8f416da8ed19fff99094f Mon Sep 17 00:00:00 2001 From: Andrew Lock Date: Wed, 24 Dec 2025 11:23:14 +0000 Subject: [PATCH 44/54] Ensure we don't access _exposures outside of the lock + reuce length of locking --- .../FeatureFlags/Exposure/ExposureApi.cs | 23 ++++++++++++------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs index a6caec2c7ca0..f5ddbefda21e 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs @@ -105,10 +105,10 @@ private async Task SendLoopAsync() { var apiRequestFactory = _apiRequestFactory; var uri = apiRequestFactory.GetEndpoint(ExposurePath); - if (_exposures.Count > 0) + var payload = TryGetPayload(); + if (payload.Count != 0) { var request = apiRequestFactory.Create(uri); - var payload = GetPayload(); using var response = await request.PostAsync(payload, MimeTypes.Json).ConfigureAwait(false); } } @@ -130,17 +130,23 @@ private async Task SendLoopAsync() } } - private ArraySegment GetPayload() + private ArraySegment TryGetPayload() { - ExposuresRequest request; + List exposures; lock (_exposures) { - List exposures = [.. _exposures]; + if (_exposures.Count == 0) + { + // nothing to do, skip send + return default; + } + + exposures = [.. _exposures]; _exposures.Clear(); - request = new ExposuresRequest(_context!, exposures); } - string json = JsonConvert.SerializeObject(request); + var request = new ExposuresRequest(_context, exposures); + var json = JsonConvert.SerializeObject(request); return new ArraySegment(Encoding.UTF8.GetBytes(json)); } @@ -149,8 +155,9 @@ public void SendExposure(in ExposureEvent exposure) lock (_exposures) { _exposures.Enqueue(exposure); - TryToStartSendLoopIfNotStarted(); } + + TryToStartSendLoopIfNotStarted(); } private sealed class ExposuresRequest(Dictionary context, List exposures) From 51f8c67f232b6a9be291e7840915456e664407cd Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Wed, 24 Dec 2025 12:44:40 +0100 Subject: [PATCH 45/54] Removed IEvaluationContext from public API --- tracer/build/supported_calltargets.g.json | 3 +- .../Datadog.Trace.Manual.csproj | 1 - .../FeatureFlags/FeatureFlagsSdk.cs | 5 ++-- .../FeatureFlagsSdkEvaluateIntegration.cs | 11 ++++---- .../FeatureFlags/EvaluationContext.cs | 3 -- .../FeatureFlags/Exposure/ExposureApi.cs | 2 -- .../FeatureFlags/FeatureFlagsEvaluator.cs | 14 +++++----- .../FeatureFlags/FeatureFlagsModule.cs | 4 +-- .../FeatureFlags/IEvaluationContext.cs | 28 ------------------- .../Generated/generated_calltargets.g.cpp | 4 +-- .../Samples.FeatureFlags/Evaluator.cs | 14 +--------- .../Samples.OpenFeature/DatadogProvider.cs | 27 +++++------------- 12 files changed, 30 insertions(+), 86 deletions(-) delete mode 100644 tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs diff --git a/tracer/build/supported_calltargets.g.json b/tracer/build/supported_calltargets.g.json index d816d86cf9c4..763a2ba232e8 100644 --- a/tracer/build/supported_calltargets.g.json +++ b/tracer/build/supported_calltargets.g.json @@ -6692,7 +6692,8 @@ "System.String", "Datadog.Trace.FeatureFlags.ValueType", "System.Object", - "Datadog.Trace.FeatureFlags.IEvaluationContext" + "System.String", + "System.Collections.Generic.IDictionary`2[System.String,System.Object]" ], "MinimumVersion": { "Item1": 3, diff --git a/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj b/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj index 8934c3560fc0..3334b2103e94 100644 --- a/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj +++ b/tracer/src/Datadog.Trace.Manual/Datadog.Trace.Manual.csproj @@ -31,7 +31,6 @@ - diff --git a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs index 05879efa9302..3414e6518074 100644 --- a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs +++ b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs @@ -38,10 +38,11 @@ public static void RegisterOnNewConfigEventHandler(Action onNewConfig) /// The feature flag key to evaluate /// The desired result type /// The default value - /// The evaluation context + /// The context targetting key + /// The context attributes [Instrumented] [MethodImpl(MethodImplOptions.NoInlining)] - public static IEvaluation? Evaluate(string flagKey, ValueType targetType, object? defaultValue, IEvaluationContext? context) + public static IEvaluation? Evaluate(string flagKey, ValueType targetType, object? defaultValue, string? targetingKey, IDictionary? attributes) { return null; } diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs index 63bb8d462f6b..7befff9504b0 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs @@ -5,6 +5,7 @@ #nullable enable using System; +using System.Collections.Generic; using System.ComponentModel; using System.IO; using System.Threading; @@ -23,7 +24,7 @@ namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual; TypeName = "Datadog.Trace.FeatureFlags.FeatureFlagsSdk", MethodName = "Evaluate", ReturnTypeName = "Datadog.Trace.FeatureFlags.IEvaluation", - ParameterTypeNames = [ClrNames.String, "Datadog.Trace.FeatureFlags.ValueType", ClrNames.Object, "Datadog.Trace.FeatureFlags.IEvaluationContext"], + ParameterTypeNames = [ClrNames.String, "Datadog.Trace.FeatureFlags.ValueType", ClrNames.Object, ClrNames.String, "System.Collections.Generic.IDictionary`2[System.String,System.Object]"], MinimumVersion = "3.31.0", MaximumVersion = "3.*.*", IntegrationName = nameof(IntegrationId.DatadogTraceManual))] @@ -31,19 +32,19 @@ namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual; [EditorBrowsable(EditorBrowsableState.Never)] public sealed class FeatureFlagsSdkEvaluateIntegration { - internal static CallTargetState OnMethodBegin(ref string key, ref TTargetType targetType, ref object? defaultValue, ref TContext? context) + internal static CallTargetState OnMethodBegin(ref string flagKey, ref TTargetType targetType, ref object? defaultValue, ref string? targetingKey, ref IDictionary? attributes) { - return new CallTargetState(null, new State(key, (FeatureFlags.ValueType)(Convert.ToInt32(targetType)), defaultValue, context)); + return new CallTargetState(null, new State(flagKey, (FeatureFlags.ValueType)(Convert.ToInt32(targetType)), defaultValue, targetingKey, attributes)); } internal static CallTargetReturn OnMethodEnd(TReturn? returnValue, Exception? exception, in CallTargetState state) { var parameters = (State)state.State!; - var res = TracerManager.Instance.FeatureFlags?.Evaluate(parameters.Key, parameters.TargetType, parameters.DefaultValue, parameters.Context.DuckCast()); + var res = TracerManager.Instance.FeatureFlags?.Evaluate(parameters.FlagKey, parameters.TargetType, parameters.DefaultValue, parameters.TargetingKey ?? string.Empty, parameters.Attributes); return new CallTargetReturn(res.DuckCast()); } - private sealed record State(string Key, FeatureFlags.ValueType TargetType, object? DefaultValue, object? Context) + private sealed record State(string FlagKey, FeatureFlags.ValueType TargetType, object? DefaultValue, string? TargetingKey, IDictionary? Attributes) { } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs index b502338a30f3..8d2e4d9f803f 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs @@ -14,10 +14,7 @@ namespace Datadog.Trace.FeatureFlags /// Standard implementation of a EvaluationContext /// Targeting Key /// Context optional parameters - [EditorBrowsable(EditorBrowsableState.Never)] - [Browsable(false)] internal sealed class EvaluationContext(string key, IDictionary? values = null) - : IEvaluationContext { /// Gets the Context Targeting Key public string TargetingKey { get; } = key; diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs index f5ddbefda21e..de7657ba6c78 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs @@ -7,7 +7,6 @@ using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; -using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; @@ -17,7 +16,6 @@ using Datadog.Trace.FeatureFlags.Exposure.Model; using Datadog.Trace.HttpOverStreams; using Datadog.Trace.Logging; -using Datadog.Trace.Vendors.dnlib; using Datadog.Trace.Vendors.Newtonsoft.Json; namespace Datadog.Trace.Exposure diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index 59bbd241338a..bb4f8ca46427 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -44,7 +44,7 @@ public FeatureFlagsEvaluator(ReportExposureDelegate? onExposureEvent, ServerConf private delegate bool NumberEquality(double a, double b); - public Evaluation Evaluate(string flagKey, ValueType resultType, object? defaultValue, IEvaluationContext? context) + public Evaluation Evaluate(string flagKey, ValueType resultType, object? defaultValue, EvaluationContext? context) { try { @@ -211,7 +211,7 @@ private static bool IsAllocationActive(Allocation allocation, DateTime now) return true; } - private static bool EvaluateRules(List rules, IEvaluationContext? context) + private static bool EvaluateRules(List rules, EvaluationContext? context) { foreach (var rule in rules) { @@ -239,7 +239,7 @@ private static bool EvaluateRules(List rules, IEvaluationContext? context) return false; } - private static bool EvaluateCondition(ConditionConfiguration condition, IEvaluationContext? context) + private static bool EvaluateCondition(ConditionConfiguration condition, EvaluationContext? context) { if (condition.Operator is null) { @@ -435,7 +435,7 @@ private static string GetMd5Hash(string input) throw new FormatException("Wrong date format"); } - private static object? ResolveAttribute(string? name, IEvaluationContext? context) + private static object? ResolveAttribute(string? name, EvaluationContext? context) { if (name == null || context is null) { @@ -533,7 +533,7 @@ private static double ParseDouble(object value) return evaluation.FlagMetadata.TryGetValue("allocationKey", out var key) ? key : null; } - internal static IDictionary FlattenContext(IEvaluationContext? context) + internal static IDictionary FlattenContext(EvaluationContext? context) { var result = new Dictionary(); if (context is not null) @@ -594,7 +594,7 @@ private Evaluation ResolveVariant( string variationKey, Allocation allocation, DateTime evalTime, - IEvaluationContext? context) + EvaluationContext? context) { if (flag.Variations is null || !flag.Variations.TryGetValue(variationKey, out var variant) || variant == null) { @@ -639,7 +639,7 @@ private void DispatchExposure( string flagKey, Evaluation evaluation, DateTime evalTime, - IEvaluationContext? context) + EvaluationContext? context) { var allocationKey = AllocationKey(evaluation); var variantKey = evaluation.Variant; diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index a87a6a96f1be..8b3586112825 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -61,7 +61,7 @@ internal void RegisterOnNewConfigEventHandler(Action? onNewConfig) _onNewConfigEventHander = onNewConfig; } - internal Evaluation Evaluate(string flagKey, ValueType resultType, object? defaultValue, IEvaluationContext? context) + internal Evaluation Evaluate(string flagKey, ValueType resultType, object? defaultValue, string targetingKey, IDictionary? attributes) { var evaluator = Volatile.Read(ref _evaluator); if (evaluator is null) @@ -71,7 +71,7 @@ internal Evaluation Evaluate(string flagKey, ValueType resultType, object? defau } Log.Debug("FeatureFlagsModule::Evaluate -> Returning Evaluation"); - return evaluator.Evaluate(flagKey, resultType, defaultValue, context); + return evaluator.Evaluate(flagKey, resultType, defaultValue, new EvaluationContext(targetingKey, attributes)); } private void UpdateRemoteConfig(List> list) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs deleted file mode 100644 index 1eb7c65900e3..000000000000 --- a/tracer/src/Datadog.Trace/FeatureFlags/IEvaluationContext.cs +++ /dev/null @@ -1,28 +0,0 @@ -// -// 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.Collections.Generic; -using System.ComponentModel; - -namespace Datadog.Trace.FeatureFlags; - -/// FeatureFlag Evaluation result. -[EditorBrowsable(EditorBrowsableState.Never)] -[Browsable(false)] -public partial interface IEvaluationContext -{ - /// Gets the targeting key. - string TargetingKey { get; } - - /// Gets context attributes. - public IDictionary Attributes { get; } - - /// Get the Context attribute if existent - /// Value key - /// Returns Context Value or null - object? GetAttribute(string key); -} diff --git a/tracer/src/Datadog.Tracer.Native/Generated/generated_calltargets.g.cpp b/tracer/src/Datadog.Tracer.Native/Generated/generated_calltargets.g.cpp index 724729b1b40a..4d840725f2ab 100644 --- a/tracer/src/Datadog.Tracer.Native/Generated/generated_calltargets.g.cpp +++ b/tracer/src/Datadog.Tracer.Native/Generated/generated_calltargets.g.cpp @@ -76,7 +76,7 @@ WCHAR* sig057[]={(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationS WCHAR* sig058[]={(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettings"),(WCHAR*)WStr("System.String"),}; WCHAR* sig059[]={(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettingsCollection"),}; WCHAR* sig060[]={(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),}; -WCHAR* sig061[]={(WCHAR*)WStr("Datadog.Trace.FeatureFlags.IEvaluation"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.ValueType"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.IEvaluationContext"),}; +WCHAR* sig061[]={(WCHAR*)WStr("Datadog.Trace.FeatureFlags.IEvaluation"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.ValueType"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; WCHAR* sig062[]={(WCHAR*)WStr("Datadog.Trace.IScope"),}; WCHAR* sig063[]={(WCHAR*)WStr("Datadog.Trace.IScope"),(WCHAR*)WStr("System.String"),}; WCHAR* sig064[]={(WCHAR*)WStr("Datadog.Trace.IScope"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.ISpanContext"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Nullable`1[System.DateTimeOffset]"),(WCHAR*)WStr("System.Nullable`1[System.Boolean]"),}; @@ -694,7 +694,7 @@ std::vector callTargets = {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("PopulateDictionary"),sig345,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.PopulateDictionaryIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("set_DiagnosticSourceEnabled"),sig341,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.DiagnosticSourceEnabledSetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.ExtensionMethods.SpanExtensions"),(WCHAR*)WStr("SetTraceSamplingPriority"),sig320,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetTraceSamplingPriorityIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.FeatureFlagsSdk"),(WCHAR*)WStr("Evaluate"),sig061,5,3,31,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkEvaluateIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.FeatureFlagsSdk"),(WCHAR*)WStr("Evaluate"),sig061,6,3,31,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkEvaluateIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.FeatureFlagsSdk"),(WCHAR*)WStr("IsAvailable"),sig121,1,3,31,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkIsAvailableIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.FeatureFlagsSdk"),(WCHAR*)WStr("RegisterOnNewConfigEventHandler"),sig339,2,3,31,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextExtractor"),(WCHAR*)WStr(".ctor"),sig310,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorConstructorIntegration"),CallTargetKind::Default,1,15}, diff --git a/tracer/test/test-applications/integrations/Samples.FeatureFlags/Evaluator.cs b/tracer/test/test-applications/integrations/Samples.FeatureFlags/Evaluator.cs index 6fadd7b6aff3..2e39bfe524ec 100644 --- a/tracer/test/test-applications/integrations/Samples.FeatureFlags/Evaluator.cs +++ b/tracer/test/test-applications/integrations/Samples.FeatureFlags/Evaluator.cs @@ -14,8 +14,7 @@ public static void Init() public static (string? Value, string? Error)? Evaluate(string key) { - var context = new EvaluationContext(key); - var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, Datadog.Trace.FeatureFlags.ValueType.String, "Not found", context); + var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, Datadog.Trace.FeatureFlags.ValueType.String, "Not found", key, null); if (evaluation is null) { @@ -34,15 +33,4 @@ public static (string? Value, string? Error)? Evaluate(string key) return (evaluation.Value as string, evaluation.Error); } - - class EvaluationContext(string key, IDictionary? values = null) - : IEvaluationContext - { - public string TargetingKey { get; } = key; - - public IDictionary Attributes { get; } = values ?? new Dictionary(); - - public object? GetAttribute(string key) - => Attributes.TryGetValue(key, out var res) ? res : null; - } } diff --git a/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs b/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs index 6b92749c367b..02b5ba669ac0 100644 --- a/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs +++ b/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs @@ -36,7 +36,7 @@ public class DatadogProvider : global::OpenFeature.FeatureProvider public override Task> ResolveBooleanValueAsync(string flagKey, bool defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Boolean, defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Boolean, defaultValue, context?.TargetingKey, GetContextAttributes(context)); return Task.FromResult(GetResolutionDetails(res)); } @@ -49,7 +49,7 @@ public override Task> ResolveBooleanValueAsync(string fl public override Task> ResolveDoubleValueAsync(string flagKey, double defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Numeric, defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Numeric, defaultValue, context?.TargetingKey, GetContextAttributes(context)); return Task.FromResult(GetResolutionDetails(res)); } @@ -62,7 +62,7 @@ public override Task> ResolveDoubleValueAsync(string f public override Task> ResolveIntegerValueAsync(string flagKey, int defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Integer, defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Integer, defaultValue, context?.TargetingKey, GetContextAttributes(context)); return Task.FromResult(GetResolutionDetails(res)); } @@ -75,7 +75,7 @@ public override Task> ResolveIntegerValueAsync(string fla public override Task> ResolveStringValueAsync(string flagKey, string defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.String, defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.String, defaultValue, context?.TargetingKey, GetContextAttributes(context)); return Task.FromResult(GetResolutionDetails(res)); } @@ -88,20 +88,18 @@ public override Task> ResolveStringValueAsync(string f public override Task> ResolveStructureValueAsync(string flagKey, Value defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Json, defaultValue, GetContext(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Json, defaultValue, context?.TargetingKey, GetContextAttributes(context)); return Task.FromResult(GetResolutionDetails(res)); } - private static IEvaluationContext? GetContext(EvaluationContext? context) + private static IDictionary? GetContextAttributes(EvaluationContext? context) { if (context == null) { return null; } - var values = context.AsDictionary().Select(p => new KeyValuePair(p.Key, ToObject(p.Value))).ToDictionary(p => p.Key, p => p.Value); - var res = new Context(context.TargetingKey ?? string.Empty, values); - return res; + return context.AsDictionary().Select(p => new KeyValuePair(p.Key, ToObject(p.Value))).ToDictionary(p => p.Key, p => p.Value); } private static object? ToObject(Value value) => value switch @@ -159,15 +157,4 @@ private static ImmutableMetadata ToMetadata(IDictionary? metadat var dic = (metadata ?? new Dictionary()).ToDictionary(p => p.Key, p => (object)p.Value); return new ImmutableMetadata(dic); } - - class Context(string key, IDictionary? values = null) - : IEvaluationContext - { - public string TargetingKey { get; } = key; - - public IDictionary Attributes { get; } = values ?? new Dictionary(); - - public object? GetAttribute(string key) - => Attributes.TryGetValue(key, out var res) ? res : null; - } } From 6114fc1ad2a35e3ce331b37109e4351a8a6526f6 Mon Sep 17 00:00:00 2001 From: Andrew Lock Date: Wed, 24 Dec 2025 15:25:47 +0000 Subject: [PATCH 46/54] Reinstated EvaluationContext into public API It is actually easier to evolve this over time, but by instrumenting the exploded args we can maintain compatibility without extra duck typing --- .../FeatureFlags/EvaluationContext.cs | 22 +++++++++++++++++++ .../FeatureFlags/FeatureFlagsSdk.cs | 13 ++++++++--- .../FeatureFlags/EvaluationContext.cs | 6 ----- .../Samples.FeatureFlags/Evaluator.cs | 2 +- .../Samples.OpenFeature/DatadogProvider.cs | 17 +++++++++----- 5 files changed, 44 insertions(+), 16 deletions(-) create mode 100644 tracer/src/Datadog.Trace.Manual/FeatureFlags/EvaluationContext.cs diff --git a/tracer/src/Datadog.Trace.Manual/FeatureFlags/EvaluationContext.cs b/tracer/src/Datadog.Trace.Manual/FeatureFlags/EvaluationContext.cs new file mode 100644 index 000000000000..c2b2ea1d8b64 --- /dev/null +++ b/tracer/src/Datadog.Trace.Manual/FeatureFlags/EvaluationContext.cs @@ -0,0 +1,22 @@ +// +// 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.ComponentModel; + +namespace Datadog.Trace.FeatureFlags; + +/// Standard implementation of a EvaluationContext +/// Targeting Key +/// Context optional parameters +[EditorBrowsable(EditorBrowsableState.Never)] +[Browsable(false)] +public sealed class EvaluationContext(string? key, IDictionary? values = null) +{ + /// Gets the Context Targeting Key + public string? TargetingKey { get; } = key; + + /// Gets the Context optional Values + public IDictionary? Attributes { get; } = values; +} diff --git a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs index 3414e6518074..5c433807f766 100644 --- a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs +++ b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs @@ -38,12 +38,19 @@ public static void RegisterOnNewConfigEventHandler(Action onNewConfig) /// The feature flag key to evaluate /// The desired result type /// The default value - /// The context targetting key - /// The context attributes + /// The evaluation context + public static IEvaluation? Evaluate(string flagKey, ValueType targetType, object? defaultValue, EvaluationContext? context) + => Evaluate(flagKey, targetType, defaultValue, context?.TargetingKey, context?.Attributes); + [Instrumented] [MethodImpl(MethodImplOptions.NoInlining)] - public static IEvaluation? Evaluate(string flagKey, ValueType targetType, object? defaultValue, string? targetingKey, IDictionary? attributes) + private static IEvaluation? Evaluate(string flagKey, ValueType targetType, object? defaultValue, string? targetingKey, IDictionary? attributes) { + if (flagKey is null) + { + throw new ArgumentNullException(nameof(flagKey)); + } + return null; } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs index 8d2e4d9f803f..73bd38b43f8a 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs @@ -21,11 +21,5 @@ internal sealed class EvaluationContext(string key, IDictionary /// Gets the Context optional Values public IDictionary Attributes { get; } = values ?? new Dictionary(); - - /// Get the Context value if existent - /// Value key - /// Returns Context Value or null - public object? GetAttribute(string key) - => Attributes.TryGetValue(key, out var res) ? res : null; } } diff --git a/tracer/test/test-applications/integrations/Samples.FeatureFlags/Evaluator.cs b/tracer/test/test-applications/integrations/Samples.FeatureFlags/Evaluator.cs index 2e39bfe524ec..3bace0fad8a7 100644 --- a/tracer/test/test-applications/integrations/Samples.FeatureFlags/Evaluator.cs +++ b/tracer/test/test-applications/integrations/Samples.FeatureFlags/Evaluator.cs @@ -14,7 +14,7 @@ public static void Init() public static (string? Value, string? Error)? Evaluate(string key) { - var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, Datadog.Trace.FeatureFlags.ValueType.String, "Not found", key, null); + var evaluation = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(key, Datadog.Trace.FeatureFlags.ValueType.String, "Not found", new EvaluationContext(key)); if (evaluation is null) { diff --git a/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs b/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs index 02b5ba669ac0..1297b22d2ae4 100644 --- a/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs +++ b/tracer/test/test-applications/integrations/Samples.OpenFeature/DatadogProvider.cs @@ -10,7 +10,6 @@ using System.Linq; using System.Threading; using System.Threading.Tasks; -using Datadog.Trace.FeatureFlags; using OpenFeature.Constant; using OpenFeature.Model; @@ -36,7 +35,7 @@ public class DatadogProvider : global::OpenFeature.FeatureProvider public override Task> ResolveBooleanValueAsync(string flagKey, bool defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Boolean, defaultValue, context?.TargetingKey, GetContextAttributes(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Boolean, defaultValue, ToContext(context)); return Task.FromResult(GetResolutionDetails(res)); } @@ -49,7 +48,7 @@ public override Task> ResolveBooleanValueAsync(string fl public override Task> ResolveDoubleValueAsync(string flagKey, double defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Numeric, defaultValue, context?.TargetingKey, GetContextAttributes(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Numeric, defaultValue, ToContext(context)); return Task.FromResult(GetResolutionDetails(res)); } @@ -62,7 +61,7 @@ public override Task> ResolveDoubleValueAsync(string f public override Task> ResolveIntegerValueAsync(string flagKey, int defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Integer, defaultValue, context?.TargetingKey, GetContextAttributes(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Integer, defaultValue, ToContext(context)); return Task.FromResult(GetResolutionDetails(res)); } @@ -75,7 +74,7 @@ public override Task> ResolveIntegerValueAsync(string fla public override Task> ResolveStringValueAsync(string flagKey, string defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.String, defaultValue, context?.TargetingKey, GetContextAttributes(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.String, defaultValue, ToContext(context)); return Task.FromResult(GetResolutionDetails(res)); } @@ -88,7 +87,7 @@ public override Task> ResolveStringValueAsync(string f public override Task> ResolveStructureValueAsync(string flagKey, Value defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); - var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Json, defaultValue, context?.TargetingKey, GetContextAttributes(context)); + var res = Datadog.Trace.FeatureFlags.FeatureFlagsSdk.Evaluate(flagKey, Trace.FeatureFlags.ValueType.Json, defaultValue, ToContext(context)); return Task.FromResult(GetResolutionDetails(res)); } @@ -157,4 +156,10 @@ private static ImmutableMetadata ToMetadata(IDictionary? metadat var dic = (metadata ?? new Dictionary()).ToDictionary(p => p.Key, p => (object)p.Value); return new ImmutableMetadata(dic); } + + private static Datadog.Trace.FeatureFlags.EvaluationContext? ToContext(EvaluationContext? context) + { + return context is null ? null : new(context.TargetingKey, GetContextAttributes(context)); + + } } From e2b1294e1938eb0406512e6f7720ced3dcd4b222 Mon Sep 17 00:00:00 2001 From: Andrew Lock Date: Wed, 24 Dec 2025 15:31:02 +0000 Subject: [PATCH 47/54] Minor tweaks to the API --- .../FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs index 7befff9504b0..d00628c581c6 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkEvaluateIntegration.cs @@ -32,13 +32,19 @@ namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual; [EditorBrowsable(EditorBrowsableState.Never)] public sealed class FeatureFlagsSdkEvaluateIntegration { - internal static CallTargetState OnMethodBegin(ref string flagKey, ref TTargetType targetType, ref object? defaultValue, ref string? targetingKey, ref IDictionary? attributes) + internal static CallTargetState OnMethodBegin(ref string flagKey, FeatureFlags.ValueType targetType, ref object? defaultValue, ref string? targetingKey, ref IDictionary? attributes) { - return new CallTargetState(null, new State(flagKey, (FeatureFlags.ValueType)(Convert.ToInt32(targetType)), defaultValue, targetingKey, attributes)); + return new CallTargetState(null, new State(flagKey, targetType, defaultValue, targetingKey, attributes)); } internal static CallTargetReturn OnMethodEnd(TReturn? returnValue, Exception? exception, in CallTargetState state) { + if (exception is not null) + { + // invalid call to the API e.g. non-null args were null. Just let it bubble up. + return new CallTargetReturn(returnValue); + } + var parameters = (State)state.State!; var res = TracerManager.Instance.FeatureFlags?.Evaluate(parameters.FlagKey, parameters.TargetType, parameters.DefaultValue, parameters.TargetingKey ?? string.Empty, parameters.Attributes); return new CallTargetReturn(res.DuckCast()); From ea38ed47b6e9350baba6fc9417cf61e249f04732 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Sun, 28 Dec 2025 21:09:39 +0100 Subject: [PATCH 48/54] Fix compilation error --- tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs index 73bd38b43f8a..8d2e4d9f803f 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs @@ -21,5 +21,11 @@ internal sealed class EvaluationContext(string key, IDictionary /// Gets the Context optional Values public IDictionary Attributes { get; } = values ?? new Dictionary(); + + /// Get the Context value if existent + /// Value key + /// Returns Context Value or null + public object? GetAttribute(string key) + => Attributes.TryGetValue(key, out var res) ? res : null; } } From 58e2eda7073683f6afa8c1d7aefabdf907ce4115 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Sun, 28 Dec 2025 21:23:17 +0100 Subject: [PATCH 49/54] PR comment --- ...egisterOnNewConfigEventHandlerIntegration.cs | 17 ++--------------- 1 file changed, 2 insertions(+), 15 deletions(-) diff --git a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs index 15d0c16348d9..d2e70fd95f95 100644 --- a/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs +++ b/tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/ManualInstrumentation/FeatureFlags/FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration.cs @@ -32,20 +32,7 @@ public sealed class FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration { internal static CallTargetState OnMethodBegin(ref Action? onNewConfig) { - return new CallTargetState(null, onNewConfig); - } - - internal static CallTargetReturn OnMethodEnd(Exception? exception, in CallTargetState state) - { - if (state.State is Action onNewConfig) - { - TracerManager.Instance.FeatureFlags?.RegisterOnNewConfigEventHandler(onNewConfig); - } - else - { - exception = new ArgumentException(); - } - - return CallTargetReturn.GetDefault(); + TracerManager.Instance.FeatureFlags?.RegisterOnNewConfigEventHandler(onNewConfig); + return CallTargetState.GetDefault(); } } From 5997cc3e6eefd10148a8e5747a921d7d172c8eaa Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Tue, 30 Dec 2025 18:00:46 +0100 Subject: [PATCH 50/54] PR comments --- .../FeatureFlags/EvaluationContext.cs | 6 +- .../FeatureFlags/FeatureFlagsEvaluator.cs | 132 ++++++++++++------ .../Datadog.Trace/FeatureFlags/ValueType.cs | 4 +- .../FeatureFlagsHelpers.cs | 7 +- .../FeatureFlagsEvaluatorTests.cs | 101 ++++++++------ 5 files changed, 155 insertions(+), 95 deletions(-) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs index 8d2e4d9f803f..48246570b678 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/EvaluationContext.cs @@ -13,14 +13,14 @@ namespace Datadog.Trace.FeatureFlags { /// Standard implementation of a EvaluationContext /// Targeting Key - /// Context optional parameters - internal sealed class EvaluationContext(string key, IDictionary? values = null) + /// Context optional attributes + internal sealed class EvaluationContext(string key, IDictionary? attributes = null) { /// Gets the Context Targeting Key public string TargetingKey { get; } = key; /// Gets the Context optional Values - public IDictionary Attributes { get; } = values ?? new Dictionary(); + public IDictionary Attributes { get; } = attributes ?? new Dictionary(); /// Get the Context value if existent /// Value key diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index bb4f8ca46427..c51d788df15a 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -21,9 +21,10 @@ namespace Datadog.Trace.FeatureFlags { internal sealed class FeatureFlagsEvaluator { - internal static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(FeatureFlagsEvaluator)); + internal const string DateFormat = "yyyy-MM-dd'T'HH:mm:ss.fff'Z'"; + internal const string MetadataAllocationKey = "dd_allocationKey"; - internal static readonly string DateFormat = "yyyy-MM-dd'T'HH:mm:ss.fff'Z'"; + internal static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(FeatureFlagsEvaluator)); private readonly ReportExposureDelegate? _onExposureEvent; private readonly ServerConfiguration? _config; @@ -62,19 +63,6 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default }); } - if (StringUtil.IsNullOrEmpty(context?.TargetingKey)) - { - return new Evaluation( - flagKey, - defaultValue, - EvaluationReason.Error, - error: "TARGETING_KEY_MISSING", - metadata: new Dictionary - { - ["errorCode"] = "TARGETING_KEY_MISSING" - }); - } - if (config.Flags is null || !config.Flags.TryGetValue(flagKey, out var flag) || flag is null) { return new Evaluation( @@ -118,7 +106,7 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default } var now = DateTime.UtcNow; - var targetingKey = context?.TargetingKey ?? string.Empty; + var targetingKey = context?.TargetingKey; foreach (var allocation in flag.Allocations) { @@ -139,6 +127,11 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default { foreach (var split in allocation.Splits) { + if (StringUtil.IsNullOrEmpty(split.VariationKey)) + { + throw new FormatException($"Empty variation key in allocation {allocation.Key}"); + } + var allShardsMatch = true; if (split.Shards is { Count: > 0 } splitShards) { @@ -154,7 +147,7 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default if (allShardsMatch) { - return ResolveVariant(flagKey, resultType, defaultValue, flag, split.VariationKey ?? string.Empty, allocation, now, context); + return ResolveVariant(flagKey, resultType, defaultValue, flag, split.VariationKey, allocation, now, context); } } } @@ -179,6 +172,18 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default ["message"] = ex.Message }); } + catch (MissingTargetingKeyException) + { + return new Evaluation( + flagKey, + defaultValue, + EvaluationReason.Error, + error: "TARGETING_KEY_MISSING", + metadata: new Dictionary + { + ["errorCode"] = "TARGETING_KEY_MISSING" + }); + } catch (Exception ex) { return new Evaluation( @@ -279,7 +284,7 @@ private static bool EvaluateCondition(ConditionConfiguration condition, Evaluati case ConditionOperator.LT: return CompareNumber(attributeValue, condition.Value, (a, b) => a < b); default: - return false; + throw new FormatException($"Unknown condition operator {condition.Operator.ToString()}"); } } @@ -313,7 +318,7 @@ private static bool IsOneOf(object attributeValue, object? conditionValue) { if (conditionValue is not IEnumerable enumerable) { - return false; + throw new FormatException($"Condition value is not an array {Convert.ToString(conditionValue ?? "")}"); } foreach (var value in enumerable) @@ -373,7 +378,7 @@ private static bool CompareNumber(object attributeValue, object? conditionValue, return comparator(a, b); } - private static bool MatchesShard(Shard shard, string targetingKey) + private static bool MatchesShard(Shard shard, string? targetingKey) { if (shard.Ranges is null) { @@ -392,8 +397,13 @@ private static bool MatchesShard(Shard shard, string targetingKey) return false; } - private static int GetShard(string salt, string targetingKey, int totalShards) + private static int GetShard(string salt, string? targetingKey, int totalShards) { + if (StringUtil.IsNullOrEmpty(targetingKey)) + { + throw new MissingTargetingKeyException(); + } + var hashKey = $"{salt}-{targetingKey}"; var md5Hash = GetMd5Hash(hashKey); var first8Chars = md5Hash.Substring(0, Math.Min(8, md5Hash.Length)); @@ -445,6 +455,11 @@ private static string GetMd5Hash(string input) // Special case "id": if not present, use targeting key if (name == "id" && !context.Attributes.ContainsKey(name)) { + if (StringUtil.IsNullOrEmpty(context.TargetingKey)) + { + throw new MissingTargetingKeyException(); + } + return context.TargetingKey; } @@ -480,7 +495,7 @@ private static string GetMd5Hash(string input) if (target == ValueType.Integer) { - var number = ParseDouble(value); + var number = ParseInteger(value); return (int)number; } @@ -508,12 +523,7 @@ private static double ParseDouble(object value) { if (value is string txt) { - return txt.ToLower() switch - { - "true" => 1.0, - "false" => 0.0, - _ => double.Parse(txt, CultureInfo.InvariantCulture) - }; + return double.Parse(txt, CultureInfo.InvariantCulture); } else if (value is IConvertible) { @@ -523,6 +533,20 @@ private static double ParseDouble(object value) return double.Parse(Convert.ToString(value)!, CultureInfo.InvariantCulture); } + private static double ParseInteger(object value) + { + if (value is string txt) + { + return int.Parse(txt, CultureInfo.InvariantCulture); + } + else if (value is IConvertible) + { + return Convert.ToInt32(value, CultureInfo.InvariantCulture); + } + + return int.Parse(Convert.ToString(value)!, CultureInfo.InvariantCulture); + } + private static string? AllocationKey(Evaluation evaluation) { if (evaluation.FlagMetadata == null) @@ -530,7 +554,7 @@ private static double ParseDouble(object value) return null; } - return evaluation.FlagMetadata.TryGetValue("allocationKey", out var key) ? key : null; + return evaluation.FlagMetadata.TryGetValue(MetadataAllocationKey, out var key) ? key : null; } internal static IDictionary FlattenContext(EvaluationContext? context) @@ -550,6 +574,12 @@ private static double ParseDouble(object value) var entry = stack.Pop(); var value = entry.Value; + // For now only return first level entries + if (entry.Level > 1) + { + continue; + } + if (value == null || seen.Add(value)) { if (value == null) @@ -596,27 +626,25 @@ private Evaluation ResolveVariant( DateTime evalTime, EvaluationContext? context) { + if (StringUtil.IsNullOrEmpty(flag.Key)) + { + return ParseError($"Variant not found for: {variationKey}"); + } + + if (StringUtil.IsNullOrEmpty(allocation.Key)) + { + return ParseError($"Allocation key is null for {flagKey}"); + } + if (flag.Variations is null || !flag.Variations.TryGetValue(variationKey, out var variant) || variant == null) { - return new Evaluation( - flagKey, - defaultValue, - EvaluationReason.Error, - error: $"Variant not found for: {variationKey}", - metadata: new Dictionary - { - ["errorCode"] = "PARSE_ERROR", - ["message"] = $"Variant not found for: {variationKey}" - }); + return ParseError($"Variant not found for: {variationKey}"); } var mappedValue = MapValue(resultType, variant.Value); - var metadata = new Dictionary { - ["flagKey"] = flag.Key ?? string.Empty, - ["variationType"] = flag.VariationType?.ToString() ?? string.Empty, - ["allocationKey"] = allocation.Key ?? string.Empty + [MetadataAllocationKey] = allocation.Key }; var evaluation = new Evaluation( @@ -633,6 +661,20 @@ private Evaluation ResolveVariant( } return evaluation; + + Evaluation ParseError(string error) + { + return new Evaluation( + flagKey, + defaultValue, + EvaluationReason.Error, + error: error, + metadata: new Dictionary + { + ["errorCode"] = "PARSE_ERROR", + ["message"] = error + }); + } } private void DispatchExposure( @@ -663,6 +705,10 @@ private record struct FlattenEntry(string Key, object? Value, int Level) { } + private sealed class MissingTargetingKeyException : Exception + { + } + #pragma warning disable SA1201 // Elements should appear in the correct order internal delegate void ReportExposureDelegate(in Exposure.Model.ExposureEvent ev); #pragma warning restore SA1201 // Elements should appear in the correct order diff --git a/tracer/src/Datadog.Trace/FeatureFlags/ValueType.cs b/tracer/src/Datadog.Trace/FeatureFlags/ValueType.cs index 14dae134d8c8..94d5d37ccbd3 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/ValueType.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/ValueType.cs @@ -9,7 +9,7 @@ namespace Datadog.Trace.FeatureFlags; -/// Evaluation result reason +/// Evaluation result type [EditorBrowsable(EditorBrowsableState.Never)] [Browsable(false)] public enum ValueType @@ -26,6 +26,6 @@ public enum ValueType /// Bool value Boolean, - /// Json string value + /// Json value Json } diff --git a/tracer/test/Datadog.Trace.TestHelpers/FeatureFlagsHelpers.cs b/tracer/test/Datadog.Trace.TestHelpers/FeatureFlagsHelpers.cs index 594581179b47..acce7069947c 100644 --- a/tracer/test/Datadog.Trace.TestHelpers/FeatureFlagsHelpers.cs +++ b/tracer/test/Datadog.Trace.TestHelpers/FeatureFlagsHelpers.cs @@ -38,9 +38,14 @@ internal static Flag CreateSimpleFlag(string key, ValueType type, object value, [variantKey] = new Variant { Key = variantKey, Value = (string)value }, }; + var shards = new List() + { + new Shard() { Salt = ".", TotalShards = 5000, Ranges = new List { new ShardRange() { Start = 0, End = 5000 } } } + }; + var splits = new List { - new Split { Shards = new List(), VariationKey = variantKey } + new Split { Shards = shards, VariationKey = variantKey } }; var allocations = new List diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs index 181af1a688d0..04a25d8cb59e 100644 --- a/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/FeatureFlagsEvaluatorTests.cs @@ -27,48 +27,57 @@ public partial class FeatureFlagsEvaluatorTests public static IEnumerable MapValueCases() { - // targetType, value, expected (or typeof(Exception)) + // targetType, value, expected, typeof(Exception) + yield return new object?[] { null, null, null }; + // String - yield return new object?[] { "hello", "hello" }; - yield return new object?[] { 123, "123" }; - yield return new object?[] { true, "True" }; - yield return new object?[] { 3.14, "3.14" }; - yield return new object?[] { null, null }; + yield return new object?[] { "hello", "hello", null }; + yield return new object?[] { 123, "123", null }; + yield return new object?[] { true, "True", null }; + yield return new object?[] { 3.14, "3.14", null }; // Bool - yield return new object?[] { true, true }; - yield return new object?[] { false, false }; - yield return new object?[] { "true", true }; - yield return new object?[] { "false", false }; - yield return new object?[] { "TRUE", true }; - yield return new object?[] { "FALSE", false }; - yield return new object?[] { 1, true }; - yield return new object?[] { 0, false }; - yield return new object?[] { null, null }; + yield return new object?[] { true, true, null }; + yield return new object?[] { false, false, null }; + yield return new object?[] { "true", true, null }; + yield return new object?[] { "false", false, null }; + yield return new object?[] { "TRUE", true, null }; + yield return new object?[] { "FALSE", false, null }; + yield return new object?[] { 1, true, null }; + yield return new object?[] { 0, false, null }; // Int - yield return new object?[] { 42, (int)42 }; - yield return new object?[] { "42", (int)42 }; - yield return new object?[] { 3.14, (int)3 }; - yield return new object?[] { "3.14", (int)3 }; - yield return new object?[] { null, null }; + yield return new object?[] { 42, (int)42, null }; + yield return new object?[] { "42", (int)42, null }; // Double - yield return new object?[] { 3.14, 3.14 }; - yield return new object?[] { "3.14", 3.14 }; - yield return new object?[] { 42, 42d }; - yield return new object?[] { "42", 42d }; - yield return new object?[] { null, null }; + yield return new object?[] { 3.14, 3.14, null }; + yield return new object?[] { "3.14", 3.14, null }; + yield return new object?[] { 42, 42d, null }; + yield return new object?[] { "42", 42d, null }; // Unsupported - yield return new object?[] { new DateTime(2023, 12, 21), typeof(ArgumentException) }; + yield return new object?[] { new DateTime(2023, 12, 21), null, typeof(ArgumentException) }; + yield return new object?[] { "3.14", (int)3, typeof(FormatException) }; + yield return new object?[] { 3.14, (int)3, typeof(FormatException) }; } [Theory] [MemberData(nameof(MapValueCases))] - public void MapValueTests(object? input, object? expected) + public void MapValueTests(object? input, object? expected, Type? expectedExceptionType) { - if (expected is null || expected is string) + if (expectedExceptionType is not null) + { + try + { + _ = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.String, input); + } + catch (Exception res) + { + Assert.Equal(expectedExceptionType, res.GetType()); + } + } + else if (expected is null || expected is string) { var res = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.String, input); Assert.Equal(expected, res); @@ -88,17 +97,6 @@ public void MapValueTests(object? input, object? expected) var res = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.Boolean, input); Assert.Equal(expected, res); } - else if (expected is System.Type) - { - try - { - _ = FeatureFlagsEvaluator.MapValue(Trace.FeatureFlags.ValueType.String, input); - } - catch (Exception res) - { - Assert.Equal(expected, res.GetType()); - } - } else { throw new Exception($"Unknown expected type {expected.GetType()}"); @@ -121,10 +119,21 @@ public void EvaluateWithoutConfigReturnsProviderNotReadyAndDefault() [Fact] public void EvaluateWithMissingTargetingKeyReturnsTargetingKeyMissing() { - var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration()); - var ctx = new EvaluationContext(string.Empty); // no targetingKey + var flags = new Dictionary + { + ["simple-string"] = FeatureFlagsHelpers.CreateSimpleFlag("simple-string", ValueType.String, "default", "on") + }; + + var evaluator = new FeatureFlagsEvaluator(null, new ServerConfiguration { Flags = flags }); + + var ctx = new EvaluationContext("user-123"); + var result = evaluator.Evaluate("simple-string", Trace.FeatureFlags.ValueType.String, "default", ctx); + Assert.Equal("default", result.Value); + Assert.Equal(EvaluationReason.TargetingMatch, result.Reason); + Assert.Equal("on", result.Variant); - var result = evaluator.Evaluate("flag", Trace.FeatureFlags.ValueType.String, "default", ctx); + var noTargettingKeyCtx = new EvaluationContext(string.Empty); // no targetingKey + result = evaluator.Evaluate("simple-string", Trace.FeatureFlags.ValueType.String, "default", noTargettingKeyCtx); Assert.Equal("default", result.Value); Assert.Equal(EvaluationReason.Error, result.Reason); @@ -225,15 +234,15 @@ public void EvaluateFlagWithoutAllocationsReturnsDefaultValue() // list: [1,2,[4]] yield return new object[] { - new Dictionary { { "list", new List { 1, 2, new List { 4 } } } }, - new Dictionary { { "list[0]", 1 }, { "list[1]", 2 }, { "list[2][0]", 4 } }, + new Dictionary { { "integer", 1 }, { "list", new List { 1, 2, new List { 4 } } } }, + new Dictionary { { "integer", 1 } }, }; // nested map yield return new object[] { - new Dictionary { { "map", new Dictionary { { "key1", 1 }, { "key2", 2 }, { "key3", new Dictionary { { "key4", 4 } } } } } }, - new Dictionary { { "map.key1", 1 }, { "map.key2", 2 }, { "map.key3.key4", 4 } }, + new Dictionary { { "integer", 1 }, { "map", new Dictionary { { "key1", 1 }, { "key2", 2 }, { "key3", new Dictionary { { "key4", 4 } } } } } }, + new Dictionary { { "integer", 1 } }, }; } From 7455cb67cb25150c65d89084b134e995cafa162d Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Wed, 7 Jan 2026 10:16:17 +0100 Subject: [PATCH 51/54] PR comments --- .../src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs | 2 +- tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs | 5 +++-- tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs | 2 +- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs index c51d788df15a..f63f5e535df8 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsEvaluator.cs @@ -76,7 +76,7 @@ public Evaluation Evaluate(string flagKey, ValueType resultType, object? default }); } - if (!flag.Enabled is true) + if (flag.Enabled != true) { return new Evaluation( flagKey, diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index 8b3586112825..e61fcd2b612d 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -79,10 +79,11 @@ private void UpdateRemoteConfig(List> Log.Debug("FeatureFlagsModule::UpdateRemoteConfig -> New config received. {Count}", list.Count); try { - // Feed configs to the rules evaluator + // Feed configs to the rules evaluator (take only the last one) if (list.Count > 0) { - Interlocked.Exchange(ref _evaluator, new FeatureFlagsEvaluator(ReportExposure, list[0].Value)); + var selectedConfig = list[list.Count - 1].Value; + Interlocked.Exchange(ref _evaluator, new FeatureFlagsEvaluator(ReportExposure, selectedConfig)); _onNewConfigEventHander?.Invoke(); } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs index 58b1317341af..db5983783da4 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Rcm/FfeProduct.cs @@ -52,7 +52,7 @@ public ApplyDetails[] UpdateFromRcm(Dictionary if (serverConfigFile.TypedFile is not null) { _serverConfigurations.Add(new KeyValuePair(ffeConfig.Path.Path, serverConfigFile.TypedFile)); - res.Insert(0, ApplyDetails.FromOk(ffeConfig.Path.Path)); + res.Add(ApplyDetails.FromOk(ffeConfig.Path.Path)); apply = true; } } From 0a5567937437e84f9b0e09f52970463ba399d5d6 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Wed, 7 Jan 2026 13:57:56 +0100 Subject: [PATCH 52/54] Added exposure events cache for deduplication --- .../FeatureFlags/Exposure/ExposureApi.cs | 214 +++++++++--------- .../FeatureFlags/Exposure/ExposureCache.cs | 120 ++++++++++ .../FeatureFlags/FeatureFlagsModule.cs | 2 +- .../FeatureFlags/ExposureCacheTests.cs | 185 +++++++++++++++ 4 files changed, 415 insertions(+), 106 deletions(-) create mode 100644 tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureCache.cs create mode 100644 tracer/test/Datadog.Trace.Tests/FeatureFlags/ExposureCacheTests.cs diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs index de7657ba6c78..d172355e6d8f 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureApi.cs @@ -18,151 +18,155 @@ using Datadog.Trace.Logging; using Datadog.Trace.Vendors.Newtonsoft.Json; -namespace Datadog.Trace.Exposure -{ - internal sealed class ExposureApi : IDisposable - { - internal static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(ExposureApi)); +namespace Datadog.Trace.FeatureFlags.Exposure; - public const string ExposurePath = "evp_proxy/v2/api/v2/exposure"; - private readonly TaskCompletionSource _processExit = new(); - private readonly TimeSpan _sendInterval = TimeSpan.FromSeconds(10); - private readonly Queue _exposures = new Queue(); +internal sealed class ExposureApi : IDisposable +{ + internal static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(ExposureApi)); - private IApiRequestFactory _apiRequestFactory; - private Dictionary _context; - private int _started = 0; + private const int DefaultCapacity = 1 << 16; // 65536 elements + public const string ExposurePath = "evp_proxy/v2/api/v2/exposure"; + private readonly TaskCompletionSource _processExit = new(); + private readonly TimeSpan _sendInterval = TimeSpan.FromSeconds(10); + private readonly Queue _exposures = new Queue(); - internal ExposureApi(TracerSettings tracerSettings) - { - UpdateApi(tracerSettings.Manager.InitialExporterSettings); - UpdateContext(tracerSettings.Manager.InitialMutableSettings); - - tracerSettings.Manager.SubscribeToChanges(changes => - { - if (changes.UpdatedExporter is { } exporter) - { - UpdateApi(exporter); - } + private ExposureCache _exposureCache = new ExposureCache(DefaultCapacity); + private IApiRequestFactory _apiRequestFactory; + private Dictionary _context; + private int _started = 0; - if (changes.UpdatedMutable is { } mutable) - { - UpdateContext(mutable); - } - }); + internal ExposureApi(TracerSettings tracerSettings) + { + UpdateApi(tracerSettings.Manager.InitialExporterSettings); + UpdateContext(tracerSettings.Manager.InitialMutableSettings); - [MemberNotNull(nameof(_apiRequestFactory))] - void UpdateApi(ExporterSettings exporterSettings) + tracerSettings.Manager.SubscribeToChanges(changes => + { + if (changes.UpdatedExporter is { } exporter) { - Log.Debug("ExposureApi::UpdateApi-> Applying settings"); - var apiRequestFactory = AgentTransportStrategy.Get( - exporterSettings, - productName: "FeatureFlags exposure", - tcpTimeout: TimeSpan.FromSeconds(5), - AgentHttpHeaderNames.MinimalHeaders, - () => new MinimalAgentHeaderHelper(), - uri => uri); - Interlocked.Exchange(ref _apiRequestFactory!, apiRequestFactory); + UpdateApi(exporter); } - [MemberNotNull(nameof(_context))] - void UpdateContext(MutableSettings settings) + if (changes.UpdatedMutable is { } mutable) { - Log.Debug("ExposureApi::UpdateContext -> Applying settings"); - var context = new Dictionary - { - { "service", settings.DefaultServiceName }, - { "env", settings.Environment ?? "unknown" }, - { "version", settings.ServiceVersion ?? "unknown" } - }; - Interlocked.Exchange(ref _context!, context); + UpdateContext(mutable); } - } + }); - public void Dispose() + [MemberNotNull(nameof(_apiRequestFactory))] + void UpdateApi(ExporterSettings exporterSettings) { - _processExit.TrySetResult(true); + Log.Debug("ExposureApi::UpdateApi-> Applying settings"); + var apiRequestFactory = AgentTransportStrategy.Get( + exporterSettings, + productName: "FeatureFlags exposure", + tcpTimeout: TimeSpan.FromSeconds(5), + AgentHttpHeaderNames.MinimalHeaders, + () => new MinimalAgentHeaderHelper(), + uri => uri); + Interlocked.Exchange(ref _apiRequestFactory!, apiRequestFactory); } - public void TryToStartSendLoopIfNotStarted() + [MemberNotNull(nameof(_context))] + void UpdateContext(MutableSettings settings) { - if (Interlocked.CompareExchange(ref _started, 1, 0) != 0) + Log.Debug("ExposureApi::UpdateContext -> Applying settings"); + var context = new Dictionary { - return; - } + { "service", settings.DefaultServiceName }, + { "env", settings.Environment ?? "unknown" }, + { "version", settings.ServiceVersion ?? "unknown" } + }; + Interlocked.Exchange(ref _context!, context); + } + } - _ = Task.Run(SendLoopAsync).ContinueWith(t => { Log.Error(t.Exception, "FeatureFlags Exposure send loop failed"); }, TaskContinuationOptions.OnlyOnFaulted); + public void Dispose() + { + _processExit.TrySetResult(true); + } + + public void TryToStartSendLoopIfNotStarted() + { + if (Interlocked.CompareExchange(ref _started, 1, 0) != 0) + { + return; } - private async Task SendLoopAsync() + _ = Task.Run(SendLoopAsync).ContinueWith(t => { Log.Error(t.Exception, "FeatureFlags Exposure send loop failed"); }, TaskContinuationOptions.OnlyOnFaulted); + } + + private async Task SendLoopAsync() + { + Log.Debug("ExposureApi::SendLoopAsync -> Enter"); + while (!_processExit.Task.IsCompleted) { - Log.Debug("ExposureApi::SendLoopAsync -> Enter"); - while (!_processExit.Task.IsCompleted) + try { - try - { - var apiRequestFactory = _apiRequestFactory; - var uri = apiRequestFactory.GetEndpoint(ExposurePath); - var payload = TryGetPayload(); - if (payload.Count != 0) - { - var request = apiRequestFactory.Create(uri); - using var response = await request.PostAsync(payload, MimeTypes.Json).ConfigureAwait(false); - } - } - catch (Exception ex) + var apiRequestFactory = _apiRequestFactory; + var uri = apiRequestFactory.GetEndpoint(ExposurePath); + var payload = TryGetPayload(); + if (payload.Count != 0) { - Log.Error(ex, "Error while sending Feature Flags exposures to the agent"); - } - - try - { - await Task.WhenAny(_processExit.Task, Task.Delay(_sendInterval)).ConfigureAwait(false); - } - catch (OperationCanceledException) - { - // We are shutting down, so don't do anything about it + var request = apiRequestFactory.Create(uri); + using var response = await request.PostAsync(payload, MimeTypes.Json).ConfigureAwait(false); } + } + catch (Exception ex) + { + Log.Error(ex, "Error while sending Feature Flags exposures to the agent"); + } - Log.Debug("ExposureApi::SendLoopAsync -> Exit"); + try + { + await Task.WhenAny(_processExit.Task, Task.Delay(_sendInterval)).ConfigureAwait(false); + } + catch (OperationCanceledException) + { + // We are shutting down, so don't do anything about it } + + Log.Debug("ExposureApi::SendLoopAsync -> Exit"); } + } - private ArraySegment TryGetPayload() + private ArraySegment TryGetPayload() + { + List exposures; + lock (_exposures) { - List exposures; - lock (_exposures) + if (_exposures.Count == 0) { - if (_exposures.Count == 0) - { - // nothing to do, skip send - return default; - } - - exposures = [.. _exposures]; - _exposures.Clear(); + // nothing to do, skip send + return default; } - var request = new ExposuresRequest(_context, exposures); - var json = JsonConvert.SerializeObject(request); - return new ArraySegment(Encoding.UTF8.GetBytes(json)); + exposures = [.. _exposures]; + _exposures.Clear(); } - public void SendExposure(in ExposureEvent exposure) + var request = new ExposuresRequest(_context, exposures); + var json = JsonConvert.SerializeObject(request); + return new ArraySegment(Encoding.UTF8.GetBytes(json)); + } + + public void SendExposure(in ExposureEvent exposure) + { + if (_exposureCache.Add(exposure)) { lock (_exposures) { _exposures.Enqueue(exposure); } - - TryToStartSendLoopIfNotStarted(); } - private sealed class ExposuresRequest(Dictionary context, List exposures) - { - public Dictionary Context { get; } = context; + TryToStartSendLoopIfNotStarted(); + } - public List Exposures { get; } = exposures; - } + private sealed class ExposuresRequest(Dictionary context, List exposures) + { + public Dictionary Context { get; } = context; + + public List Exposures { get; } = exposures; } } diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureCache.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureCache.cs new file mode 100644 index 000000000000..abc63bcb9edd --- /dev/null +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureCache.cs @@ -0,0 +1,120 @@ +// +// 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 System.Collections.Generic; +using Datadog.Trace.FeatureFlags.Exposure.Model; + +namespace Datadog.Trace.FeatureFlags.Exposure; + +/// +/// Esta clase no es thread-safe intencionalmente. +/// La seguridad de hilos se gestiona en el patrón de acceso de un solo hilo. +/// +internal sealed class ExposureCache +{ + private readonly int _capacity; + private readonly Dictionary _cache; + private readonly LinkedList _lruList; + + public ExposureCache(int capacity) + { + _capacity = capacity; + _cache = new Dictionary(capacity); + _lruList = new LinkedList(); + } + + public int Size => _lruList.Count; + + public bool Add(ExposureEvent exposureEvent) + { + lock (_cache) + { + var key = new Key(exposureEvent); + var value = new Value(exposureEvent); + + bool exists = _cache.TryGetValue(key, out var oldValue); + + if (exists) + { + // Update LRU priority (move element to the begining of the queue) + _lruList.Remove(key); + _lruList.AddFirst(key); + + if (oldValue == value) + { + return false; + } + } + + // New key or different value + if (!exists && _cache.Count >= _capacity) + { + RemoveLeastRecentlyUsed(); + } + + _cache[key] = value; + if (!exists) + { + _lruList.AddFirst(key); + } + + return true; + } + } + + public Value? Get(Key key) + { + lock (_cache) + { + if (_cache.TryGetValue(key, out var value)) + { + // Get operation should refresh LRU priority + _lruList.Remove(key); + _lruList.AddFirst(key); + return value; + } + + return null; + } + } + + private void RemoveLeastRecentlyUsed() + { + var last = _lruList.Last; + if (last != null) + { + _cache.Remove(last.Value); + _lruList.RemoveLast(); + } + } + + public sealed record Key + { + public Key(ExposureEvent exposureEvent) + { + Flag = exposureEvent.Flag.Key; + Subject = exposureEvent.Subject.Id; + } + + public string Flag { get; } + + public string Subject { get; } + } + + public sealed record Value + { + public Value(ExposureEvent exposureEvent) + { + Variant = exposureEvent.Variant.Key; + Allocation = exposureEvent.Allocation.Key; + } + + public string Variant { get; } + + public string Allocation { get; } + } +} diff --git a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs index e61fcd2b612d..bb1dda60b2e9 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/FeatureFlagsModule.cs @@ -9,7 +9,7 @@ using System.Collections.Generic; using System.Threading; using Datadog.Trace.Configuration; -using Datadog.Trace.Exposure; +using Datadog.Trace.FeatureFlags.Exposure; using Datadog.Trace.FeatureFlags.Exposure.Model; using Datadog.Trace.FeatureFlags.Rcm; using Datadog.Trace.FeatureFlags.Rcm.Model; diff --git a/tracer/test/Datadog.Trace.Tests/FeatureFlags/ExposureCacheTests.cs b/tracer/test/Datadog.Trace.Tests/FeatureFlags/ExposureCacheTests.cs new file mode 100644 index 000000000000..52d786f5e9a8 --- /dev/null +++ b/tracer/test/Datadog.Trace.Tests/FeatureFlags/ExposureCacheTests.cs @@ -0,0 +1,185 @@ +// +// 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 System.Collections.Generic; +using Datadog.Trace.FeatureFlags; +using Datadog.Trace.FeatureFlags.Exposure; +using Datadog.Trace.FeatureFlags.Exposure.Model; +using Datadog.Trace.FeatureFlags.Rcm.Model; +using Datadog.Trace.TestHelpers; +using Xunit; +using ValueType = Datadog.Trace.FeatureFlags.ValueType; + +namespace Datadog.Trace.Tests.FeatureFlags; + +/// FeatureFlagsEvaluator discrete tests +public partial class ExposureCacheTests +{ + public static IEnumerable Cases() + { + yield return new object?[] + { + 5, + new object[] + { + }, + new bool[] + { + }, + 0 + }; + yield return new object?[] + { + 5, + new object[] + { + CreateEvent("flag", "subject", "variant", "allocation"), + }, + new bool[] + { + true, + }, + 1 + }; + yield return new object?[] + { + 5, + new object[] + { + CreateEvent("flag", "subject", "variant", "allocation"), + CreateEvent("flag", "subject", "variant", "allocation"), + }, + new bool[] + { + true, + false, + }, + 1 + }; + yield return new object?[] + { + 5, + new object[] + { + CreateEvent("flag", "subject", "variant", "allocation"), + CreateEvent("flag", "subject", "variant", "allocation"), + CreateEvent("flag1", "subject", "variant", "allocation"), + CreateEvent("flag1", "subject", "variant", "allocation"), + }, + new bool[] + { + true, + false, + true, + false, + }, + 2 + }; + yield return new object?[] + { + 5, + new object[] + { + CreateEvent("flag", "subject", "variant", "allocation"), + CreateEvent("flag", "subject", "variant1", "allocation"), + }, + new bool[] + { + true, + true, + }, + 1 + }; + yield return new object?[] + { + 5, + new object[] + { + CreateEvent("flag", "subject1", "variant", "allocation"), + CreateEvent("flag", "subject2", "variant", "allocation"), + CreateEvent("flag", "subject3", "variant", "allocation"), + }, + new bool[] + { + true, + true, + true, + }, + 3 + }; + yield return new object?[] + { + 5, + new object[] + { + CreateEvent("flag1", "subject", "variant", "allocation"), + CreateEvent("flag2", "subject", "variant", "allocation"), + CreateEvent("flag3", "subject", "variant", "allocation"), + }, + new bool[] + { + true, + true, + true, + }, + 3 + }; + yield return new object?[] + { + 5, + new object[] + { + CreateEvent("flag1", "subject", "variant", "allocation"), + CreateEvent("flag2", "subject", "variant", "allocation"), + CreateEvent("flag3", "subject", "variant", "allocation"), + CreateEvent("flag4", "subject", "variant", "allocation"), + CreateEvent("flag5", "subject", "variant", "allocation"), + CreateEvent("flag6", "subject", "variant", "allocation"), + CreateEvent("flag7", "subject", "variant", "allocation"), + }, + new bool[] + { + true, + true, + true, + true, + true, + true, + true, + }, + 5 + }; + + static ExposureEvent CreateEvent(string flag, string subject, string variant, string allocation) + { + return new ExposureEvent( + new DateTimeOffset(DateTime.Now).ToUnixTimeMilliseconds(), + new Trace.FeatureFlags.Exposure.Model.Allocation(allocation), + new Trace.FeatureFlags.Exposure.Model.Flag(flag), + new Trace.FeatureFlags.Exposure.Model.Variant(variant), + new Subject(subject, new Dictionary())); + } + } + + [Theory] + [MemberData(nameof(Cases))] + public void ExposureEventsAreAddedOrDiscarded(int capacity, object[] exposureEvents, bool[] expected, int size) + { + var cache = new ExposureCache(capacity); + + Assert.Equal(exposureEvents.Length, expected.Length); + + for (int x = 0; x < exposureEvents.Length; x++) + { + bool added = cache.Add((ExposureEvent)exposureEvents[x]); + Assert.Equal(expected[x], added); + } + + Assert.Equal(size, cache.Size); + } +} From 08cb9944c46286841e1c79ebc2003652a247d55d Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Fri, 9 Jan 2026 15:21:33 +0100 Subject: [PATCH 53/54] Fix typos --- .../src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs | 2 +- .../src/Datadog.Trace/FeatureFlags/Exposure/ExposureCache.cs | 5 +---- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs index 5c433807f766..f6e880dcaa99 100644 --- a/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs +++ b/tracer/src/Datadog.Trace.Manual/FeatureFlags/FeatureFlagsSdk.cs @@ -17,7 +17,7 @@ namespace Datadog.Trace.FeatureFlags; [Browsable(false)] public static class FeatureFlagsSdk { - /// Gets a value indicating wether FeatureFlags framework is available or not + /// Gets a value indicating whether FeatureFlags framework is available or not /// True if FeatureFlagsSDK is instrumented [Instrumented] [MethodImpl(MethodImplOptions.NoInlining)] diff --git a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureCache.cs b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureCache.cs index abc63bcb9edd..a1a1d9815ab1 100644 --- a/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureCache.cs +++ b/tracer/src/Datadog.Trace/FeatureFlags/Exposure/ExposureCache.cs @@ -10,10 +10,7 @@ namespace Datadog.Trace.FeatureFlags.Exposure; -/// -/// Esta clase no es thread-safe intencionalmente. -/// La seguridad de hilos se gestiona en el patrón de acceso de un solo hilo. -/// +/// LRU ExposureEvents cache internal sealed class ExposureCache { private readonly int _capacity; From 688c62cf6edd6c729eaa1da2b2cf713b462c1122 Mon Sep 17 00:00:00 2001 From: Daniel Romano Date: Mon, 12 Jan 2026 15:28:44 +0100 Subject: [PATCH 54/54] Rebase fix --- .../Generated/generated_calltargets.g.cpp | 820 +++++++++--------- 1 file changed, 411 insertions(+), 409 deletions(-) diff --git a/tracer/src/Datadog.Tracer.Native/Generated/generated_calltargets.g.cpp b/tracer/src/Datadog.Tracer.Native/Generated/generated_calltargets.g.cpp index 4d840725f2ab..981cbf169c2e 100644 --- a/tracer/src/Datadog.Tracer.Native/Generated/generated_calltargets.g.cpp +++ b/tracer/src/Datadog.Tracer.Native/Generated/generated_calltargets.g.cpp @@ -279,182 +279,183 @@ WCHAR* sig260[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[HotChocolate.Execut WCHAR* sig261[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.AspNetCore.Identity.IdentityResult]"),(WCHAR*)WStr("!0"),}; WCHAR* sig262[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.AspNetCore.Identity.SignInResult]"),(WCHAR*)WStr("!0"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),}; WCHAR* sig263[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.AspNetCore.Identity.SignInResult]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig264[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Azure.WebJobs.Host.Executors.IDelayedException]"),(WCHAR*)WStr("Microsoft.Azure.WebJobs.Host.Executors.IFunctionInstance"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig265[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Azure.WebJobs.Script.Grpc.Messages.TypedData]"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.HttpRequest"),(WCHAR*)WStr("Microsoft.Extensions.Logging.ILogger"),(WCHAR*)WStr("Microsoft.Azure.WebJobs.Script.Grpc.GrpcCapabilities"),}; -WCHAR* sig266[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Data.SqlClient.SqlDataReader]"),}; -WCHAR* sig267[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Data.SqlClient.SqlDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; -WCHAR* sig268[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Data.SqlClient.SqlDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig269[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Data.SqlClient.SqlDataReader]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig270[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Data.Sqlite.SqliteDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig271[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.VisualStudio.TestTools.UnitTesting.TestResult[]]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodInfo"),}; -WCHAR* sig272[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.VisualStudio.TestTools.UnitTesting.TestResult[]]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.TestMethod"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging.IMessageLogger"),}; -WCHAR* sig273[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.VisualStudio.TestTools.UnitTesting.TestResult[]]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.ITestMethod"),}; -WCHAR* sig274[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[MySql.Data.MySqlClient.MySqlDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; -WCHAR* sig275[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[MySql.Data.MySqlClient.MySqlDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig276[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[MySqlConnector.MySqlDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig277[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[MySqlConnector.MySqlDataReader]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig278[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Npgsql.NpgsqlDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig279[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Oracle.DataAccess.Client.OracleDataReader]"),}; -WCHAR* sig280[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Oracle.DataAccess.Client.OracleDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; -WCHAR* sig281[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Oracle.DataAccess.Client.OracleDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig282[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Oracle.DataAccess.Client.OracleDataReader]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig283[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Oracle.ManagedDataAccess.Client.OracleDataReader]"),}; -WCHAR* sig284[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Oracle.ManagedDataAccess.Client.OracleDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; -WCHAR* sig285[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Oracle.ManagedDataAccess.Client.OracleDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig286[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Oracle.ManagedDataAccess.Client.OracleDataReader]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig287[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[RabbitMQ.Client.BasicGetResult]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig288[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[RabbitMQ.Client.QueueDeclareOk]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig289[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Collections.Generic.IReadOnlyList`1[Azure.Messaging.EventHubs.EventData]]"),(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("System.Nullable`1[System.TimeSpan]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig290[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Collections.Generic.IReadOnlyList`1[Azure.Messaging.ServiceBus.ServiceBusReceivedMessage]]"),(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("System.Nullable`1[System.TimeSpan]"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig291[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Collections.Generic.IReadOnlyList`1[System.Int64]]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Azure.Messaging.ServiceBus.ServiceBusMessage]"),(WCHAR*)WStr("System.DateTimeOffset"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig292[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Data.Common.DbDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig293[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Data.SqlClient.SqlDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig294[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Decimal]"),}; -WCHAR* sig295[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Int32]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig296[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Net.Http.HttpResponseMessage]"),(WCHAR*)WStr("System.Net.Http.HttpRequestMessage"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig297[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Net.Http.HttpResponseMessage]"),(WCHAR*)WStr("System.Web.Http.Controllers.HttpControllerContext"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig298[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Net.Http.HttpResponseMessage]"),(WCHAR*)WStr("System.Web.Http.Controllers.HttpControllerContext"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig299[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Net.Http.HttpResponseMessage]"),(WCHAR*)WStr("System.Web.Http.ExceptionHandling.IExceptionHandler"),(WCHAR*)WStr("System.Web.Http.ExceptionHandling.ExceptionContext"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig300[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Object]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig301[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.String]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("RabbitMQ.Client.IAsyncBasicConsumer"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig302[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Tuple`2[System.Object, System.Object[]]]"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Object[]"),}; -WCHAR* sig303[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Xunit.Sdk.RunSummary]"),}; -WCHAR* sig304[]={(WCHAR*)WStr("System.Threading.Tasks.ValueTask"),(WCHAR*)WStr("RabbitMQ.Client.CachedString"),(WCHAR*)WStr("RabbitMQ.Client.CachedString"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("!!0"),(WCHAR*)WStr("System.ReadOnlyMemory`1[System.Byte]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig305[]={(WCHAR*)WStr("System.Threading.Tasks.ValueTask"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("!!0"),(WCHAR*)WStr("System.ReadOnlyMemory`1[System.Byte]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig306[]={(WCHAR*)WStr("System.Threading.Tasks.ValueTask`1[System.TimeSpan]"),(WCHAR*)WStr("_"),}; -WCHAR* sig307[]={(WCHAR*)WStr("System.Threading.Tasks.ValueTask`1[Xunit.v3.RunSummary]"),(WCHAR*)WStr("!0"),}; -WCHAR* sig308[]={(WCHAR*)WStr("System.Threading.Tasks.ValueTask`1[Xunit.v3.RunSummary]"),(WCHAR*)WStr("!0"),(WCHAR*)WStr("!2"),}; -WCHAR* sig309[]={(WCHAR*)WStr("System.Uri"),}; -WCHAR* sig310[]={(WCHAR*)WStr("System.Void"),}; -WCHAR* sig311[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("!!0"),(WCHAR*)WStr("System.Action`3[!!0,System.String,System.String]"),(WCHAR*)WStr("Datadog.Trace.ISpanContext"),}; -WCHAR* sig312[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("!!0"),(WCHAR*)WStr("System.Action`3[!!0,System.String,System.String]"),(WCHAR*)WStr("Datadog.Trace.ISpanContext"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),}; -WCHAR* sig313[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Amazon.Lambda.RuntimeSupport.LambdaBootstrapHandler"),}; -WCHAR* sig314[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Confluent.Kafka.ConsumerBuilder`2[!0,!1]"),}; -WCHAR* sig315[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Confluent.Kafka.ProducerBuilder`2[!0,!1]"),}; -WCHAR* sig316[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Confluent.Kafka.TopicPartition"),(WCHAR*)WStr("Confluent.Kafka.Message`2[!0,!1]"),(WCHAR*)WStr("System.Action`1[Confluent.Kafka.DeliveryReport`2[!0,!1]]"),}; -WCHAR* sig317[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Datadog.Trace.Ci.ITest"),(WCHAR*)WStr("Datadog.Trace.Ci.BenchmarkHostInfo&"),(WCHAR*)WStr("Datadog.Trace.Ci.BenchmarkJobInfo&"),}; -WCHAR* sig318[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Datadog.Trace.Ci.ITest"),(WCHAR*)WStr("Datadog.Trace.Ci.BenchmarkMeasureType"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.Ci.BenchmarkDiscreteStats&"),}; -WCHAR* sig319[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Datadog.Trace.Ci.ITest"),(WCHAR*)WStr("Datadog.Trace.Ci.TestParameters"),}; -WCHAR* sig320[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Datadog.Trace.ISpan"),(WCHAR*)WStr("Datadog.Trace.SamplingPriority"),}; -WCHAR* sig321[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Datadog.Trace.ISpan"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),}; -WCHAR* sig322[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Google.Protobuf.CodedInputStream"),}; -WCHAR* sig323[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Google.Protobuf.CodedOutputStream"),}; -WCHAR* sig324[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Google.Protobuf.ParseContext&"),}; -WCHAR* sig325[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Google.Protobuf.WriteContext&"),}; -WCHAR* sig326[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("IBM.WMQ.MQMessage"),(WCHAR*)WStr("IBM.WMQ.MQGetMessageOptions"),(WCHAR*)WStr("System.Int32"),}; -WCHAR* sig327[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("IBM.WMQ.MQMessage"),(WCHAR*)WStr("IBM.WMQ.MQPutMessageOptions"),}; -WCHAR* sig328[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.RequestDelegate"),}; -WCHAR* sig329[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.HttpResponse"),(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("Grpc.Core.StatusCode"),(WCHAR*)WStr("System.String"),}; -WCHAR* sig330[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.ModelBinding.ModelBindingResult"),}; -WCHAR* sig331[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestContext"),}; -WCHAR* sig332[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestContext"),(WCHAR*)WStr("_"),}; -WCHAR* sig333[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("MongoDB.Driver.Core.Connections.IConnection"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; -WCHAR* sig334[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("NLog.Config.LoggingConfiguration"),}; -WCHAR* sig335[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("NUnit.Framework.Internal.TestMethod"),(WCHAR*)WStr("NUnit.Framework.Interfaces.ITestFilter"),}; -WCHAR* sig336[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("NUnit.Framework.Internal.TestMethod"),(WCHAR*)WStr("NUnit.Framework.Interfaces.ITestFilter"),(WCHAR*)WStr("NUnit.Framework.Internal.Abstractions.IDebugger"),}; -WCHAR* sig337[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("OpenQA.Selenium.Remote.SendingRemoteHttpRequestEventArgs"),}; -WCHAR* sig338[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Serilog.Events.LogEvent"),}; -WCHAR* sig339[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Action"),}; -WCHAR* sig340[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Action`2[System.Object,!!0]"),(WCHAR*)WStr("!!0"),}; -WCHAR* sig341[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig342[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Grpc.Core.Internal.ClientSideStatus"),}; -WCHAR* sig343[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Grpc.Core.Internal.ClientSideStatus"),(WCHAR*)WStr("Grpc.Core.Internal.IBufferReader"),(WCHAR*)WStr("Grpc.Core.Metadata"),}; -WCHAR* sig344[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.Dictionary`2[System.String,System.Object]"),}; -WCHAR* sig345[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.Dictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig346[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.ICollection`1[System.Reflection.MethodInfo]"),(WCHAR*)WStr("System.Func`1[System.IDisposable]"),}; -WCHAR* sig347[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String&"),(WCHAR*)WStr("System.String&"),}; -WCHAR* sig348[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; -WCHAR* sig349[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Confluent.Kafka.TopicPartitionOffset]"),}; -WCHAR* sig350[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),}; -WCHAR* sig351[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),}; -WCHAR* sig352[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.IExternalScopeProvider"),}; -WCHAR* sig353[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.ILogEnricher]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.IStaticLogEnricher]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggingSampler"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.IExternalScopeProvider"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerEnrichmentOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerRedactionOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Compliance.Redaction.IRedactorProvider"),}; -WCHAR* sig354[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.ILogEnricher]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.IStaticLogEnricher]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggingSampler"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.IExternalScopeProvider"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerEnrichmentOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerRedactionOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Compliance.Redaction.IRedactorProvider"),(WCHAR*)WStr("Microsoft.Extensions.Diagnostics.Buffering.LogBuffer"),}; -WCHAR* sig355[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.ILogEnricher]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.IStaticLogEnricher]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.IExternalScopeProvider"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerEnrichmentOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerRedactionOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Compliance.Redaction.IRedactorProvider"),}; -WCHAR* sig356[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.UnitTestElement]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter.ITestCaseDiscoverySink"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter.IDiscoveryContext"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging.IMessageLogger"),}; -WCHAR* sig357[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[System.String]"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),}; -WCHAR* sig358[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[System.String]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[System.String]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[System.String]"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),}; -WCHAR* sig359[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Exception"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig360[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Net.Http.HttpRequestMessage"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Diagnostics.Activity"),(WCHAR*)WStr("Grpc.Core.Status"),}; -WCHAR* sig361[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Net.Http.HttpRequestMessage"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Diagnostics.Activity"),(WCHAR*)WStr("System.Nullable`1[Grpc.Core.Status]"),}; -WCHAR* sig362[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Net.HttpWebResponse"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; -WCHAR* sig363[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Net.WebException"),(WCHAR*)WStr("System.Net.HttpWebResponse&"),}; -WCHAR* sig364[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Collections.Generic.Dictionary`2[System.String,System.Object]"),}; -WCHAR* sig365[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Messaging.MessageQueueTransaction"),(WCHAR*)WStr("System.Messaging.MessageQueueTransactionType"),}; -WCHAR* sig366[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.IServerResponseChannelSinkStack"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; -WCHAR* sig367[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.IServerResponseChannelSinkStack"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; -WCHAR* sig368[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders"),(WCHAR*)WStr("System.IO.Stream"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; -WCHAR* sig369[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.MessageRpc&"),}; -WCHAR* sig370[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.MessageRpc&"),(WCHAR*)WStr("System.Exception&"),(WCHAR*)WStr("System.Boolean&"),}; -WCHAR* sig371[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),}; -WCHAR* sig372[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("!0"),(WCHAR*)WStr("!1"),(WCHAR*)WStr("System.Action`1[Confluent.Kafka.DeliveryReport`2[!0,!1]]"),}; -WCHAR* sig373[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.UserDetails"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; -WCHAR* sig374[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("NLog.Config.LoggingConfiguration"),}; -WCHAR* sig375[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),}; -WCHAR* sig376[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Datadog.Trace.UserDetails"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; -WCHAR* sig377[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; -WCHAR* sig378[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; -WCHAR* sig379[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; -WCHAR* sig380[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; -WCHAR* sig381[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.UnitTestElement]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter.ITestCaseDiscoverySink"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter.IDiscoveryContext"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging.IMessageLogger"),}; -WCHAR* sig382[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("RabbitMQ.Client.IBasicProperties"),(WCHAR*)WStr("_"),}; -WCHAR* sig383[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; -WCHAR* sig384[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; -WCHAR* sig385[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; -WCHAR* sig386[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.UInt64"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("RabbitMQ.Client.IBasicProperties"),(WCHAR*)WStr("_"),}; -WCHAR* sig387[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.TimeSpan"),}; -WCHAR* sig388[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Type"),(WCHAR*)WStr("NLog.Internal.TargetWithFilterChain"),(WCHAR*)WStr("NLog.LogEventInfo"),(WCHAR*)WStr("NLog.LogFactory"),}; -WCHAR* sig389[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Xunit.v3.IXunitTestMethod"),(WCHAR*)WStr("System.Collections.Generic.IReadOnlyCollection`1[Xunit.v3.IXunitTestCase]"),(WCHAR*)WStr("Xunit.Sdk.ExplicitOption"),(WCHAR*)WStr("Xunit.v3.IMessageBus"),(WCHAR*)WStr("Xunit.v3.ExceptionAggregator"),(WCHAR*)WStr("System.Threading.CancellationTokenSource"),(WCHAR*)WStr("System.Object[]"),}; -WCHAR* sig390[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Yarp.ReverseProxy.Forwarder.ForwarderHttpClientContext"),(WCHAR*)WStr("System.Net.Http.SocketsHttpHandler"),}; -WCHAR* sig391[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("_"),}; -WCHAR* sig392[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("_"),(WCHAR*)WStr("_"),}; -WCHAR* sig393[]={(WCHAR*)WStr("System.Web.Mvc.ActionResult"),(WCHAR*)WStr("System.Web.Mvc.ControllerContext"),(WCHAR*)WStr("System.Web.Mvc.ActionDescriptor"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; -WCHAR* sig394[]={(WCHAR*)WStr("_"),(WCHAR*)WStr("_"),}; -WCHAR* sig395[]={(WCHAR*)WStr("_"),(WCHAR*)WStr("_"),(WCHAR*)WStr("_"),}; +WCHAR* sig264[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Azure.Cosmos.ResponseMessage]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Microsoft.Azure.Documents.ResourceType"),(WCHAR*)WStr("Microsoft.Azure.Documents.OperationType"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.RequestOptions"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.ContainerInternal"),(WCHAR*)WStr("_"),(WCHAR*)WStr("System.IO.Stream"),(WCHAR*)WStr("System.Action`1[Microsoft.Azure.Cosmos.RequestMessage]"),(WCHAR*)WStr("_"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig265[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Azure.WebJobs.Host.Executors.IDelayedException]"),(WCHAR*)WStr("Microsoft.Azure.WebJobs.Host.Executors.IFunctionInstance"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig266[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Azure.WebJobs.Script.Grpc.Messages.TypedData]"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.HttpRequest"),(WCHAR*)WStr("Microsoft.Extensions.Logging.ILogger"),(WCHAR*)WStr("Microsoft.Azure.WebJobs.Script.Grpc.GrpcCapabilities"),}; +WCHAR* sig267[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Data.SqlClient.SqlDataReader]"),}; +WCHAR* sig268[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Data.SqlClient.SqlDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; +WCHAR* sig269[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Data.SqlClient.SqlDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig270[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Data.SqlClient.SqlDataReader]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig271[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.Data.Sqlite.SqliteDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig272[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.VisualStudio.TestTools.UnitTesting.TestResult[]]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodInfo"),}; +WCHAR* sig273[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.VisualStudio.TestTools.UnitTesting.TestResult[]]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.TestMethod"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging.IMessageLogger"),}; +WCHAR* sig274[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Microsoft.VisualStudio.TestTools.UnitTesting.TestResult[]]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.ITestMethod"),}; +WCHAR* sig275[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[MySql.Data.MySqlClient.MySqlDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; +WCHAR* sig276[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[MySql.Data.MySqlClient.MySqlDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig277[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[MySqlConnector.MySqlDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig278[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[MySqlConnector.MySqlDataReader]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig279[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Npgsql.NpgsqlDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig280[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Oracle.DataAccess.Client.OracleDataReader]"),}; +WCHAR* sig281[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Oracle.DataAccess.Client.OracleDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; +WCHAR* sig282[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Oracle.DataAccess.Client.OracleDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig283[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Oracle.DataAccess.Client.OracleDataReader]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig284[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Oracle.ManagedDataAccess.Client.OracleDataReader]"),}; +WCHAR* sig285[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Oracle.ManagedDataAccess.Client.OracleDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),}; +WCHAR* sig286[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Oracle.ManagedDataAccess.Client.OracleDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig287[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Oracle.ManagedDataAccess.Client.OracleDataReader]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig288[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[RabbitMQ.Client.BasicGetResult]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig289[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[RabbitMQ.Client.QueueDeclareOk]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig290[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Collections.Generic.IReadOnlyList`1[Azure.Messaging.EventHubs.EventData]]"),(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("System.Nullable`1[System.TimeSpan]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig291[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Collections.Generic.IReadOnlyList`1[Azure.Messaging.ServiceBus.ServiceBusReceivedMessage]]"),(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("System.Nullable`1[System.TimeSpan]"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig292[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Collections.Generic.IReadOnlyList`1[System.Int64]]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Azure.Messaging.ServiceBus.ServiceBusMessage]"),(WCHAR*)WStr("System.DateTimeOffset"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig293[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Data.Common.DbDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig294[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Data.SqlClient.SqlDataReader]"),(WCHAR*)WStr("System.Data.CommandBehavior"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig295[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Decimal]"),}; +WCHAR* sig296[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Int32]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig297[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Net.Http.HttpResponseMessage]"),(WCHAR*)WStr("System.Net.Http.HttpRequestMessage"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig298[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Net.Http.HttpResponseMessage]"),(WCHAR*)WStr("System.Web.Http.Controllers.HttpControllerContext"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig299[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Net.Http.HttpResponseMessage]"),(WCHAR*)WStr("System.Web.Http.Controllers.HttpControllerContext"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig300[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Net.Http.HttpResponseMessage]"),(WCHAR*)WStr("System.Web.Http.ExceptionHandling.IExceptionHandler"),(WCHAR*)WStr("System.Web.Http.ExceptionHandling.ExceptionContext"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig301[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Object]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig302[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.String]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("RabbitMQ.Client.IAsyncBasicConsumer"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig303[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[System.Tuple`2[System.Object, System.Object[]]]"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Object[]"),}; +WCHAR* sig304[]={(WCHAR*)WStr("System.Threading.Tasks.Task`1[Xunit.Sdk.RunSummary]"),}; +WCHAR* sig305[]={(WCHAR*)WStr("System.Threading.Tasks.ValueTask"),(WCHAR*)WStr("RabbitMQ.Client.CachedString"),(WCHAR*)WStr("RabbitMQ.Client.CachedString"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("!!0"),(WCHAR*)WStr("System.ReadOnlyMemory`1[System.Byte]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig306[]={(WCHAR*)WStr("System.Threading.Tasks.ValueTask"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("!!0"),(WCHAR*)WStr("System.ReadOnlyMemory`1[System.Byte]"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig307[]={(WCHAR*)WStr("System.Threading.Tasks.ValueTask`1[System.TimeSpan]"),(WCHAR*)WStr("_"),}; +WCHAR* sig308[]={(WCHAR*)WStr("System.Threading.Tasks.ValueTask`1[Xunit.v3.RunSummary]"),(WCHAR*)WStr("!0"),}; +WCHAR* sig309[]={(WCHAR*)WStr("System.Threading.Tasks.ValueTask`1[Xunit.v3.RunSummary]"),(WCHAR*)WStr("!0"),(WCHAR*)WStr("!2"),}; +WCHAR* sig310[]={(WCHAR*)WStr("System.Uri"),}; +WCHAR* sig311[]={(WCHAR*)WStr("System.Void"),}; +WCHAR* sig312[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("!!0"),(WCHAR*)WStr("System.Action`3[!!0,System.String,System.String]"),(WCHAR*)WStr("Datadog.Trace.ISpanContext"),}; +WCHAR* sig313[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("!!0"),(WCHAR*)WStr("System.Action`3[!!0,System.String,System.String]"),(WCHAR*)WStr("Datadog.Trace.ISpanContext"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),}; +WCHAR* sig314[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Amazon.Lambda.RuntimeSupport.LambdaBootstrapHandler"),}; +WCHAR* sig315[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Confluent.Kafka.ConsumerBuilder`2[!0,!1]"),}; +WCHAR* sig316[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Confluent.Kafka.ProducerBuilder`2[!0,!1]"),}; +WCHAR* sig317[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Confluent.Kafka.TopicPartition"),(WCHAR*)WStr("Confluent.Kafka.Message`2[!0,!1]"),(WCHAR*)WStr("System.Action`1[Confluent.Kafka.DeliveryReport`2[!0,!1]]"),}; +WCHAR* sig318[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Datadog.Trace.Ci.ITest"),(WCHAR*)WStr("Datadog.Trace.Ci.BenchmarkHostInfo&"),(WCHAR*)WStr("Datadog.Trace.Ci.BenchmarkJobInfo&"),}; +WCHAR* sig319[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Datadog.Trace.Ci.ITest"),(WCHAR*)WStr("Datadog.Trace.Ci.BenchmarkMeasureType"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.Ci.BenchmarkDiscreteStats&"),}; +WCHAR* sig320[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Datadog.Trace.Ci.ITest"),(WCHAR*)WStr("Datadog.Trace.Ci.TestParameters"),}; +WCHAR* sig321[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Datadog.Trace.ISpan"),(WCHAR*)WStr("Datadog.Trace.SamplingPriority"),}; +WCHAR* sig322[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Datadog.Trace.ISpan"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),}; +WCHAR* sig323[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Google.Protobuf.CodedInputStream"),}; +WCHAR* sig324[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Google.Protobuf.CodedOutputStream"),}; +WCHAR* sig325[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Google.Protobuf.ParseContext&"),}; +WCHAR* sig326[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Google.Protobuf.WriteContext&"),}; +WCHAR* sig327[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("IBM.WMQ.MQMessage"),(WCHAR*)WStr("IBM.WMQ.MQGetMessageOptions"),(WCHAR*)WStr("System.Int32"),}; +WCHAR* sig328[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("IBM.WMQ.MQMessage"),(WCHAR*)WStr("IBM.WMQ.MQPutMessageOptions"),}; +WCHAR* sig329[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.IApplicationBuilder"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.RequestDelegate"),}; +WCHAR* sig330[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.HttpResponse"),(WCHAR*)WStr("System.Int32"),(WCHAR*)WStr("Grpc.Core.StatusCode"),(WCHAR*)WStr("System.String"),}; +WCHAR* sig331[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.ModelBinding.ModelBindingResult"),}; +WCHAR* sig332[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestContext"),}; +WCHAR* sig333[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestContext"),(WCHAR*)WStr("_"),}; +WCHAR* sig334[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("MongoDB.Driver.Core.Connections.IConnection"),(WCHAR*)WStr("System.Threading.CancellationToken"),}; +WCHAR* sig335[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("NLog.Config.LoggingConfiguration"),}; +WCHAR* sig336[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("NUnit.Framework.Internal.TestMethod"),(WCHAR*)WStr("NUnit.Framework.Interfaces.ITestFilter"),}; +WCHAR* sig337[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("NUnit.Framework.Internal.TestMethod"),(WCHAR*)WStr("NUnit.Framework.Interfaces.ITestFilter"),(WCHAR*)WStr("NUnit.Framework.Internal.Abstractions.IDebugger"),}; +WCHAR* sig338[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("OpenQA.Selenium.Remote.SendingRemoteHttpRequestEventArgs"),}; +WCHAR* sig339[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Serilog.Events.LogEvent"),}; +WCHAR* sig340[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Action"),}; +WCHAR* sig341[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Action`2[System.Object,!!0]"),(WCHAR*)WStr("!!0"),}; +WCHAR* sig342[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Boolean"),}; +WCHAR* sig343[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Grpc.Core.Internal.ClientSideStatus"),}; +WCHAR* sig344[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Grpc.Core.Internal.ClientSideStatus"),(WCHAR*)WStr("Grpc.Core.Internal.IBufferReader"),(WCHAR*)WStr("Grpc.Core.Metadata"),}; +WCHAR* sig345[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.Dictionary`2[System.String,System.Object]"),}; +WCHAR* sig346[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.Dictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.Boolean"),}; +WCHAR* sig347[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.ICollection`1[System.Reflection.MethodInfo]"),(WCHAR*)WStr("System.Func`1[System.IDisposable]"),}; +WCHAR* sig348[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String&"),(WCHAR*)WStr("System.String&"),}; +WCHAR* sig349[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; +WCHAR* sig350[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Confluent.Kafka.TopicPartitionOffset]"),}; +WCHAR* sig351[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),}; +WCHAR* sig352[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),}; +WCHAR* sig353[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.IExternalScopeProvider"),}; +WCHAR* sig354[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.ILogEnricher]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.IStaticLogEnricher]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggingSampler"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.IExternalScopeProvider"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerEnrichmentOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerRedactionOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Compliance.Redaction.IRedactorProvider"),}; +WCHAR* sig355[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.ILogEnricher]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.IStaticLogEnricher]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggingSampler"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.IExternalScopeProvider"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerEnrichmentOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerRedactionOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Compliance.Redaction.IRedactorProvider"),(WCHAR*)WStr("Microsoft.Extensions.Diagnostics.Buffering.LogBuffer"),}; +WCHAR* sig356[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Logging.ILoggerProvider]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.ILogEnricher]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.Extensions.Diagnostics.Enrichment.IStaticLogEnricher]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerFilterOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptions`1[Microsoft.Extensions.Logging.LoggerFactoryOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Logging.IExternalScopeProvider"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerEnrichmentOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Options.IOptionsMonitor`1[Microsoft.Extensions.Logging.LoggerRedactionOptions]"),(WCHAR*)WStr("Microsoft.Extensions.Compliance.Redaction.IRedactorProvider"),}; +WCHAR* sig357[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.UnitTestElement]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter.ITestCaseDiscoverySink"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter.IDiscoveryContext"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging.IMessageLogger"),}; +WCHAR* sig358[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[System.String]"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),}; +WCHAR* sig359[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[System.String]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[System.String]"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[System.String]"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),}; +WCHAR* sig360[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Exception"),(WCHAR*)WStr("System.Boolean"),}; +WCHAR* sig361[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Net.Http.HttpRequestMessage"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Diagnostics.Activity"),(WCHAR*)WStr("Grpc.Core.Status"),}; +WCHAR* sig362[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Net.Http.HttpRequestMessage"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Diagnostics.Activity"),(WCHAR*)WStr("System.Nullable`1[Grpc.Core.Status]"),}; +WCHAR* sig363[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Net.HttpWebResponse"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; +WCHAR* sig364[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Net.WebException"),(WCHAR*)WStr("System.Net.HttpWebResponse&"),}; +WCHAR* sig365[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Collections.Generic.Dictionary`2[System.String,System.Object]"),}; +WCHAR* sig366[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Object"),(WCHAR*)WStr("System.Messaging.MessageQueueTransaction"),(WCHAR*)WStr("System.Messaging.MessageQueueTransactionType"),}; +WCHAR* sig367[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.IServerResponseChannelSinkStack"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; +WCHAR* sig368[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.IServerResponseChannelSinkStack"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; +WCHAR* sig369[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Runtime.Remoting.Messaging.IMessage"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders"),(WCHAR*)WStr("System.IO.Stream"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.ITransportHeaders&"),(WCHAR*)WStr("System.IO.Stream&"),}; +WCHAR* sig370[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.MessageRpc&"),}; +WCHAR* sig371[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.MessageRpc&"),(WCHAR*)WStr("System.Exception&"),(WCHAR*)WStr("System.Boolean&"),}; +WCHAR* sig372[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),}; +WCHAR* sig373[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("!0"),(WCHAR*)WStr("!1"),(WCHAR*)WStr("System.Action`1[Confluent.Kafka.DeliveryReport`2[!0,!1]]"),}; +WCHAR* sig374[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("Datadog.Trace.UserDetails"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; +WCHAR* sig375[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("NLog.Config.LoggingConfiguration"),}; +WCHAR* sig376[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),}; +WCHAR* sig377[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("Datadog.Trace.UserDetails"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; +WCHAR* sig378[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; +WCHAR* sig379[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; +WCHAR* sig380[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; +WCHAR* sig381[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; +WCHAR* sig382[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IEnumerable`1[Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.UnitTestElement]"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter.ITestCaseDiscoverySink"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter.IDiscoveryContext"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging.IMessageLogger"),}; +WCHAR* sig383[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("RabbitMQ.Client.IBasicProperties"),(WCHAR*)WStr("_"),}; +WCHAR* sig384[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; +WCHAR* sig385[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.String]"),}; +WCHAR* sig386[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; +WCHAR* sig387[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.UInt64"),(WCHAR*)WStr("System.Boolean"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("System.String"),(WCHAR*)WStr("RabbitMQ.Client.IBasicProperties"),(WCHAR*)WStr("_"),}; +WCHAR* sig388[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.TimeSpan"),}; +WCHAR* sig389[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("System.Type"),(WCHAR*)WStr("NLog.Internal.TargetWithFilterChain"),(WCHAR*)WStr("NLog.LogEventInfo"),(WCHAR*)WStr("NLog.LogFactory"),}; +WCHAR* sig390[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Xunit.v3.IXunitTestMethod"),(WCHAR*)WStr("System.Collections.Generic.IReadOnlyCollection`1[Xunit.v3.IXunitTestCase]"),(WCHAR*)WStr("Xunit.Sdk.ExplicitOption"),(WCHAR*)WStr("Xunit.v3.IMessageBus"),(WCHAR*)WStr("Xunit.v3.ExceptionAggregator"),(WCHAR*)WStr("System.Threading.CancellationTokenSource"),(WCHAR*)WStr("System.Object[]"),}; +WCHAR* sig391[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("Yarp.ReverseProxy.Forwarder.ForwarderHttpClientContext"),(WCHAR*)WStr("System.Net.Http.SocketsHttpHandler"),}; +WCHAR* sig392[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("_"),}; +WCHAR* sig393[]={(WCHAR*)WStr("System.Void"),(WCHAR*)WStr("_"),(WCHAR*)WStr("_"),}; +WCHAR* sig394[]={(WCHAR*)WStr("System.Web.Mvc.ActionResult"),(WCHAR*)WStr("System.Web.Mvc.ControllerContext"),(WCHAR*)WStr("System.Web.Mvc.ActionDescriptor"),(WCHAR*)WStr("System.Collections.Generic.IDictionary`2[System.String,System.Object]"),}; +WCHAR* sig395[]={(WCHAR*)WStr("_"),(WCHAR*)WStr("_"),}; +WCHAR* sig396[]={(WCHAR*)WStr("_"),(WCHAR*)WStr("_"),(WCHAR*)WStr("_"),}; std::vector callTargets = { {(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Close"),sig310,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Close"),sig311,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetString"),sig169,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Read"),sig121,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("netstandard"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("ReadAsync"),sig301,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig293,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig296,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Close"),sig310,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Close"),sig310,1,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig301,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Close"),sig311,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Close"),sig311,1,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetString"),sig169,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetString"),sig169,2,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Read"),sig121,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Read"),sig121,1,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("ReadAsync"),sig301,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("ReadAsync"),sig301,2,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig293,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig296,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Close"),sig310,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig301,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Close"),sig311,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetString"),sig169,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("Read"),sig121,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("AerospikeClient"),(WCHAR*)WStr("Aerospike.Client.AsyncCommand"),(WCHAR*)WStr("ExecuteCommand"),sig310,1,4,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Aerospike.AsyncCommandIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("AerospikeClient"),(WCHAR*)WStr("Aerospike.Client.SyncCommand"),(WCHAR*)WStr("ExecuteCommand"),sig310,1,4,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Aerospike.SyncCommandIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.Common"),(WCHAR*)WStr("System.Data.Common.DbDataReader"),(WCHAR*)WStr("ReadAsync"),sig301,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("AerospikeClient"),(WCHAR*)WStr("Aerospike.Client.AsyncCommand"),(WCHAR*)WStr("ExecuteCommand"),sig311,1,4,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Aerospike.AsyncCommandIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("AerospikeClient"),(WCHAR*)WStr("Aerospike.Client.SyncCommand"),(WCHAR*)WStr("ExecuteCommand"),sig311,1,4,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Aerospike.SyncCommandIntegration"),CallTargetKind::Default,1,15}, #if _WIN32 -{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.Compilation.BuildManager"),(WCHAR*)WStr("InvokePreStartInitMethodsCore"),sig346,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.HttpModule_Integration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.ThreadContext"),(WCHAR*)WStr("AssociateWithCurrentThread"),sig341,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ThreadContext_AssociateWithCurrentThread_Integration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.ThreadContext"),(WCHAR*)WStr("DisassociateFromCurrentThread"),sig310,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ThreadContext_DisassociateFromCurrentThread_Integration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.Compilation.BuildManager"),(WCHAR*)WStr("InvokePreStartInitMethodsCore"),sig347,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.HttpModule_Integration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.ThreadContext"),(WCHAR*)WStr("AssociateWithCurrentThread"),sig342,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ThreadContext_AssociateWithCurrentThread_Integration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.ThreadContext"),(WCHAR*)WStr("DisassociateFromCurrentThread"),sig311,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ThreadContext_DisassociateFromCurrentThread_Integration"),CallTargetKind::Default,1,1}, #endif {(WCHAR*)WStr("Microsoft.AspNetCore.Authentication.Abstractions"),(WCHAR*)WStr("Microsoft.AspNetCore.Authentication.AuthenticationHttpContextExtensions"),(WCHAR*)WStr("SignInAsync"),sig194,5,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.AuthenticationHttpContextExtensionsIntegration"),CallTargetKind::Default,1,14}, {(WCHAR*)WStr("Microsoft.AspNetCore.Http"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.ApplicationBuilder"),(WCHAR*)WStr("Build"),sig079,1,3,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.AspNetCoreBlockMiddlewareIntegrationEnd"),CallTargetKind::Default,1,14}, @@ -462,19 +463,19 @@ std::vector callTargets = {(WCHAR*)WStr("Microsoft.AspNetCore.Http"),(WCHAR*)WStr("Microsoft.AspNetCore.Http.DefaultHttpContext"),(WCHAR*)WStr("set_User"),sig202,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.HttpContextSetUser"),CallTargetKind::Default,2,14}, {(WCHAR*)WStr("Microsoft.AspNetCore.Http.Abstractions"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.MapExtensions"),(WCHAR*)WStr("Map"),sig077,4,2,2,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.EndpointsCollection.MapExtensionsMapIntegrationV2V3"),CallTargetKind::Default,1,14}, {(WCHAR*)WStr("Microsoft.AspNetCore.Http.Abstractions"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.MapExtensions"),(WCHAR*)WStr("Map"),sig078,5,5,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.EndpointsCollection.MapExtensionsMapIntegrationV5Plus"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Http.Abstractions"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.RunExtensions"),(WCHAR*)WStr("Run"),sig328,3,2,2,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.EndpointsCollection.RunExtensionsRunIntegration"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Http.Abstractions"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.RunExtensions"),(WCHAR*)WStr("Run"),sig329,3,2,2,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.EndpointsCollection.RunExtensionsRunIntegration"),CallTargetKind::Default,1,14}, {(WCHAR*)WStr("Microsoft.AspNetCore.Identity"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.SignInManager`1"),(WCHAR*)WStr("PasswordSignInAsync"),sig263,5,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.SignInManagerPasswordSignInIntegration"),CallTargetKind::Default,2,14}, {(WCHAR*)WStr("Microsoft.AspNetCore.Identity"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.SignInManager`1"),(WCHAR*)WStr("PasswordSignInAsync"),sig263,5,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.SignInManagerPasswordSignInIntegration"),CallTargetKind::Derived,2,14}, {(WCHAR*)WStr("Microsoft.AspNetCore.Identity"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.SignInManager`1"),(WCHAR*)WStr("PasswordSignInAsync"),sig262,5,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.SignInManagerPasswordSignInUserIntegration"),CallTargetKind::Default,2,14}, {(WCHAR*)WStr("Microsoft.AspNetCore.Identity"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.SignInManager`1"),(WCHAR*)WStr("PasswordSignInAsync"),sig263,5,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.SignInManagerPasswordSignInUserIntegration"),CallTargetKind::Derived,2,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.ModelBinding.DefaultModelBindingContext"),(WCHAR*)WStr("set_Result"),sig330,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.DefaultModelBindingContext_SetResult_Integration"),CallTargetKind::Default,6,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.ModelBinding.DefaultModelBindingContext"),(WCHAR*)WStr("set_Result"),sig330,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.DefaultModelBindingContext_SetResult_Integration"),CallTargetKind::Derived,6,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.MvcOptions"),(WCHAR*)WStr(".ctor"),sig310,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.MvcOptionsIntegration"),CallTargetKind::Default,2,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.ModelBinding.DefaultModelBindingContext"),(WCHAR*)WStr("set_Result"),sig331,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.DefaultModelBindingContext_SetResult_Integration"),CallTargetKind::Default,6,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.ModelBinding.DefaultModelBindingContext"),(WCHAR*)WStr("set_Result"),sig331,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.DefaultModelBindingContext_SetResult_Integration"),CallTargetKind::Derived,6,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Mvc.MvcOptions"),(WCHAR*)WStr(".ctor"),sig311,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.MvcOptionsIntegration"),CallTargetKind::Default,2,14}, {(WCHAR*)WStr("Microsoft.AspNetCore.Server.IIS"),(WCHAR*)WStr("Microsoft.AspNetCore.Server.IIS.Core.IISHttpContext"),(WCHAR*)WStr("FireOnStarting"),sig175,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.FireOnStartCommon"),CallTargetKind::Default,6,14}, {(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http.HttpProtocol"),(WCHAR*)WStr("FireOnStarting"),sig175,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.FireOnStartCommon"),CallTargetKind::Default,6,14}, {(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core.KestrelServer"),(WCHAR*)WStr("StartAsync"),sig191,3,2,2,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.EndpointsCollection.KestrelServerImplStartAsyncIntegration"),CallTargetKind::Default,1,14}, {(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Server.Kestrel.Core.KestrelServerImpl"),(WCHAR*)WStr("StartAsync"),sig191,3,5,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.EndpointsCollection.KestrelServerImplStartAsyncIntegration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Session"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.SessionOptions"),(WCHAR*)WStr("set_IdleTimeout"),sig387,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.Session.SessionOptionsIdleTimeoutIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Session"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.SessionOptions"),(WCHAR*)WStr("set_IdleTimeout"),sig388,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.Session.SessionOptionsIdleTimeoutIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Microsoft.AspNetCore.StaticFiles"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.DirectoryBrowserExtensions"),(WCHAR*)WStr("UseDirectoryBrowser"),sig075,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.StaticFiles.DirectoryBrowserExtensionsUseDirectoryBrowserIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.AspNetCore.StaticFiles"),(WCHAR*)WStr("Microsoft.AspNetCore.Builder.DirectoryBrowserExtensions"),(WCHAR*)WStr("UseDirectoryBrowser"),sig076,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.StaticFiles.DirectoryBrowserExtensionsUseDirectoryBrowserIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Extensions.Identity.Core"),(WCHAR*)WStr("Microsoft.AspNetCore.Identity.UserManager`1"),(WCHAR*)WStr("CreateAsync"),sig261,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.UserEvents.UserManagerCreateIntegration"),CallTargetKind::Default,2,14}, @@ -482,10 +483,10 @@ std::vector callTargets = #if _WIN32 {(WCHAR*)WStr("System.Web.Mvc"),(WCHAR*)WStr("System.Web.Mvc.Async.AsyncControllerActionInvoker"),(WCHAR*)WStr("BeginInvokeAction"),sig145,5,4,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.AsyncControllerActionInvoker_BeginInvokeAction_Integration"),CallTargetKind::Default,1,1}, {(WCHAR*)WStr("System.Web.Mvc"),(WCHAR*)WStr("System.Web.Mvc.Async.AsyncControllerActionInvoker"),(WCHAR*)WStr("EndInvokeAction"),sig124,2,4,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.AsyncControllerActionInvoker_EndInvokeAction_Integration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Web.Mvc"),(WCHAR*)WStr("System.Web.Mvc.ControllerActionInvoker"),(WCHAR*)WStr("InvokeActionMethod"),sig393,4,4,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ControllerActionInvoker_InvokeAction_Integration"),CallTargetKind::Default,6,1}, -{(WCHAR*)WStr("System.Web.Http"),(WCHAR*)WStr("System.Web.Http.ApiController"),(WCHAR*)WStr("ExecuteAsync"),sig298,3,5,1,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ApiController_ExecuteAsync_Integration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Web.Http"),(WCHAR*)WStr("System.Web.Http.Controllers.ReflectedHttpActionDescriptor"),(WCHAR*)WStr("ExecuteAsync"),sig297,4,5,1,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ReflectedHttpActionDescriptor_ExecuteAsync_Integration"),CallTargetKind::Default,6,1}, -{(WCHAR*)WStr("System.Web.Http"),(WCHAR*)WStr("System.Web.Http.ExceptionHandling.ExceptionHandlerExtensions"),(WCHAR*)WStr("HandleAsync"),sig299,4,5,1,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ExceptionHandlerExtensions_HandleAsync_Integration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Web.Mvc"),(WCHAR*)WStr("System.Web.Mvc.ControllerActionInvoker"),(WCHAR*)WStr("InvokeActionMethod"),sig394,4,4,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ControllerActionInvoker_InvokeAction_Integration"),CallTargetKind::Default,6,1}, +{(WCHAR*)WStr("System.Web.Http"),(WCHAR*)WStr("System.Web.Http.ApiController"),(WCHAR*)WStr("ExecuteAsync"),sig299,3,5,1,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ApiController_ExecuteAsync_Integration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Web.Http"),(WCHAR*)WStr("System.Web.Http.Controllers.ReflectedHttpActionDescriptor"),(WCHAR*)WStr("ExecuteAsync"),sig298,4,5,1,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ReflectedHttpActionDescriptor_ExecuteAsync_Integration"),CallTargetKind::Default,6,1}, +{(WCHAR*)WStr("System.Web.Http"),(WCHAR*)WStr("System.Web.Http.ExceptionHandling.ExceptionHandlerExtensions"),(WCHAR*)WStr("HandleAsync"),sig300,4,5,1,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNet.ExceptionHandlerExtensions_HandleAsync_Integration"),CallTargetKind::Default,1,1}, #endif {(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("BatchGetItem"),sig008,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.BatchGetItemIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.DynamoDBv2"),(WCHAR*)WStr("Amazon.DynamoDBv2.AmazonDynamoDBClient"),(WCHAR*)WStr("BatchGetItemAsync"),sig222,3,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.DynamoDb.BatchGetItemAsyncIntegration"),CallTargetKind::Default,1,15}, @@ -513,7 +514,7 @@ std::vector callTargets = {(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("PutRecords"),sig018,2,3,7,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.PutRecordsV3_7Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("PutRecordsAsync"),sig232,3,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.PutRecordsAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.Kinesis"),(WCHAR*)WStr("Amazon.Kinesis.AmazonKinesisClient"),(WCHAR*)WStr("PutRecordsAsync"),sig232,3,3,7,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Kinesis.PutRecordsAsyncV3_7Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Amazon.Lambda.RuntimeSupport"),(WCHAR*)WStr("Amazon.Lambda.RuntimeSupport.HandlerWrapper"),(WCHAR*)WStr("set_Handler"),sig313,2,1,4,0,1,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Lambda.HandlerWrapperSetHandlerIntegration"),CallTargetKind::Default,1,8}, +{(WCHAR*)WStr("Amazon.Lambda.RuntimeSupport"),(WCHAR*)WStr("Amazon.Lambda.RuntimeSupport.HandlerWrapper"),(WCHAR*)WStr("set_Handler"),sig314,2,1,4,0,1,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.Lambda.HandlerWrapperSetHandlerIntegration"),CallTargetKind::Default,1,8}, {(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("CompleteMultipartUpload"),sig021,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.MultipartUploadManagement.CompleteMultipartUploadIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("CompleteMultipartUploadAsync"),sig233,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.MultipartUploadManagement.CompleteMultipartUploadAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.S3"),(WCHAR*)WStr("Amazon.S3.AmazonS3Client"),(WCHAR*)WStr("CopyObject"),sig022,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.S3.ObjectManagement.CopyObjectIntegration"),CallTargetKind::Default,1,15}, @@ -563,21 +564,21 @@ std::vector callTargets = {(WCHAR*)WStr("AWSSDK.StepFunctions"),(WCHAR*)WStr("Amazon.StepFunctions.AmazonStepFunctionsClient"),(WCHAR*)WStr("StartExecutionAsync"),sig043,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.StepFunctions.StartExecutionAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.StepFunctions"),(WCHAR*)WStr("Amazon.StepFunctions.AmazonStepFunctionsClient"),(WCHAR*)WStr("StartSyncExecution"),sig044,2,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.StepFunctions.StartSyncExecutionIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("AWSSDK.StepFunctions"),(WCHAR*)WStr("Amazon.StepFunctions.AmazonStepFunctionsClient"),(WCHAR*)WStr("StartSyncExecutionAsync"),sig045,3,3,3,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AWS.StepFunctions.StartSyncExecutionAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Azure.Messaging.EventHubs"),(WCHAR*)WStr("Azure.Core.Shared.MessagingClientDiagnostics"),(WCHAR*)WStr("InstrumentMessage"),sig347,5,5,9,2,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.EventHubs.InstrumentMessageIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Azure.Messaging.EventHubs"),(WCHAR*)WStr("Azure.Messaging.EventHubs.Amqp.AmqpConsumer"),(WCHAR*)WStr("ReceiveAsync"),sig289,4,5,9,2,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.EventHubs.AmqpConsumerReceiveAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Azure.Messaging.EventHubs"),(WCHAR*)WStr("Azure.Core.Shared.MessagingClientDiagnostics"),(WCHAR*)WStr("InstrumentMessage"),sig348,5,5,9,2,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.EventHubs.InstrumentMessageIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Azure.Messaging.EventHubs"),(WCHAR*)WStr("Azure.Messaging.EventHubs.Amqp.AmqpConsumer"),(WCHAR*)WStr("ReceiveAsync"),sig290,4,5,9,2,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.EventHubs.AmqpConsumerReceiveAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Azure.Messaging.EventHubs"),(WCHAR*)WStr("Azure.Messaging.EventHubs.Producer.EventDataBatch"),(WCHAR*)WStr("TryAdd"),sig122,2,5,9,2,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.EventHubs.EventDataBatchTryAddIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Azure.Messaging.EventHubs"),(WCHAR*)WStr("Azure.Messaging.EventHubs.Producer.EventHubProducerClient"),(WCHAR*)WStr("SendAsync"),sig176,3,5,9,2,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.EventHubs.EventHubProducerClientSendBatchAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Azure.Messaging.EventHubs"),(WCHAR*)WStr("Azure.Messaging.EventHubs.Producer.EventHubProducerClient"),(WCHAR*)WStr("SendAsync"),sig198,3,5,9,2,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.EventHubs.EventHubProducerClientSendEnumerableAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Azure.Functions.Worker.Core"),(WCHAR*)WStr("Microsoft.Azure.Functions.Worker.Pipeline.FunctionExecutionMiddleware"),(WCHAR*)WStr("Invoke"),sig195,2,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.Functions.FunctionExecutionMiddlewareInvokeIntegration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Microsoft.Azure.WebJobs.Host"),(WCHAR*)WStr("Microsoft.Azure.WebJobs.Host.Executors.FunctionExecutor"),(WCHAR*)WStr("TryExecuteAsync"),sig264,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.Functions.AzureFunctionsExecutorTryExecuteAsyncIntegration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Microsoft.Azure.WebJobs.Script.Grpc"),(WCHAR*)WStr("Microsoft.Azure.WebJobs.Script.Grpc.GrpcMessageConversionExtensions"),(WCHAR*)WStr("ToRpcHttp"),sig265,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.Functions.GrpcMessageConversionExtensionsToRpcHttpIntegration"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Microsoft.Azure.WebJobs.Host"),(WCHAR*)WStr("Microsoft.Azure.WebJobs.Host.Executors.FunctionExecutor"),(WCHAR*)WStr("TryExecuteAsync"),sig265,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.Functions.AzureFunctionsExecutorTryExecuteAsyncIntegration"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Microsoft.Azure.WebJobs.Script.Grpc"),(WCHAR*)WStr("Microsoft.Azure.WebJobs.Script.Grpc.GrpcMessageConversionExtensions"),(WCHAR*)WStr("ToRpcHttp"),sig266,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.Functions.GrpcMessageConversionExtensionsToRpcHttpIntegration"),CallTargetKind::Default,1,14}, {(WCHAR*)WStr("Microsoft.Azure.WebJobs.Script.WebHost"),(WCHAR*)WStr("Microsoft.Azure.WebJobs.Script.WebHost.Middleware.FunctionInvocationMiddleware"),(WCHAR*)WStr("Invoke"),sig192,2,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.Functions.FunctionInvocationMiddlewareInvokeIntegration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Core.Shared.MessagingClientDiagnostics"),(WCHAR*)WStr("InstrumentMessage"),sig347,5,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.InstrumentMessageIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Core.Shared.MessagingClientDiagnostics"),(WCHAR*)WStr("InstrumentMessage"),sig348,5,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.InstrumentMessageIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ReceiverManager"),(WCHAR*)WStr("ProcessOneMessage"),sig178,3,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.ProcessMessageIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusMessageBatch"),(WCHAR*)WStr("TryAddMessage"),sig123,2,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.SendServiceBusMessageBatchIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusReceiver"),(WCHAR*)WStr("ReceiveMessagesAsync"),sig290,5,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.ServiceBusReceiverReceiveMessagesAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusReceiver"),(WCHAR*)WStr("ReceiveMessagesAsync"),sig291,5,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.ServiceBusReceiverReceiveMessagesAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusSender"),(WCHAR*)WStr("CreateDiagnosticScope"),sig046,4,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.SendServiceBusMessagesIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusSender"),(WCHAR*)WStr("ScheduleMessagesAsync"),sig291,4,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.ServiceBusSenderScheduleMessagesAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusSender"),(WCHAR*)WStr("ScheduleMessagesAsync"),sig292,4,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.ServiceBusSenderScheduleMessagesAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusSender"),(WCHAR*)WStr("SendMessagesAsync"),sig177,3,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.ServiceBusSenderSendMessageBatchAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Azure.Messaging.ServiceBus"),(WCHAR*)WStr("Azure.Messaging.ServiceBus.ServiceBusSender"),(WCHAR*)WStr("SendMessagesAsync"),sig199,3,7,14,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Azure.ServiceBus.ServiceBusSenderSendMessagesAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.ContainerCore"),(WCHAR*)WStr("GetItemQueryIterator"),sig080,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.ContainerQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, @@ -594,6 +595,7 @@ std::vector callTargets = {(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.DatabaseCore"),(WCHAR*)WStr("GetContainerQueryStreamIterator"),sig081,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.DatabaseQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.DatabaseCore"),(WCHAR*)WStr("GetUserQueryIterator"),sig080,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.DatabaseQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.DatabaseCore"),(WCHAR*)WStr("GetUserQueryIterator"),sig081,4,3,6,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.DatabaseQueryIteratorsIntegrations"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Azure.Cosmos.Client"),(WCHAR*)WStr("Microsoft.Azure.Cosmos.Handlers.RequestInvokerHandler"),(WCHAR*)WStr("SendAsync"),sig264,11,3,12,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CosmosDb.RequestInvokerHandlerSendAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("ExecuteOp"),sig181,3,3,1,3,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("ExecuteOp"),sig182,3,3,0,7,3,1,2,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.Core.ClusterNode"),(WCHAR*)WStr("ExecuteOp"),sig179,4,3,1,3,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.ClusterNodeIntegrationBis"),CallTargetKind::Default,1,15}, @@ -620,30 +622,30 @@ std::vector callTargets = {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.SharedPooledIOService"),(WCHAR*)WStr("ExecuteAsync"),sig184,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.SharedPooledIOService"),(WCHAR*)WStr("ExecuteAsync"),sig185,2,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Couchbase.NetClient"),(WCHAR*)WStr("Couchbase.IO.Services.SharedPooledIOService"),(WCHAR*)WStr("ExecuteAsync"),sig186,3,2,2,8,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Couchbase.IIOServiceExecuteAsyncIntegrationBis"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackCustomEvent"),sig371,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackCustomEventIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackCustomEvent"),sig380,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackCustomEventMetadataIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackUserLoginFailureEvent"),sig375,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackUserLoginFailureEventIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackUserLoginFailureEvent"),sig378,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackUserLoginFailureEventMetadataIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackUserLoginSuccessEvent"),sig371,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackUserLoginSuccessEventIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackUserLoginSuccessEvent"),sig380,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackUserLoginSuccessEventMetadataIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdkV2"),(WCHAR*)WStr("TrackUserLoginFailure"),sig376,5,3,0,15,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdkV2.EventTrackingSdkV2TrackUserLoginFailureUserDetailsIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdkV2"),(WCHAR*)WStr("TrackUserLoginFailure"),sig379,5,3,0,15,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdkV2.EventTrackingSdkV2TrackUserLoginFailureUserIdIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdkV2"),(WCHAR*)WStr("TrackUserLoginSuccess"),sig373,4,3,0,15,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdkV2.EventTrackingSdkV2TrackUserLoginSuccessUserDetailsIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdkV2"),(WCHAR*)WStr("TrackUserLoginSuccess"),sig384,4,3,15,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdkV2.EventTrackingSdkV2TrackUserLoginSuccessUserIdIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackCustomEvent"),sig372,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackCustomEventIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackCustomEvent"),sig381,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackCustomEventMetadataIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackUserLoginFailureEvent"),sig376,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackUserLoginFailureEventIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackUserLoginFailureEvent"),sig379,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackUserLoginFailureEventMetadataIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackUserLoginSuccessEvent"),sig372,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackUserLoginSuccessEventIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdk"),(WCHAR*)WStr("TrackUserLoginSuccessEvent"),sig381,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdk.EventTrackingSdkTrackUserLoginSuccessEventMetadataIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdkV2"),(WCHAR*)WStr("TrackUserLoginFailure"),sig377,5,3,0,15,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdkV2.EventTrackingSdkV2TrackUserLoginFailureUserDetailsIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdkV2"),(WCHAR*)WStr("TrackUserLoginFailure"),sig380,5,3,0,15,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdkV2.EventTrackingSdkV2TrackUserLoginFailureUserIdIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdkV2"),(WCHAR*)WStr("TrackUserLoginSuccess"),sig374,4,3,0,15,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdkV2.EventTrackingSdkV2TrackUserLoginSuccessUserDetailsIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.AppSec.EventTrackingSdkV2"),(WCHAR*)WStr("TrackUserLoginSuccess"),sig385,4,3,15,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.AppSec.EventTrackingSdkV2.EventTrackingSdkV2TrackUserLoginSuccessUserIdIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Baggage"),(WCHAR*)WStr("get_Current"),sig132,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Baggage.Baggage_GetCurrent_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Baggage"),(WCHAR*)WStr("set_Current"),sig348,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Baggage.Baggage_SetCurrent_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Ci.TestExtensions"),(WCHAR*)WStr("AddBenchmarkData"),sig318,5,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Ci.TestExtensionsAddBenchmarkDataIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Ci.TestExtensions"),(WCHAR*)WStr("SetBenchmarkMetadata"),sig317,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Ci.TestExtensionsSetBenchmarkMetadataIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Ci.TestExtensions"),(WCHAR*)WStr("SetParameters"),sig319,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Ci.TestExtensionsSetParametersIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Baggage"),(WCHAR*)WStr("set_Current"),sig349,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Baggage.Baggage_SetCurrent_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Ci.TestExtensions"),(WCHAR*)WStr("AddBenchmarkData"),sig319,5,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Ci.TestExtensionsAddBenchmarkDataIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Ci.TestExtensions"),(WCHAR*)WStr("SetBenchmarkMetadata"),sig318,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Ci.TestExtensionsSetBenchmarkMetadataIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Ci.TestExtensions"),(WCHAR*)WStr("SetParameters"),sig320,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Ci.TestExtensionsSetParametersIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Ci.TestModule"),(WCHAR*)WStr("InternalCreate"),sig052,5,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Ci.TestModuleInternalCreateIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Ci.TestSession"),(WCHAR*)WStr("InternalGetOrCreate"),sig053,6,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Ci.TestSessionInternalGetOrCreateIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.GlobalSettings"),(WCHAR*)WStr("SetDebugEnabled"),sig341,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.GlobalSettingsSetDebugEnabledIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.GlobalSettings"),(WCHAR*)WStr("SetDebugEnabled"),sig342,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.GlobalSettingsSetDebugEnabledIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationSettings"),(WCHAR*)WStr("get_AnalyticsEnabled"),sig158,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableIntegrationSettings.AnalyticsEnabledGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationSettings"),(WCHAR*)WStr("get_AnalyticsSampleRate"),sig142,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableIntegrationSettings.AnalyticsSampleRateGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationSettings"),(WCHAR*)WStr("get_Enabled"),sig158,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableIntegrationSettings.EnabledGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationSettings"),(WCHAR*)WStr("get_IntegrationName"),sig168,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableIntegrationSettings.IntegrationNameGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableIntegrationSettingsCollection"),(WCHAR*)WStr("get_Item"),sig056,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableIntegrationSettingsCollectionIndexerIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_AgentUri"),sig309,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.AgentUriIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_AgentUri"),sig310,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.AgentUriIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_AnalyticsEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.AnalyticsEnabledGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_CustomSamplingRules"),sig168,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.CustomSamplingRulesGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.ImmutableTracerSettings"),(WCHAR*)WStr("get_Environment"),sig168,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.ImmutableTracerSettings.EnvironmentGetIntegration"),CallTargetKind::Default,1,15}, @@ -667,10 +669,10 @@ std::vector callTargets = {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettings"),(WCHAR*)WStr("get_Enabled"),sig158,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.IntegrationSettings.EnabledGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettings"),(WCHAR*)WStr("get_IntegrationName"),sig168,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.IntegrationSettings.IntegrationNameGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.IntegrationSettingsCollection"),(WCHAR*)WStr("get_Item"),sig058,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.IntegrationSettingsCollectionIndexerIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr(".ctor"),sig310,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.CtorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr(".ctor"),sig341,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.CtorUseDefaultSourcesIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr(".ctor"),sig311,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.CtorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr(".ctor"),sig342,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.CtorUseDefaultSourcesIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("FromDefaultSources"),sig060,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.FromDefaultSourcesIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_AgentUri"),sig309,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.AgentUriGetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_AgentUri"),sig310,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.AgentUriGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_AnalyticsEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.AnalyticsEnabledGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_CustomSamplingRules"),sig168,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.CustomSamplingRulesGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_DiagnosticSourceEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.DiagnosticSourceEnabledGetIntegration"),CallTargetKind::Default,1,15}, @@ -691,23 +693,23 @@ std::vector callTargets = {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_StatsComputationEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.StatsComputationEnabledGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_TraceEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.TraceEnabledGetIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("get_TracerMetricsEnabled"),sig121,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.TracerMetricsEnabledGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("PopulateDictionary"),sig345,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.PopulateDictionaryIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("set_DiagnosticSourceEnabled"),sig341,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.DiagnosticSourceEnabledSetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.ExtensionMethods.SpanExtensions"),(WCHAR*)WStr("SetTraceSamplingPriority"),sig320,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetTraceSamplingPriorityIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("PopulateDictionary"),sig346,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.PopulateDictionaryIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Configuration.TracerSettings"),(WCHAR*)WStr("set_DiagnosticSourceEnabled"),sig342,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Configuration.TracerSettings.DiagnosticSourceEnabledSetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.ExtensionMethods.SpanExtensions"),(WCHAR*)WStr("SetTraceSamplingPriority"),sig321,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetTraceSamplingPriorityIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.FeatureFlagsSdk"),(WCHAR*)WStr("Evaluate"),sig061,6,3,31,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkEvaluateIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.FeatureFlagsSdk"),(WCHAR*)WStr("IsAvailable"),sig121,1,3,31,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkIsAvailableIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.FeatureFlagsSdk"),(WCHAR*)WStr("RegisterOnNewConfigEventHandler"),sig339,2,3,31,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextExtractor"),(WCHAR*)WStr(".ctor"),sig310,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorConstructorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.FeatureFlags.FeatureFlagsSdk"),(WCHAR*)WStr("RegisterOnNewConfigEventHandler"),sig340,2,3,31,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Datadog_Trace_Manual.FeatureFlagsSdkRegisterOnNewConfigEventHandlerIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextExtractor"),(WCHAR*)WStr(".ctor"),sig311,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorConstructorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextExtractor"),(WCHAR*)WStr("Extract"),sig068,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextExtractor"),(WCHAR*)WStr("ExtractIncludingDsm"),sig069,5,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextExtractorExtractIncludingDsmIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextInjector"),(WCHAR*)WStr(".ctor"),sig310,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextInjectorConstructorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextInjector"),(WCHAR*)WStr("Inject"),sig311,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextInjectorInjectIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextInjector"),(WCHAR*)WStr("InjectIncludingDsm"),sig312,6,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextInjectorInjectIncludingDsmIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextInjector"),(WCHAR*)WStr(".ctor"),sig311,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextInjectorConstructorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextInjector"),(WCHAR*)WStr("Inject"),sig312,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextInjectorInjectIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanContextInjector"),(WCHAR*)WStr("InjectIncludingDsm"),sig313,6,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Propagators.SpanContextInjectorInjectIncludingDsmIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanExtensions"),(WCHAR*)WStr("SetTag"),sig066,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetTagIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanExtensions"),(WCHAR*)WStr("SetUser"),sig321,9,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetUserIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr(".ctor"),sig364,3,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.CtorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("Configure"),sig344,2,3,7,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.ConfigureIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("Configure"),sig344,2,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.ConfigureIntegration_Pre3_7"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.SpanExtensions"),(WCHAR*)WStr("SetUser"),sig322,9,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Extensions.SpanExtensionsSetUserIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr(".ctor"),sig365,3,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.CtorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("Configure"),sig345,2,3,7,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.ConfigureIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("Configure"),sig345,2,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.ConfigureIntegration_Pre3_7"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("Datadog.Trace.IDatadogOpenTracingTracer.StartSpan"),sig067,6,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.StartSpanIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("ForceFlushAsync"),sig175,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.ForceFlushAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace.Manual"),(WCHAR*)WStr("Datadog.Trace.Tracer"),(WCHAR*)WStr("get_ActiveScope"),sig062,1,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.Tracer.GetActiveScopeIntegration"),CallTargetKind::Default,1,15}, @@ -721,10 +723,10 @@ std::vector callTargets = {(WCHAR*)WStr("Datadog.Trace.OpenTracing"),(WCHAR*)WStr("Datadog.Trace.OpenTracing.OpenTracingTracerFactory"),(WCHAR*)WStr("WrapTracer"),sig111,2,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.OpenTracing.OpenTracingTracerFactoryWrapTracerIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Datadog.Trace"),(WCHAR*)WStr("Datadog.Trace.Util.ProcessHelpers"),(WCHAR*)WStr("StartWithDoNotTrace"),sig141,3,2,49,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.VersionConflict.ProcessHelpersStartWithDoNotTraceIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("coverlet.core"),(WCHAR*)WStr("Coverlet.Core.Coverage"),(WCHAR*)WStr("GetCoverageResult"),sig051,1,3,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.CoverageGetCoverageResultIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("dotnet"),(WCHAR*)WStr("Microsoft.DotNet.Tools.Test.TestCommand"),(WCHAR*)WStr(".ctor"),sig358,6,2,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.TestCommand5ctorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("dotnet"),(WCHAR*)WStr("Microsoft.DotNet.Tools.Test.TestCommand"),(WCHAR*)WStr(".ctor"),sig357,4,6,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.TestCommandctorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("dotnet"),(WCHAR*)WStr("Microsoft.DotNet.Tools.Test.TestCommand"),(WCHAR*)WStr(".ctor"),sig359,6,2,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.TestCommand5ctorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("dotnet"),(WCHAR*)WStr("Microsoft.DotNet.Tools.Test.TestCommand"),(WCHAR*)WStr(".ctor"),sig358,4,6,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.TestCommandctorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("dotnet"),(WCHAR*)WStr("Microsoft.DotNet.Tools.Test.TestCommand"),(WCHAR*)WStr("Run"),sig151,2,2,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.TestCommandRunIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TraceDataCollector"),(WCHAR*)WStr("Microsoft.VisualStudio.TraceCollector.VanguardCollector.ManagedVanguard"),(WCHAR*)WStr("Stop"),sig310,1,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.ManagedVanguardStopIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TraceDataCollector"),(WCHAR*)WStr("Microsoft.VisualStudio.TraceCollector.VanguardCollector.ManagedVanguard"),(WCHAR*)WStr("Stop"),sig311,1,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.ManagedVanguardStopIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("vstest.console"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.CommandLine.Executor"),(WCHAR*)WStr("Execute"),sig149,2,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.ExecutorExecuteIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("vstest.console"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.CommandLine.Executor"),(WCHAR*)WStr("GetArgumentProcessors"),sig150,3,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.ExecutorGetArgumentProcessorsIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("vstest.console.arm64"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.CommandLine.Executor"),(WCHAR*)WStr("Execute"),sig149,2,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.DotnetTest.ExecutorExecuteIntegration"),CallTargetKind::Default,1,15}, @@ -747,11 +749,11 @@ std::vector callTargets = {(WCHAR*)WStr("GraphQL.SystemReactive"),(WCHAR*)WStr("GraphQL.Execution.SubscriptionExecutionStrategy"),(WCHAR*)WStr("ExecuteAsync"),sig210,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.Net.ExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.ParsingPrimitives"),(WCHAR*)WStr("ReadRawString"),sig170,4,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcAspNetCoreServer.IAST.ParsingPrimitivesReadRawStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Grpc.AspNetCore.Server"),(WCHAR*)WStr("Grpc.AspNetCore.Server.Internal.CallHandlers.ServerCallHandlerBase`3"),(WCHAR*)WStr("HandleCallAsync"),sig192,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcAspNetCoreServer.ServerCallHandlerBaseHandleCallAsyncIntegration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Grpc.AspNetCore.Server"),(WCHAR*)WStr("Grpc.AspNetCore.Server.Internal.GrpcProtocolHelpers"),(WCHAR*)WStr("BuildHttpErrorResponse"),sig329,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcAspNetCoreServer.GrpcProtocolHelpersBuildHttpErrorResponseIntegration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Grpc.AspNetCore.Server"),(WCHAR*)WStr("Grpc.AspNetCore.Server.Internal.HttpContextServerCallContext"),(WCHAR*)WStr("LogCallEnd"),sig310,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcAspNetCoreServer.HttpContextServerCallContextLogCallEndIntegration"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Grpc.AspNetCore.Server"),(WCHAR*)WStr("Grpc.AspNetCore.Server.Internal.GrpcProtocolHelpers"),(WCHAR*)WStr("BuildHttpErrorResponse"),sig330,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcAspNetCoreServer.GrpcProtocolHelpersBuildHttpErrorResponseIntegration"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Grpc.AspNetCore.Server"),(WCHAR*)WStr("Grpc.AspNetCore.Server.Internal.HttpContextServerCallContext"),(WCHAR*)WStr("LogCallEnd"),sig311,1,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcAspNetCoreServer.HttpContextServerCallContextLogCallEndIntegration"),CallTargetKind::Default,1,14}, {(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.DefaultCallInvoker"),(WCHAR*)WStr("CreateCall"),sig072,4,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Client.DefaultCallInvokerInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.AsyncCall`2"),(WCHAR*)WStr("HandleFinished"),sig342,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Client.AsyncCallHandleFinishedInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.AsyncCall`2"),(WCHAR*)WStr("HandleUnaryResponse"),sig343,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Client.AsyncCallHandleUnaryResponseInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.AsyncCall`2"),(WCHAR*)WStr("HandleFinished"),sig343,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Client.AsyncCallHandleFinishedInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.AsyncCall`2"),(WCHAR*)WStr("HandleUnaryResponse"),sig344,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Client.AsyncCallHandleUnaryResponseInstrumentation"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.AsyncCallServer`2"),(WCHAR*)WStr("SendInitialMetadataAsync"),sig188,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.AsyncCallServerSendInitialMetadataAsyncInstrumentation"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.AsyncCallServer`2"),(WCHAR*)WStr("SendStatusFromServerAsync"),sig189,4,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.AsyncCallServerSendStatusFromServerAsyncInstrumentation"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.ClientStreamingServerCallHandler`2"),(WCHAR*)WStr("HandleCall"),sig187,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.ServerCallHandlerInstrumentation"),CallTargetKind::Default,1,15}, @@ -759,10 +761,10 @@ std::vector callTargets = {(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.MetadataArraySafeHandle"),(WCHAR*)WStr("Create"),sig073,2,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Client.MetadataArraySafeHandleCreateInstrumentation"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.ServerStreamingServerCallHandler`2"),(WCHAR*)WStr("HandleCall"),sig187,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.ServerCallHandlerInstrumentation"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Grpc.Core"),(WCHAR*)WStr("Grpc.Core.Internal.UnaryServerCallHandler`2"),(WCHAR*)WStr("HandleCall"),sig187,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcLegacy.Server.ServerCallHandlerInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Grpc.Net.Client"),(WCHAR*)WStr("Grpc.Net.Client.Internal.GrpcCall`2"),(WCHAR*)WStr("FinishCall"),sig360,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcNetClient.GrpcCallFinishCallIntegration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Grpc.Net.Client"),(WCHAR*)WStr("Grpc.Net.Client.Internal.GrpcCall`2"),(WCHAR*)WStr("FinishCall"),sig361,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcNetClient.GrpcCallFinishCallPre243Integration"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Grpc.Net.Client"),(WCHAR*)WStr("Grpc.Net.Client.Internal.GrpcCall`2"),(WCHAR*)WStr("FinishCall"),sig361,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcNetClient.GrpcCallFinishCallIntegration"),CallTargetKind::Default,1,14}, +{(WCHAR*)WStr("Grpc.Net.Client"),(WCHAR*)WStr("Grpc.Net.Client.Internal.GrpcCall`2"),(WCHAR*)WStr("FinishCall"),sig362,5,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcNetClient.GrpcCallFinishCallPre243Integration"),CallTargetKind::Default,1,14}, {(WCHAR*)WStr("Grpc.Net.Client"),(WCHAR*)WStr("Grpc.Net.Client.Internal.GrpcCall`2"),(WCHAR*)WStr("RunCall"),sig201,3,2,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Grpc.GrpcDotNet.GrpcNetClient.GrpcCallRunCallIntegration"),CallTargetKind::Default,1,14}, -{(WCHAR*)WStr("Hangfire.Core"),(WCHAR*)WStr("Hangfire.Common.JobFilterCollection"),(WCHAR*)WStr(".ctor"),sig310,1,1,7,0,1,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Hangfire.JobFilterCollectionCtorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Hangfire.Core"),(WCHAR*)WStr("Hangfire.Common.JobFilterCollection"),(WCHAR*)WStr(".ctor"),sig311,1,1,7,0,1,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Hangfire.JobFilterCollectionCtorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Security.Cryptography"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHash"),sig128,4,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegration"),CallTargetKind::Default,4,14}, {(WCHAR*)WStr("System.Security.Cryptography"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHash"),sig129,2,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegrationBis"),CallTargetKind::Default,4,14}, {(WCHAR*)WStr("System.Security.Cryptography"),(WCHAR*)WStr("System.Security.Cryptography.HashAlgorithm"),(WCHAR*)WStr("ComputeHash"),sig127,2,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.HashAlgorithm.HashAlgorithmIntegrationBis"),CallTargetKind::Default,4,14}, @@ -778,36 +780,36 @@ std::vector callTargets = {(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.RequestExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig257,3,11,0,0,12,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.RequestExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig257,3,13,0,0,13,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegrationV13"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("HotChocolate.Execution"),(WCHAR*)WStr("HotChocolate.Execution.RequestExecutor"),(WCHAR*)WStr("ExecuteAsync"),sig256,3,14,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.GraphQL.HotChocolate.ExecuteAsyncIntegrationV14"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.CurlHandler"),(WCHAR*)WStr("SendAsync"),sig296,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.CurlHandler.CurlHandlerIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.CurlHandler"),(WCHAR*)WStr("SendAsync"),sig297,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.CurlHandler.CurlHandlerIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.HttpClientHandler"),(WCHAR*)WStr("Send"),sig154,3,5,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.HttpClientHandler.HttpClientHandlerSyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.HttpClientHandler"),(WCHAR*)WStr("SendAsync"),sig296,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.HttpClientHandler.HttpClientHandlerIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.HttpClientHandler"),(WCHAR*)WStr("SendAsync"),sig297,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.HttpClientHandler.HttpClientHandlerIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.SocketsHttpHandler"),(WCHAR*)WStr("Send"),sig154,3,5,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.SocketsHttpHandler.SocketsHttpHandlerSyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.SocketsHttpHandler"),(WCHAR*)WStr("SendAsync"),sig296,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.SocketsHttpHandler.SocketsHttpHandlerIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.WinHttpHandler"),(WCHAR*)WStr("SendAsync"),sig296,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.WinHttpHandler.WinHttpHandlerIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Net.Http.WinHttpHandler"),(WCHAR*)WStr("System.Net.Http.WinHttpHandler"),(WCHAR*)WStr("SendAsync"),sig296,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.WinHttpHandler.WinHttpHandlerIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Yarp.ReverseProxy"),(WCHAR*)WStr("Yarp.ReverseProxy.Forwarder.ForwarderHttpClientFactory"),(WCHAR*)WStr("ConfigureHandler"),sig390,3,1,1,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.SocketsHttpHandler.YarpForwarderHttpClientFactoryIntegration"),CallTargetKind::Default,1,8}, -{(WCHAR*)WStr("amqmdnetstd"),(WCHAR*)WStr("IBM.WMQ.MQDestination"),(WCHAR*)WStr("Get"),sig326,4,9,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.IbmMq.GetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("amqmdnetstd"),(WCHAR*)WStr("IBM.WMQ.MQDestination"),(WCHAR*)WStr("Put"),sig327,3,9,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.IbmMq.PutIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Logging"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactory"),(WCHAR*)WStr(".ctor"),sig350,3,2,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.LoggerFactoryConstructorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Logging"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactory"),(WCHAR*)WStr(".ctor"),sig351,4,5,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.LoggerFactoryConstructorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Logging"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactory"),(WCHAR*)WStr(".ctor"),sig352,5,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.LoggerFactoryConstructorNet7Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Logging"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactoryScopeProvider"),(WCHAR*)WStr("ForEachScope"),sig340,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.LoggerFactoryScopeProviderForEachScopeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Logging.Abstractions"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerExternalScopeProvider"),(WCHAR*)WStr("ForEachScope"),sig340,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.LoggerExternalScopeProviderForEachScopeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Telemetry"),(WCHAR*)WStr("Microsoft.Extensions.Logging.ExtendedLoggerFactory"),(WCHAR*)WStr(".ctor"),sig354,12,9,5,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.ExtendedLoggerFactoryConstructorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Telemetry"),(WCHAR*)WStr("Microsoft.Extensions.Logging.ExtendedLoggerFactory"),(WCHAR*)WStr(".ctor"),sig355,10,8,0,0,9,3,0,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.ExtendedLoggerFactoryConstructorIntegration_8xx"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Telemetry"),(WCHAR*)WStr("Microsoft.Extensions.Logging.ExtendedLoggerFactory"),(WCHAR*)WStr(".ctor"),sig353,11,9,3,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.ExtendedLoggerFactoryConstructorIntegration_930_940"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Extensions.Telemetry"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactoryScopeProvider"),(WCHAR*)WStr("ForEachScope"),sig340,3,8,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.LoggerFactoryScopeProviderForEachScopeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr(".ctor"),sig314,2,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerConstructorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Close"),sig310,1,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerCloseIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.SocketsHttpHandler"),(WCHAR*)WStr("SendAsync"),sig297,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.SocketsHttpHandler.SocketsHttpHandlerIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Net.Http"),(WCHAR*)WStr("System.Net.Http.WinHttpHandler"),(WCHAR*)WStr("SendAsync"),sig297,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.WinHttpHandler.WinHttpHandlerIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Net.Http.WinHttpHandler"),(WCHAR*)WStr("System.Net.Http.WinHttpHandler"),(WCHAR*)WStr("SendAsync"),sig297,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.WinHttpHandler.WinHttpHandlerIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Yarp.ReverseProxy"),(WCHAR*)WStr("Yarp.ReverseProxy.Forwarder.ForwarderHttpClientFactory"),(WCHAR*)WStr("ConfigureHandler"),sig391,3,1,1,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.SocketsHttpHandler.YarpForwarderHttpClientFactoryIntegration"),CallTargetKind::Default,1,8}, +{(WCHAR*)WStr("amqmdnetstd"),(WCHAR*)WStr("IBM.WMQ.MQDestination"),(WCHAR*)WStr("Get"),sig327,4,9,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.IbmMq.GetIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("amqmdnetstd"),(WCHAR*)WStr("IBM.WMQ.MQDestination"),(WCHAR*)WStr("Put"),sig328,3,9,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.IbmMq.PutIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Logging"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactory"),(WCHAR*)WStr(".ctor"),sig351,3,2,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.LoggerFactoryConstructorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Logging"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactory"),(WCHAR*)WStr(".ctor"),sig352,4,5,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.LoggerFactoryConstructorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Logging"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactory"),(WCHAR*)WStr(".ctor"),sig353,5,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.LoggerFactoryConstructorNet7Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Logging"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactoryScopeProvider"),(WCHAR*)WStr("ForEachScope"),sig341,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.LoggerFactoryScopeProviderForEachScopeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Logging.Abstractions"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerExternalScopeProvider"),(WCHAR*)WStr("ForEachScope"),sig341,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.LoggerExternalScopeProviderForEachScopeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Telemetry"),(WCHAR*)WStr("Microsoft.Extensions.Logging.ExtendedLoggerFactory"),(WCHAR*)WStr(".ctor"),sig355,12,9,5,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.ExtendedLoggerFactoryConstructorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Telemetry"),(WCHAR*)WStr("Microsoft.Extensions.Logging.ExtendedLoggerFactory"),(WCHAR*)WStr(".ctor"),sig356,10,8,0,0,9,3,0,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.ExtendedLoggerFactoryConstructorIntegration_8xx"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Telemetry"),(WCHAR*)WStr("Microsoft.Extensions.Logging.ExtendedLoggerFactory"),(WCHAR*)WStr(".ctor"),sig354,11,9,3,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.DirectSubmission.ExtendedLoggerFactoryConstructorIntegration_930_940"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Extensions.Telemetry"),(WCHAR*)WStr("Microsoft.Extensions.Logging.LoggerFactoryScopeProvider"),(WCHAR*)WStr("ForEachScope"),sig341,3,8,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.ILogger.LoggerFactoryScopeProviderForEachScopeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr(".ctor"),sig315,2,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerConstructorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Close"),sig311,1,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerCloseIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Commit"),sig133,1,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerCommitAllIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Commit"),sig349,2,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerCommitIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Commit"),sig350,2,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerCommitIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Consume"),sig047,2,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerConsumeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Dispose"),sig310,1,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerDisposeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Unsubscribe"),sig310,1,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerUnsubscribeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Producer`2"),(WCHAR*)WStr(".ctor"),sig315,2,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaProducerConstructorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Producer`2"),(WCHAR*)WStr("Produce"),sig316,4,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaProduceSyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Dispose"),sig311,1,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerDisposeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Consumer`2"),(WCHAR*)WStr("Unsubscribe"),sig311,1,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaConsumerUnsubscribeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Producer`2"),(WCHAR*)WStr(".ctor"),sig316,2,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaProducerConstructorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Producer`2"),(WCHAR*)WStr("Produce"),sig317,4,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaProduceSyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Producer`2"),(WCHAR*)WStr("ProduceAsync"),sig254,4,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaProduceAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Producer`2+TypedDeliveryHandlerShim_Action"),(WCHAR*)WStr(".ctor"),sig372,5,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaProduceSyncDeliveryHandlerIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Confluent.Kafka"),(WCHAR*)WStr("Confluent.Kafka.Producer`2+TypedDeliveryHandlerShim_Action"),(WCHAR*)WStr(".ctor"),sig373,5,1,4,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Kafka.KafkaProduceSyncDeliveryHandlerIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("log4net"),(WCHAR*)WStr("log4net.Appender.AppenderCollection"),(WCHAR*)WStr("ToArray"),sig074,1,2,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.Log4Net.DirectSubmission.AppenderCollectionIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("log4net"),(WCHAR*)WStr("log4net.Appender.AppenderCollection"),(WCHAR*)WStr("ToArray"),sig074,1,1,0,0,1,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.Log4Net.DirectSubmission.AppenderCollectionLegacyIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("log4net"),(WCHAR*)WStr("log4net.Util.AppenderAttachedImpl"),(WCHAR*)WStr("AppendLoopOnAppenders"),sig147,2,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Log4Net.AppenderAttachedImplIntegration"),CallTargetKind::Default,1,15}, @@ -837,315 +839,315 @@ std::vector callTargets = {(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.CommandWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.GetMoreWireProtocol`1"),(WCHAR*)WStr("Execute"),sig006,3,2,2,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Generic_Execute_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.GetMoreWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.KillCursorsWireProtocol"),(WCHAR*)WStr("Execute"),sig333,3,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Execute_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.KillCursorsWireProtocol"),(WCHAR*)WStr("Execute"),sig334,3,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Execute_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.KillCursorsWireProtocol"),(WCHAR*)WStr("ExecuteAsync"),sig196,3,2,1,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.QueryWireProtocol`1"),(WCHAR*)WStr("Execute"),sig006,3,2,2,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Generic_Execute_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.QueryWireProtocol`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.WriteWireProtocolBase`1"),(WCHAR*)WStr("Execute"),sig006,3,2,2,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_Generic_Execute_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MongoDB.Driver.Core"),(WCHAR*)WStr("MongoDB.Driver.Core.WireProtocol.WriteWireProtocolBase`1"),(WCHAR*)WStr("ExecuteAsync"),sig219,3,2,1,0,3,5,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.MongoDb.IWireProtocol_ExecuteAsync_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Messaging"),(WCHAR*)WStr("System.Messaging.MessageQueue"),(WCHAR*)WStr("Purge"),sig310,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Msmq.MessageQueue_Purge_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Messaging"),(WCHAR*)WStr("System.Messaging.MessageQueue"),(WCHAR*)WStr("Purge"),sig311,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Msmq.MessageQueue_Purge_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Messaging"),(WCHAR*)WStr("System.Messaging.MessageQueue"),(WCHAR*)WStr("ReceiveCurrent"),sig153,7,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Msmq.MessageQueue_ReceiveCurrent_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Messaging"),(WCHAR*)WStr("System.Messaging.MessageQueue"),(WCHAR*)WStr("SendInternal"),sig365,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Msmq.MessageQueue_SendInternal_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.TestPlatform.CrossPlatEngine"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Execution.RunTestsWithSources"),(WCHAR*)WStr("SendSessionEnd"),sig310,1,14,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.RunTestsWithSourcesSendSessionEndIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("ExecuteAssemblyCleanup"),sig310,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoExecuteAssemblyCleanupIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Messaging"),(WCHAR*)WStr("System.Messaging.MessageQueue"),(WCHAR*)WStr("SendInternal"),sig366,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Msmq.MessageQueue_SendInternal_Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.TestPlatform.CrossPlatEngine"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Execution.RunTestsWithSources"),(WCHAR*)WStr("SendSessionEnd"),sig311,1,14,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.RunTestsWithSourcesSendSessionEndIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("ExecuteAssemblyCleanup"),sig311,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoExecuteAssemblyCleanupIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyCleanup"),sig168,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyInitialize"),sig331,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyInitializeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyInitialize"),sig332,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyInitializeIntegrationV3_9"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig310,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig395,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupIntegrationV3_9"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig394,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassCleanupIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyInitialize"),sig332,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyInitializeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyInitialize"),sig333,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyInitializeIntegrationV3_9"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig311,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig396,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupIntegrationV3_9"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig395,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassCleanupIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassCleanup"),sig174,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitialize"),sig391,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitialize"),sig392,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeIntegrationV3_9"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitialize"),sig392,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitialize"),sig393,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeIntegrationV3_9"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("Execute"),sig089,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("Execute"),sig092,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteIntegration3_8"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("ExecuteTest"),sig093,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteTestIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("ExecuteTestAsync"),sig271,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteTestIntegrationV3_9"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("ExecuteTestAsync"),sig272,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteTestIntegrationV3_9"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TypeCache"),(WCHAR*)WStr("GetTestMethodInfo"),sig088,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TypeCacheGetTestMethodInfoIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TypeCache"),(WCHAR*)WStr("GetTestMethodInfo"),sig087,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TypeCacheGetTestMethodInfoIntegrationV3_9"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunCleanup"),sig086,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunCleanupIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTest"),sig090,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTest"),sig094,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestIntegration3_8"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTestAsync"),sig272,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestAsyncIntegration3_8"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.UnitTestDiscoverer"),(WCHAR*)WStr("SendTestCases"),sig381,6,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestDiscovererSendTestCasesIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("ExecuteAssemblyCleanup"),sig310,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoExecuteAssemblyCleanupIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTestAsync"),sig273,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestAsyncIntegration3_8"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.UnitTestDiscoverer"),(WCHAR*)WStr("SendTestCases"),sig382,6,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestDiscovererSendTestCasesIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("ExecuteAssemblyCleanup"),sig311,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoExecuteAssemblyCleanupIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyCleanup"),sig168,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyInitialize"),sig331,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyInitializeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyInitialize"),sig332,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyInitializeIntegrationV3_9"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig310,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig395,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupIntegrationV3_9"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig394,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanupAsync"),sig394,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyInitialize"),sig332,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyInitializeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyInitialize"),sig333,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyInitializeIntegrationV3_9"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig311,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig396,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupIntegrationV3_9"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanup"),sig395,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassCleanupIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanupAsync"),sig395,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassCleanup"),sig174,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassCleanupIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitialize"),sig391,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitialize"),sig392,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeIntegrationV3_9"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitialize"),sig392,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitialize"),sig393,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeIntegrationV3_9"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitializeAsync"),sig207,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("ExecuteTestAsync"),sig271,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteTestIntegrationV3_9"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("ExecuteTestAsync"),sig272,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteTestIntegrationV3_9"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TypeCache"),(WCHAR*)WStr("GetTestMethodInfo"),sig088,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TypeCacheGetTestMethodInfoIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TypeCache"),(WCHAR*)WStr("GetTestMethodInfo"),sig087,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TypeCacheGetTestMethodInfoIntegrationV3_9"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunCleanup"),sig086,1,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunCleanupIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTest"),sig090,3,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTest"),sig094,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestIntegration3_8"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTestAsync"),sig272,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestAsyncIntegration3_8"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.UnitTestDiscoverer"),(WCHAR*)WStr("SendTestCases"),sig381,6,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestDiscovererSendTestCasesIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTestAsync"),sig273,4,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestAsyncIntegration3_8"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.UnitTestDiscoverer"),(WCHAR*)WStr("SendTestCases"),sig382,6,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestDiscovererSendTestCasesIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("Execute"),sig091,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("Execute"),sig091,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("ExecuteAsync"),sig273,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("ExecuteAsync"),sig273,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteAsyncIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("MSTest.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("ExecuteAsync"),sig273,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MSTest.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("ExecuteAsync"),sig273,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteAsyncIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyInitialize"),sig331,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyInitializeIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanupAsync"),sig394,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("ExecuteAsync"),sig274,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("ExecuteAsync"),sig274,2,14,0,0,14,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteAsyncIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("MSTest.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("ExecuteAsync"),sig274,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MSTest.TestFramework"),(WCHAR*)WStr("Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute"),(WCHAR*)WStr("ExecuteAsync"),sig274,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodAttributeExecuteAsyncIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestAssemblyInfo"),(WCHAR*)WStr("RunAssemblyInitialize"),sig332,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestAssemblyInfoRunAssemblyInitializeIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("ExecuteClassCleanupAsync"),sig395,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoExecuteClassCleanupAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestClassInfo"),(WCHAR*)WStr("RunClassInitializeAsync"),sig207,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestClassInfoRunClassInitializeAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("ExecuteTestAsync"),sig271,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteTestIntegrationV3_9"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TestMethodRunner"),(WCHAR*)WStr("ExecuteTestAsync"),sig272,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TestMethodRunnerExecuteTestIntegrationV3_9"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.TypeCache"),(WCHAR*)WStr("GetTestMethodInfo"),sig087,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.TypeCacheGetTestMethodInfoIntegrationV3_9"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTest"),sig094,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestIntegration3_8"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTestAsync"),sig272,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestAsyncIntegration3_8"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.UnitTestDiscoverer"),(WCHAR*)WStr("SendTestCases"),sig356,5,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestDiscovererSendTestCasesIntegrationV4"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("Close"),sig310,1,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution.UnitTestRunner"),(WCHAR*)WStr("RunSingleTestAsync"),sig273,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestRunnerRunSingleTestAsyncIntegration3_8"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MSTestAdapter.PlatformServices"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.UnitTestDiscoverer"),(WCHAR*)WStr("SendTestCases"),sig357,5,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.MsTestV2.UnitTestDiscovererSendTestCasesIntegrationV4"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("Close"),sig311,1,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig293,3,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig296,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig095,1,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig096,2,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig095,1,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig096,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig274,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig275,3,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig275,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig276,3,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig301,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("GetString"),sig169,2,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("GetValue"),sig162,2,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("Read"),sig121,1,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ReadAsync"),sig300,2,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("Close"),sig310,1,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ReadAsync"),sig301,2,6,7,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("Close"),sig311,1,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("GetString"),sig169,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("Read"),sig121,1,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("MySql.Data"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig301,2,8,0,0,9,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig293,3,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig296,2,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig095,1,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig096,2,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySql.Data.MySqlClient.MySqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig301,2,0,61,0,0,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig293,3,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig296,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig097,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig098,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig277,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig276,3,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig278,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig277,3,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("Close"),sig310,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig301,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("Close"),sig311,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("GetString"),sig169,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("Read"),sig121,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("MySqlConnector"),(WCHAR*)WStr("MySqlConnector.MySqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig301,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.Config.LoggingConfigurationFileLoader"),(WCHAR*)WStr("Load"),sig099,3,6,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LoggingConfigurationFileLoaderLoadInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LogFactory"),(WCHAR*)WStr("ActivateLoggingConfiguration"),sig334,2,6,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LogFactoryActivateLoggingConfigurationInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LogFactory"),(WCHAR*)WStr("ActivateLoggingConfiguration"),sig335,2,6,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LogFactoryActivateLoggingConfigurationInstrumentation"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LogFactory"),(WCHAR*)WStr("BuildLoggerConfiguration"),sig100,3,5,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LogFactoryBuildLoggerConfiguration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LogFactory"),(WCHAR*)WStr("BuildLoggerConfiguration"),sig374,3,5,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LogFactoryGetConfigurationForLoggerInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LogFactory"),(WCHAR*)WStr("GetConfigurationForLogger"),sig374,3,2,1,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LogFactoryGetConfigurationForLoggerInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LoggerImpl"),(WCHAR*)WStr("Write"),sig388,5,1,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.LogsInjection.LoggerImplWriteIntegrationV4"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LoggerImpl"),(WCHAR*)WStr("Write"),sig388,5,5,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.LogsInjection.LoggerImplWriteIntegrationV5"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LogFactory"),(WCHAR*)WStr("BuildLoggerConfiguration"),sig375,3,5,0,0,5,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LogFactoryGetConfigurationForLoggerInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LogFactory"),(WCHAR*)WStr("GetConfigurationForLogger"),sig375,3,2,1,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.DirectSubmission.LogFactoryGetConfigurationForLoggerInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LoggerImpl"),(WCHAR*)WStr("Write"),sig389,5,1,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.LogsInjection.LoggerImplWriteIntegrationV4"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("NLog"),(WCHAR*)WStr("NLog.LoggerImpl"),(WCHAR*)WStr("Write"),sig389,5,5,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.NLog.LogsInjection.LoggerImplWriteIntegrationV5"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig293,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig296,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig101,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig102,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig278,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig279,3,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig301,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("Close"),sig197,4,4,0,0,8,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.Npgsql.ReaderCloseNpgsqlIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("GetString"),sig169,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("Read"),sig121,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Npgsql"),(WCHAR*)WStr("Npgsql.NpgsqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig301,2,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.CommandBuilder"),(WCHAR*)WStr("MakeSkipCommand"),sig103,2,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitCommandBuilderMakeTestCommandIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.CommandBuilder"),(WCHAR*)WStr("MakeTestCommand"),sig105,2,3,0,0,3,6,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitCommandBuilderMakeTestCommandIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.SimpleWorkItem"),(WCHAR*)WStr(".ctor"),sig336,4,3,13,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.SimpleWorkItemctor2Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.SimpleWorkItem"),(WCHAR*)WStr(".ctor"),sig335,3,3,7,0,3,12,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.SimpleWorkItemctorIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.SimpleWorkItem"),(WCHAR*)WStr(".ctor"),sig337,4,3,13,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.SimpleWorkItemctor2Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.SimpleWorkItem"),(WCHAR*)WStr(".ctor"),sig336,3,3,7,0,3,12,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.SimpleWorkItemctorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.SimpleWorkItem"),(WCHAR*)WStr("MakeTestCommand"),sig104,1,3,7,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitSimpleWorkItemMakeTestCommandIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.WorkItem"),(WCHAR*)WStr("PerformWork"),sig310,1,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitWorkItemPerformWorkIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.WorkItem"),(WCHAR*)WStr("WorkItemComplete"),sig310,1,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitWorkItemWorkItemCompleteIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.WorkItem"),(WCHAR*)WStr("PerformWork"),sig311,1,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitWorkItemPerformWorkIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Execution.WorkItem"),(WCHAR*)WStr("WorkItemComplete"),sig311,1,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitWorkItemWorkItemCompleteIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("nunit.framework"),(WCHAR*)WStr("NUnit.Framework.Internal.Reflect"),(WCHAR*)WStr("InvokeMethod"),sig165,4,3,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.NUnit.NUnitReflectInvokeMethodIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("OpenTelemetry"),(WCHAR*)WStr("OpenTelemetry.Trace.TracerProviderBuilderExtensions"),(WCHAR*)WStr("Build"),sig110,2,1,0,0,1,0,0,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.OpenTelemetry.TracerProviderBuilderIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("OpenTelemetry.Api"),(WCHAR*)WStr("OpenTelemetry.Trace.Tracer"),(WCHAR*)WStr("StartRootSpan"),sig108,6,1,0,0,1,0,0,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.OpenTelemetry.StartRootSpanIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("OpenTelemetry.Api"),(WCHAR*)WStr("OpenTelemetry.Trace.Tracer"),(WCHAR*)WStr("StartSpan"),sig109,7,1,0,0,1,0,0,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.OpenTelemetry.StartSpanIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig293,3,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig296,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig113,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig114,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig279,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig280,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig282,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig281,3,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig280,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig281,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig283,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig282,3,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("Close"),sig310,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig301,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("Close"),sig311,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("GetString"),sig169,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("Read"),sig121,1,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("Close"),sig310,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Oracle.DataAccess"),(WCHAR*)WStr("Oracle.DataAccess.Client.OracleDataReader"),(WCHAR*)WStr("ReadAsync"),sig301,2,4,122,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("Close"),sig311,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig293,3,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig293,3,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig296,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig296,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig115,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig116,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig115,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReader"),sig116,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig283,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig284,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig286,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig285,3,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig283,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig284,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig286,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig285,3,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig284,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig285,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig287,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig286,3,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig284,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig285,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig287,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig286,3,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig301,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig301,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("GetString"),sig169,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("GetValue"),sig162,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("Read"),sig121,1,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ReadAsync"),sig300,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("Close"),sig310,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleCommand"),(WCHAR*)WStr("ReadAsync"),sig301,2,2,0,0,4,122,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("Close"),sig311,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("GetString"),sig169,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("Read"),sig121,1,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Oracle.ManagedDataAccess"),(WCHAR*)WStr("Oracle.ManagedDataAccess.Client.OracleDataReader"),(WCHAR*)WStr("ReadAsync"),sig301,2,23,0,0,23,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Diagnostics.Process"),(WCHAR*)WStr("Start"),sig140,1,1,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Process.ProcessStartIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Diagnostics.Process"),(WCHAR*)WStr("System.Diagnostics.Process"),(WCHAR*)WStr("Start"),sig140,1,1,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Process.ProcessStartIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IBufferMessage"),(WCHAR*)WStr("InternalMergeFrom"),sig324,2,3,15,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.BufferMessageInternalMergeFromIntegration"),CallTargetKind::Interface,1,15}, -{(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IBufferMessage"),(WCHAR*)WStr("InternalWriteTo"),sig325,2,3,15,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.BufferMessageInternalWriteToIntegration"),CallTargetKind::Interface,1,15}, -{(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IMessage"),(WCHAR*)WStr("MergeFrom"),sig322,2,3,13,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.MessageMergeFromIntegration"),CallTargetKind::Interface,1,15}, -{(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IMessage"),(WCHAR*)WStr("MergeFrom"),sig322,2,3,0,0,3,12,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.OldMessageMergeFromIntegration"),CallTargetKind::Interface,1,15}, -{(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IMessage"),(WCHAR*)WStr("WriteTo"),sig323,2,3,13,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.MessageWriteToIntegration"),CallTargetKind::Interface,1,15}, -{(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IMessage"),(WCHAR*)WStr("WriteTo"),sig323,2,3,0,0,3,12,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.OldMessageWriteToIntegration"),CallTargetKind::Interface,1,15}, +{(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IBufferMessage"),(WCHAR*)WStr("InternalMergeFrom"),sig325,2,3,15,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.BufferMessageInternalMergeFromIntegration"),CallTargetKind::Interface,1,15}, +{(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IBufferMessage"),(WCHAR*)WStr("InternalWriteTo"),sig326,2,3,15,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.BufferMessageInternalWriteToIntegration"),CallTargetKind::Interface,1,15}, +{(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IMessage"),(WCHAR*)WStr("MergeFrom"),sig323,2,3,13,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.MessageMergeFromIntegration"),CallTargetKind::Interface,1,15}, +{(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IMessage"),(WCHAR*)WStr("MergeFrom"),sig323,2,3,0,0,3,12,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.OldMessageMergeFromIntegration"),CallTargetKind::Interface,1,15}, +{(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IMessage"),(WCHAR*)WStr("WriteTo"),sig324,2,3,13,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.MessageWriteToIntegration"),CallTargetKind::Interface,1,15}, +{(WCHAR*)WStr("Google.Protobuf"),(WCHAR*)WStr("Google.Protobuf.IMessage"),(WCHAR*)WStr("WriteTo"),sig324,2,3,0,0,3,12,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Protobuf.OldMessageWriteToIntegration"),CallTargetKind::Interface,1,15}, {(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.AsyncDefaultBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliver"),sig205,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverAsyncIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.AsyncDefaultBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliverAsync"),sig206,9,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverAsyncAsyncIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.DefaultBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliver"),sig386,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Framing.Impl.Model"),(WCHAR*)WStr("_Private_BasicPublish"),sig382,6,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicPublishIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Framing.Impl.Model"),(WCHAR*)WStr("_Private_ExchangeDeclare"),sig383,9,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.ExchangeDeclareIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Framing.Impl.Model"),(WCHAR*)WStr("_Private_QueueDeclare"),sig377,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.QueueDeclareIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.DefaultBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliver"),sig387,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverIntegration"),CallTargetKind::Derived,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Framing.Impl.Model"),(WCHAR*)WStr("_Private_BasicPublish"),sig383,6,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicPublishIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Framing.Impl.Model"),(WCHAR*)WStr("_Private_ExchangeDeclare"),sig384,9,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.ExchangeDeclareIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Framing.Impl.Model"),(WCHAR*)WStr("_Private_QueueDeclare"),sig378,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.QueueDeclareIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.IAsyncBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliver"),sig205,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverAsyncIntegration"),CallTargetKind::Interface,1,15}, {(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.IAsyncBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliverAsync"),sig206,9,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverAsyncAsyncIntegration"),CallTargetKind::Interface,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.IBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliver"),sig386,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverIntegration"),CallTargetKind::Interface,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("BasicConsumeAsync"),sig301,9,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicConsumeAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("BasicGetAsync"),sig287,4,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicGetAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("BasicPublishAsync"),sig304,7,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicPublishAsyncCachedStringsIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("BasicPublishAsync"),sig305,7,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicPublishAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.IBasicConsumer"),(WCHAR*)WStr("HandleBasicDeliver"),sig387,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicDeliverIntegration"),CallTargetKind::Interface,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("BasicConsumeAsync"),sig302,9,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicConsumeAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("BasicGetAsync"),sig288,4,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicGetAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("BasicPublishAsync"),sig305,7,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicPublishAsyncCachedStringsIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("BasicPublishAsync"),sig306,7,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicPublishAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("ExchangeDeclareAsync"),sig203,9,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.ExchangeDeclareAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("PopulateBasicPropertiesHeaders"),sig118,4,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.PopulateBasicPropertiesHeadersIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("QueueBindAsync"),sig204,7,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.QueueBindAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("QueueDeclareAsync"),sig288,9,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.QueueDeclareAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.Channel"),(WCHAR*)WStr("QueueDeclareAsync"),sig289,9,7,0,0,7,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.QueueDeclareAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.ModelBase"),(WCHAR*)WStr("BasicConsume"),sig172,8,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicConsumeIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.ModelBase"),(WCHAR*)WStr("BasicGet"),sig117,3,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.BasicGetIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.ModelBase"),(WCHAR*)WStr("QueueBind"),sig385,5,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.QueueBindIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("RabbitMQ.Client"),(WCHAR*)WStr("RabbitMQ.Client.Impl.ModelBase"),(WCHAR*)WStr("QueueBind"),sig386,5,3,6,9,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.RabbitMQ.QueueBindIntegration"),CallTargetKind::Default,1,15}, #if _WIN32 {(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.BinaryClientFormatterSink"),(WCHAR*)WStr("SyncProcessMessage"),sig167,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.SyncProcessMessageIntegration"),CallTargetKind::Default,1,1}, {(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.BinaryServerFormatterSink"),(WCHAR*)WStr("ProcessMessage"),sig166,8,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Server.ProcessMessageIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.BinaryServerFormatterSink"),(WCHAR*)WStr("SerializeResponse"),sig367,5,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Server.BinarySerializeResponseIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.BinaryServerFormatterSink"),(WCHAR*)WStr("SerializeResponse"),sig368,5,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Server.BinarySerializeResponseIntegration"),CallTargetKind::Default,1,1}, {(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Http.HttpClientTransportSink"),(WCHAR*)WStr("ProcessAndSend"),sig155,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.HttpProcessAndSendIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Http.HttpClientTransportSink"),(WCHAR*)WStr("ProcessMessage"),sig368,6,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.HttpProcessMessageIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Http.HttpClientTransportSink"),(WCHAR*)WStr("ProcessResponseException"),sig363,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.HttpProcessResponseExceptionIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Http.HttpClientTransportSink"),(WCHAR*)WStr("ReceiveAndProcess"),sig362,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.HttpReceiveAndProcessIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Ipc.IpcClientTransportSink"),(WCHAR*)WStr("ProcessMessage"),sig368,6,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.IpcTcpProcessMessageIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Http.HttpClientTransportSink"),(WCHAR*)WStr("ProcessMessage"),sig369,6,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.HttpProcessMessageIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Http.HttpClientTransportSink"),(WCHAR*)WStr("ProcessResponseException"),sig364,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.HttpProcessResponseExceptionIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Http.HttpClientTransportSink"),(WCHAR*)WStr("ReceiveAndProcess"),sig363,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.HttpReceiveAndProcessIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Ipc.IpcClientTransportSink"),(WCHAR*)WStr("ProcessMessage"),sig369,6,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.IpcTcpProcessMessageIntegration"),CallTargetKind::Default,1,1}, {(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.SoapClientFormatterSink"),(WCHAR*)WStr("SyncProcessMessage"),sig167,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.SyncProcessMessageIntegration"),CallTargetKind::Default,1,1}, {(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.SoapServerFormatterSink"),(WCHAR*)WStr("ProcessMessage"),sig166,8,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Server.ProcessMessageIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.SoapServerFormatterSink"),(WCHAR*)WStr("SerializeResponse"),sig366,6,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Server.SoapSerializeResponseIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Tcp.TcpClientTransportSink"),(WCHAR*)WStr("ProcessMessage"),sig368,6,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.IpcTcpProcessMessageIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.SoapServerFormatterSink"),(WCHAR*)WStr("SerializeResponse"),sig367,6,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Server.SoapSerializeResponseIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.Runtime.Remoting"),(WCHAR*)WStr("System.Runtime.Remoting.Channels.Tcp.TcpClientTransportSink"),(WCHAR*)WStr("ProcessMessage"),sig369,6,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Remoting.Client.IpcTcpProcessMessageIntegration"),CallTargetKind::Default,1,1}, #endif -{(WCHAR*)WStr("WebDriver"),(WCHAR*)WStr("OpenQA.Selenium.Remote.HttpCommandExecutor"),(WCHAR*)WStr("OnSendingRemoteHttpRequest"),sig337,2,3,12,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.Selenium.HttpCommandExecutorOnSendingRemoteHttpRequestIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("WebDriver"),(WCHAR*)WStr("OpenQA.Selenium.Remote.HttpCommandExecutor"),(WCHAR*)WStr("OnSendingRemoteHttpRequest"),sig338,2,3,12,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.Selenium.HttpCommandExecutorOnSendingRemoteHttpRequestIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("WebDriver"),(WCHAR*)WStr("OpenQA.Selenium.Remote.RemoteWebDriver"),(WCHAR*)WStr("Execute"),sig106,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.Selenium.WebDriverExecuteIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("WebDriver"),(WCHAR*)WStr("OpenQA.Selenium.Remote.RemoteWebDriver"),(WCHAR*)WStr("Execute"),sig106,3,3,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.Selenium.WebDriverExecuteIntegration"),CallTargetKind::Derived,1,15}, {(WCHAR*)WStr("WebDriver"),(WCHAR*)WStr("OpenQA.Selenium.WebDriver"),(WCHAR*)WStr("Execute"),sig107,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.Selenium.WebDriverExecuteIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("WebDriver"),(WCHAR*)WStr("OpenQA.Selenium.WebDriver"),(WCHAR*)WStr("Execute"),sig107,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.Selenium.WebDriverExecuteIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("Serilog"),(WCHAR*)WStr("Serilog.Core.Logger"),(WCHAR*)WStr("Dispatch"),sig338,2,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.Serilog.LogsInjection.LoggerDispatchInstrumentation"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Serilog"),(WCHAR*)WStr("Serilog.Core.Pipeline.Logger"),(WCHAR*)WStr("Dispatch"),sig338,2,1,4,0,1,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.Serilog.LogsInjection.LoggerDispatchInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Serilog"),(WCHAR*)WStr("Serilog.Core.Logger"),(WCHAR*)WStr("Dispatch"),sig339,2,2,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.Serilog.LogsInjection.LoggerDispatchInstrumentation"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Serilog"),(WCHAR*)WStr("Serilog.Core.Pipeline.Logger"),(WCHAR*)WStr("Dispatch"),sig339,2,1,4,0,1,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.Serilog.LogsInjection.LoggerDispatchInstrumentation"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Serilog"),(WCHAR*)WStr("Serilog.LoggerConfiguration"),(WCHAR*)WStr("CreateLogger"),sig119,1,1,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Logging.Serilog.DirectSubmission.LoggerConfigurationInstrumentation"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("ServiceStack.Redis"),(WCHAR*)WStr("ServiceStack.Redis.RedisNativeClient"),(WCHAR*)WStr("SendReceive"),sig002,5,4,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.ServiceStack.RedisNativeClientSendReceiveIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("ServiceStack.Redis"),(WCHAR*)WStr("ServiceStack.Redis.RedisNativeClient"),(WCHAR*)WStr("SendReceive"),sig003,6,6,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Redis.ServiceStack.RedisNativeClientSendReceiveIntegration_6_2_0"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig293,3,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig296,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig082,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig083,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig266,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig269,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig267,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig268,3,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig267,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig270,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig268,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig269,3,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Close"),sig310,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig301,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Close"),sig311,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetString"),sig169,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Read"),sig121,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("Close"),sig310,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Microsoft.Data.SqlClient"),(WCHAR*)WStr("Microsoft.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig301,2,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("Close"),sig311,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("GetString"),sig169,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("Read"),sig121,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteDataReader"),(WCHAR*)WStr("ReadAsync"),sig301,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig293,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig296,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig136,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig137,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig293,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig294,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Close"),sig310,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig301,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Close"),sig311,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetString"),sig169,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Read"),sig121,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig301,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig293,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig295,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteNonQueryAsync"),sig296,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig136,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReader"),sig137,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig293,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig294,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig300,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Close"),sig310,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlCommand"),(WCHAR*)WStr("ExecuteScalarAsync"),sig301,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Close"),sig311,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetString"),sig169,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("Read"),sig121,1,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("Close"),sig310,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data.SqlClient"),(WCHAR*)WStr("System.Data.SqlClient.SqlDataReader"),(WCHAR*)WStr("ReadAsync"),sig301,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("Close"),sig311,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderCloseIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("GetString"),sig169,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("GetValue"),sig162,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderGetStringIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("Read"),sig121,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadIntegration"),CallTargetKind::Default,4,15}, -{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("ReadAsync"),sig300,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, +{(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteDataReader"),(WCHAR*)WStr("ReadAsync"),sig301,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.ReaderReadAsyncIntegration"),CallTargetKind::Default,4,15}, {(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig292,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteDbDataReaderAsync"),sig293,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteReader"),sig084,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteReader"),sig085,2,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig270,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteReaderAsync"),sig271,3,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorAndCancellationAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("Microsoft.Data.Sqlite"),(WCHAR*)WStr("Microsoft.Data.Sqlite.SqliteCommand"),(WCHAR*)WStr("ExecuteScalar"),sig160,1,2,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteScalarIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteCommand"),(WCHAR*)WStr("ExecuteDbDataReader"),sig135,2,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteReaderWithBehaviorIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Data.SQLite"),(WCHAR*)WStr("System.Data.SQLite.SQLiteCommand"),(WCHAR*)WStr("ExecuteNonQuery"),sig146,1,1,0,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AdoNet.CommandExecuteNonQueryIntegration"),CallTargetKind::Default,1,15}, @@ -1181,19 +1183,19 @@ std::vector callTargets = {(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics"),(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddleware"),(WCHAR*)WStr("DisplayException"),sig190,2,3,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.StackTraceLeak.DeveloperExceptionPageMiddlewareIntegration_Pre_3_0_0"),CallTargetKind::Default,4,14}, {(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics"),(WCHAR*)WStr("Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddlewareImpl"),(WCHAR*)WStr("DisplayException"),sig190,2,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.StackTraceLeak.DeveloperExceptionPageMiddlewareIntegration_Pre_3_0_0"),CallTargetKind::Default,4,14}, #if _WIN32 -{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.HttpResponse"),(WCHAR*)WStr("WriteErrorMessage"),sig359,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.StackTraceLeak.HttpResponseIntegration"),CallTargetKind::Default,4,1}, +{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.HttpResponse"),(WCHAR*)WStr("WriteErrorMessage"),sig360,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.StackTraceLeak.HttpResponseIntegration"),CallTargetKind::Default,4,1}, #endif -{(WCHAR*)WStr("System.Security.Cryptography"),(WCHAR*)WStr("System.Security.Cryptography.SymmetricAlgorithm"),(WCHAR*)WStr(".ctor"),sig310,1,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CryptographyAlgorithm.SymmetricAlgorithmIntegration"),CallTargetKind::Default,4,14}, -{(WCHAR*)WStr("System.Security.Cryptography.Primitives"),(WCHAR*)WStr("System.Security.Cryptography.SymmetricAlgorithm"),(WCHAR*)WStr(".ctor"),sig310,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CryptographyAlgorithm.SymmetricAlgorithmIntegration"),CallTargetKind::Default,4,14}, -{(WCHAR*)WStr("Microsoft.TestPlatform.PlatformAbstractions"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.PlatformAbstractions.PlatformAssemblyResolver"),(WCHAR*)WStr(".ctor"),sig310,1,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.PlatformAssemblyResolverAssemblyResolverEventIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("System.Security.Cryptography"),(WCHAR*)WStr("System.Security.Cryptography.SymmetricAlgorithm"),(WCHAR*)WStr(".ctor"),sig311,1,7,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CryptographyAlgorithm.SymmetricAlgorithmIntegration"),CallTargetKind::Default,4,14}, +{(WCHAR*)WStr("System.Security.Cryptography.Primitives"),(WCHAR*)WStr("System.Security.Cryptography.SymmetricAlgorithm"),(WCHAR*)WStr(".ctor"),sig311,1,1,0,0,6,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.CryptographyAlgorithm.SymmetricAlgorithmIntegration"),CallTargetKind::Default,4,14}, +{(WCHAR*)WStr("Microsoft.TestPlatform.PlatformAbstractions"),(WCHAR*)WStr("Microsoft.VisualStudio.TestPlatform.PlatformAbstractions.PlatformAssemblyResolver"),(WCHAR*)WStr(".ctor"),sig311,1,15,0,0,15,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.PlatformAssemblyResolverAssemblyResolverEventIntegration"),CallTargetKind::Default,1,15}, #if _WIN32 {(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.AsyncMethodInvoker"),(WCHAR*)WStr("InvokeBegin"),sig144,5,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.AsyncMethodInvoker_InvokeBegin_Integration"),CallTargetKind::Default,1,1}, {(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.AsyncMethodInvoker"),(WCHAR*)WStr("InvokeEnd"),sig164,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.AsyncMethodInvoker_InvokeEnd_Integration"),CallTargetKind::Default,1,1}, {(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.ChannelHandler"),(WCHAR*)WStr("HandleRequest"),sig125,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.ChannelHandlerIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.ImmutableDispatchRuntime"),(WCHAR*)WStr("AfterReceiveRequest"),sig369,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.AfterReceiveRequestIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.ImmutableDispatchRuntime"),(WCHAR*)WStr("BeforeSendReply"),sig370,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.BeforeSendReplyIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.ImmutableDispatchRuntime"),(WCHAR*)WStr("AfterReceiveRequest"),sig370,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.AfterReceiveRequestIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.ImmutableDispatchRuntime"),(WCHAR*)WStr("BeforeSendReply"),sig371,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.BeforeSendReplyIntegration"),CallTargetKind::Default,1,1}, {(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.SyncMethodInvoker"),(WCHAR*)WStr("Invoke"),sig163,4,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.SyncMethodInvokerIntegration"),CallTargetKind::Default,1,1}, -{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.TaskMethodInvoker"),(WCHAR*)WStr("InvokeAsync"),sig302,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.TaskMethodInvokerIntegration"),CallTargetKind::Default,1,1}, +{(WCHAR*)WStr("System.ServiceModel"),(WCHAR*)WStr("System.ServiceModel.Dispatcher.TaskMethodInvoker"),(WCHAR*)WStr("InvokeAsync"),sig303,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Wcf.TaskMethodInvokerIntegration"),CallTargetKind::Default,1,1}, #endif {(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("BeginGetRequestStream"),sig143,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_BeginGetRequestStream_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("BeginGetResponse"),sig143,3,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_BeginGetResponse_Integration"),CallTargetKind::Default,1,15}, @@ -1208,31 +1210,31 @@ std::vector callTargets = {(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("GetRequestStream"),sig152,1,9,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_GetRequestStreamV9_Integration"),CallTargetKind::Default,1,8}, {(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.HttpWebRequest"),(WCHAR*)WStr("GetResponse"),sig156,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.HttpWebRequest_GetResponse_Integration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("System.Net.Requests"),(WCHAR*)WStr("System.Net.WebRequest"),(WCHAR*)WStr("GetResponseAsync"),sig211,1,4,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.WebRequest.WebRequest_GetResponseAsync_Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("Microsoft.AspNetCore.Html.Abstractions"),(WCHAR*)WStr("Microsoft.AspNetCore.Html.HtmlString"),(WCHAR*)WStr(".ctor"),sig371,2,1,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.Html.HtmlStringIntegration"),CallTargetKind::Default,4,14}, +{(WCHAR*)WStr("Microsoft.AspNetCore.Html.Abstractions"),(WCHAR*)WStr("Microsoft.AspNetCore.Html.HtmlString"),(WCHAR*)WStr(".ctor"),sig372,2,1,0,0,10,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.Html.HtmlStringIntegration"),CallTargetKind::Default,4,14}, #if _WIN32 -{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.HtmlString"),(WCHAR*)WStr(".ctor"),sig371,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.Html.HtmlStringIntegration"),CallTargetKind::Default,4,1}, +{(WCHAR*)WStr("System.Web"),(WCHAR*)WStr("System.Web.HtmlString"),(WCHAR*)WStr(".ctor"),sig372,2,4,0,0,4,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.AspNetCore.Html.HtmlStringIntegration"),CallTargetKind::Default,4,1}, #endif {(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("BeforeTestAssemblyFinishedAsync"),sig175,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerBeforeTestAssemblyFinishedAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("BeforeTestAssemblyFinishedAsync"),sig175,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerBeforeTestAssemblyFinishedAsyncIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("RunAsync"),sig303,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestClassRunner`1"),(WCHAR*)WStr("RunAsync"),sig303,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestClassRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestInvoker`1"),(WCHAR*)WStr("RunAsync"),sig294,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestInvokerRunAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestOutputHelper"),(WCHAR*)WStr("QueueTestOutput"),sig371,2,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestOutputHelperQueueTestOutputIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestRunner`1"),(WCHAR*)WStr("RunAsync"),sig303,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("RunAsync"),sig304,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestClassRunner`1"),(WCHAR*)WStr("RunAsync"),sig304,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestClassRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestInvoker`1"),(WCHAR*)WStr("RunAsync"),sig295,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestInvokerRunAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestOutputHelper"),(WCHAR*)WStr("QueueTestOutput"),sig372,2,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestOutputHelperQueueTestOutputIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.execution.desktop"),(WCHAR*)WStr("Xunit.Sdk.TestRunner`1"),(WCHAR*)WStr("RunAsync"),sig304,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("BeforeTestAssemblyFinishedAsync"),sig175,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerBeforeTestAssemblyFinishedAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("BeforeTestAssemblyFinishedAsync"),sig175,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerBeforeTestAssemblyFinishedAsyncIntegration"),CallTargetKind::Derived,1,15}, -{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("RunAsync"),sig303,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestClassRunner`1"),(WCHAR*)WStr("RunAsync"),sig303,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestClassRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestAssemblyRunner`1"),(WCHAR*)WStr("RunAsync"),sig304,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestAssemblyRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestClassRunner`1"),(WCHAR*)WStr("RunAsync"),sig304,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestClassRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, {(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestFrameworkDiscoverer"),(WCHAR*)WStr("ReportDiscoveredTestCase"),sig126,4,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.TestFrameworkDiscovererReportDiscoveredTestCaseIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestInvoker`1"),(WCHAR*)WStr("RunAsync"),sig294,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestInvokerRunAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestOutputHelper"),(WCHAR*)WStr("QueueTestOutput"),sig371,2,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestOutputHelperQueueTestOutputIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestRunner`1"),(WCHAR*)WStr("RunAsync"),sig303,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.TestAssemblyRunner`4"),(WCHAR*)WStr("Run"),sig307,2,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XUnitTestAssemblyRunnerRunV3Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.TestClassRunner`4"),(WCHAR*)WStr("Run"),sig307,2,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XUnitTestClassRunnerRunV3Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.TestOutputHelper"),(WCHAR*)WStr("QueueTestOutput"),sig371,2,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XUnitTestOutputHelperQueueTestOutputV3Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.TestRunner`2"),(WCHAR*)WStr("RunTest"),sig306,2,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XUnitTestRunnerV3Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.XunitTestMethodRunnerBase`3"),(WCHAR*)WStr("RunTestCase"),sig308,3,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XUnitTestMethodRunnerBaseRunTestCaseV3Integration"),CallTargetKind::Default,1,15}, -{(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.XunitTestMethodRunnerContext"),(WCHAR*)WStr(".ctor"),sig389,8,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XunitTestMethodRunnerContextCtorV3Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestInvoker`1"),(WCHAR*)WStr("RunAsync"),sig295,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestInvokerRunAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestOutputHelper"),(WCHAR*)WStr("QueueTestOutput"),sig372,2,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestOutputHelperQueueTestOutputIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.execution.dotnet"),(WCHAR*)WStr("Xunit.Sdk.TestRunner`1"),(WCHAR*)WStr("RunAsync"),sig304,1,2,2,0,2,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.XUnitTestRunnerRunAsyncIntegration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.TestAssemblyRunner`4"),(WCHAR*)WStr("Run"),sig308,2,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XUnitTestAssemblyRunnerRunV3Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.TestClassRunner`4"),(WCHAR*)WStr("Run"),sig308,2,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XUnitTestClassRunnerRunV3Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.TestOutputHelper"),(WCHAR*)WStr("QueueTestOutput"),sig372,2,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XUnitTestOutputHelperQueueTestOutputV3Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.TestRunner`2"),(WCHAR*)WStr("RunTest"),sig307,2,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XUnitTestRunnerV3Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.XunitTestMethodRunnerBase`3"),(WCHAR*)WStr("RunTestCase"),sig309,3,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XUnitTestMethodRunnerBaseRunTestCaseV3Integration"),CallTargetKind::Default,1,15}, +{(WCHAR*)WStr("xunit.v3.core"),(WCHAR*)WStr("Xunit.v3.XunitTestMethodRunnerContext"),(WCHAR*)WStr(".ctor"),sig390,8,1,0,0,3,65535,65535,assemblyName,(WCHAR*)WStr("Datadog.Trace.ClrProfiler.AutoInstrumentation.Testing.XUnit.V3.XunitTestMethodRunnerContextCtorV3Integration"),CallTargetKind::Default,1,15}, }; return profiler->RegisterCallTargetDefinitions((WCHAR*) WStr("Tracing"), callTargets.data(), callTargets.size(), enabledCategories, platform); }