internal Tracer(TracerSettings settings, IAgentWriter agentWriter, ISampler sampler, IScopeManager scopeManager, IStatsd statsd)
{
// update the count of Tracer instances
Interlocked.Increment(ref _liveTracerCount);
Settings = settings ?? TracerSettings.FromDefaultSources();
// if not configured, try to determine an appropriate service name
DefaultServiceName = Settings.ServiceName ??
GetApplicationName() ??
UnknownServiceName;
// only set DogStatsdClient if tracer metrics are enabled
if (Settings.TracerMetricsEnabled)
{
Statsd = statsd ?? CreateDogStatsdClient(Settings, DefaultServiceName);
}
// fall back to default implementations of each dependency if not provided
IApi apiClient = new Api(Settings.AgentUri, delegatingHandler: null, Statsd);
_agentWriter = agentWriter ?? new AgentWriter(apiClient, Statsd);
_scopeManager = scopeManager ?? new AsyncLocalScopeManager();
Sampler = sampler ?? new RuleBasedSampler(new RateLimiter(Settings.MaxTracesSubmittedPerSecond));
if (!string.IsNullOrWhiteSpace(Settings.CustomSamplingRules))
{
// User has opted in, ensure rate limiter is used
RuleBasedSampler.OptInTracingWithoutLimits();
foreach (var rule in CustomSamplingRule.BuildFromConfigurationString(Settings.CustomSamplingRules))
{
Sampler.RegisterRule(rule);
}
}
// Register callbacks to make sure we flush the traces before exiting
AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit;
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
Console.CancelKeyPress += Console_CancelKeyPress;
// start the heartbeat loop
_heartbeatTimer = new Timer(HeartbeatCallback, state: null, dueTime: TimeSpan.Zero, period: TimeSpan.FromMinutes(1));
// If configured, add/remove the correlation identifiers into the
// LibLog logging context when a scope is activated/closed
if (Settings.LogsInjectionEnabled)
{
InitializeLibLogScopeEventSubscriber(_scopeManager);
}
}
public void Constructs_All_Expected_From_Config_String()
{
var config = "[{\"sample_rate\":0.5, \"service\":\".*cart.*\"}, {\"sample_rate\":1, \"service\":\".*shipping.*\", \"name\":\"authorize\"}, {\"sample_rate\":0.1, \"service\":\".*shipping.*\"}, {\"sample_rate\":0.05}]";
var rules = CustomSamplingRule.BuildFromConfigurationString(config).ToArray();
var cartRule = rules[0];
Assert.Equal(expected: 0.5f, actual: cartRule.GetSamplingRate(CartCheckoutSpan));
VerifySingleRule(cartRule, CartCheckoutSpan, true);
VerifySingleRule(cartRule, AddToCartSpan, true);
VerifySingleRule(cartRule, ShippingAuthSpan, false);
VerifySingleRule(cartRule, ShippingRevertSpan, false);
VerifySingleRule(cartRule, RequestShippingSpan, false);
var shippingAuthRule = rules[1];
Assert.Equal(expected: 1f, actual: shippingAuthRule.GetSamplingRate(CartCheckoutSpan));
VerifySingleRule(shippingAuthRule, CartCheckoutSpan, false);
VerifySingleRule(shippingAuthRule, AddToCartSpan, false);
VerifySingleRule(shippingAuthRule, ShippingAuthSpan, true);
VerifySingleRule(shippingAuthRule, ShippingRevertSpan, false);
VerifySingleRule(shippingAuthRule, RequestShippingSpan, false);
var fallbackShippingRule = rules[2];
Assert.Equal(expected: 0.1f, actual: fallbackShippingRule.GetSamplingRate(CartCheckoutSpan));
VerifySingleRule(fallbackShippingRule, CartCheckoutSpan, false);
VerifySingleRule(fallbackShippingRule, AddToCartSpan, false);
VerifySingleRule(fallbackShippingRule, ShippingAuthSpan, true);
VerifySingleRule(fallbackShippingRule, ShippingRevertSpan, true);
VerifySingleRule(fallbackShippingRule, RequestShippingSpan, true);
var fallbackRule = rules[3];
Assert.Equal(expected: 0.05f, actual: fallbackRule.GetSamplingRate(CartCheckoutSpan));
VerifySingleRule(fallbackRule, CartCheckoutSpan, true);
VerifySingleRule(fallbackRule, AddToCartSpan, true);
VerifySingleRule(fallbackRule, ShippingAuthSpan, true);
VerifySingleRule(fallbackRule, ShippingRevertSpan, true);
VerifySingleRule(fallbackRule, RequestShippingSpan, true);
}
internal Tracer(TracerSettings settings, IAgentWriter agentWriter, ISampler sampler, IScopeManager scopeManager, IStatsd statsd)
{
// update the count of Tracer instances
Interlocked.Increment(ref _liveTracerCount);
Settings = settings ?? TracerSettings.FromDefaultSources();
// if not configured, try to determine an appropriate service name
DefaultServiceName = Settings.ServiceName ??
GetApplicationName() ??
UnknownServiceName;
// only set DogStatsdClient if tracer metrics are enabled
if (Settings.TracerMetricsEnabled)
{
// Run this first in case the port override is ready
TracingProcessManager.SubscribeToDogStatsDPortOverride(
port =>
{
Log.Debug("Attempting to override dogstatsd port with {0}", port);
Statsd = CreateDogStatsdClient(Settings, DefaultServiceName, port);
});
Statsd = statsd ?? CreateDogStatsdClient(Settings, DefaultServiceName, Settings.DogStatsdPort);
}
// Run this first in case the port override is ready
TracingProcessManager.SubscribeToTraceAgentPortOverride(
port =>
{
Log.Debug("Attempting to override trace agent port with {0}", port);
var builder = new UriBuilder(Settings.AgentUri)
{
Port = port
};
var baseEndpoint = builder.Uri;
IApi overridingApiClient = new Api(baseEndpoint, delegatingHandler: null, Statsd);
if (_agentWriter == null)
{
_agentWriter = _agentWriter ?? new AgentWriter(overridingApiClient, Statsd);
}
else
{
_agentWriter.OverrideApi(overridingApiClient);
}
});
// fall back to default implementations of each dependency if not provided
_agentWriter = agentWriter ?? new AgentWriter(new Api(Settings.AgentUri, delegatingHandler: null, Statsd), Statsd);
_scopeManager = scopeManager ?? new AsyncLocalScopeManager();
Sampler = sampler ?? new RuleBasedSampler(new RateLimiter(Settings.MaxTracesSubmittedPerSecond));
if (!string.IsNullOrWhiteSpace(Settings.CustomSamplingRules))
{
// User has opted in, ensure rate limiter is used
RuleBasedSampler.OptInTracingWithoutLimits();
foreach (var rule in CustomSamplingRule.BuildFromConfigurationString(Settings.CustomSamplingRules))
{
Sampler.RegisterRule(rule);
}
}
if (Settings.GlobalSamplingRate != null)
{
var globalRate = (float)Settings.GlobalSamplingRate;
if (globalRate < 0f || globalRate > 1f)
{
Log.Warning("{0} configuration of {1} is out of range", ConfigurationKeys.GlobalSamplingRate, Settings.GlobalSamplingRate);
}
else
{
Sampler.RegisterRule(new GlobalSamplingRule(globalRate));
}
}
// Register callbacks to make sure we flush the traces before exiting
AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit;
AppDomain.CurrentDomain.DomainUnload += CurrentDomain_DomainUnload;
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
Console.CancelKeyPress += Console_CancelKeyPress;
// start the heartbeat loop
_heartbeatTimer = new Timer(HeartbeatCallback, state: null, dueTime: TimeSpan.Zero, period: TimeSpan.FromMinutes(1));
// If configured, add/remove the correlation identifiers into the
// LibLog logging context when a scope is activated/closed
if (Settings.LogsInjectionEnabled)
{
InitializeLibLogScopeEventSubscriber(_scopeManager, DefaultServiceName, Settings.ServiceVersion, Settings.Environment);
}
}
private void VerifySingleRule(string config, Span span, bool isMatch)
{
var rule = CustomSamplingRule.BuildFromConfigurationString(config).Single();
VerifySingleRule(rule, span, isMatch);
}
private void VerifyRate(string config, float expectedRate)
{
var rule = CustomSamplingRule.BuildFromConfigurationString(config).Single();
Assert.Equal(expected: expectedRate, actual: rule.GetSamplingRate(CartCheckoutSpan));
}
public void Malformed_Rules_Do_Not_Register_Or_Crash(string ruleConfig)
{
var rules = CustomSamplingRule.BuildFromConfigurationString(ruleConfig).ToArray();
Assert.Empty(rules);
}
internal Tracer(TracerSettings settings, IAgentWriter agentWriter, ISampler sampler, IScopeManager scopeManager, IDogStatsd statsd)
{
// update the count of Tracer instances
Interlocked.Increment(ref _liveTracerCount);
Settings = settings ?? TracerSettings.FromDefaultSources();
// if not configured, try to determine an appropriate service name
DefaultServiceName = Settings.ServiceName ??
GetApplicationName() ??
UnknownServiceName;
// only set DogStatsdClient if tracer metrics are enabled
if (Settings.TracerMetricsEnabled)
{
// Run this first in case the port override is ready
TracingProcessManager.SubscribeToDogStatsDPortOverride(
port =>
{
Log.Debug("Attempting to override dogstatsd port with {0}", port);
Statsd = CreateDogStatsdClient(Settings, DefaultServiceName, port);
});
Statsd = statsd ?? CreateDogStatsdClient(Settings, DefaultServiceName, Settings.DogStatsdPort);
}
// Run this first in case the port override is ready
TracingProcessManager.SubscribeToTraceAgentPortOverride(
port =>
{
Log.Debug("Attempting to override trace agent port with {0}", port);
var builder = new UriBuilder(Settings.AgentUri)
{
Port = port
};
var baseEndpoint = builder.Uri;
if (_agentWriter == null)
{
IApi overridingApiClient = new Api(baseEndpoint, apiRequestFactory: null, Statsd);
_agentWriter = _agentWriter ?? new AgentWriter(overridingApiClient, Statsd, queueSize: Settings.TraceQueueSize);
}
else
{
_agentWriter.SetApiBaseEndpoint(baseEndpoint);
}
});
// fall back to default implementations of each dependency if not provided
_agentWriter = agentWriter ?? new AgentWriter(new Api(Settings.AgentUri, apiRequestFactory: null, Statsd), Statsd, queueSize: Settings.TraceQueueSize);
_scopeManager = scopeManager ?? new AsyncLocalScopeManager();
Sampler = sampler ?? new RuleBasedSampler(new RateLimiter(Settings.MaxTracesSubmittedPerSecond));
if (!string.IsNullOrWhiteSpace(Settings.CustomSamplingRules))
{
foreach (var rule in CustomSamplingRule.BuildFromConfigurationString(Settings.CustomSamplingRules))
{
Sampler.RegisterRule(rule);
}
}
if (Settings.GlobalSamplingRate != null)
{
var globalRate = (float)Settings.GlobalSamplingRate;
if (globalRate < 0f || globalRate > 1f)
{
Log.Warning("{0} configuration of {1} is out of range", ConfigurationKeys.GlobalSamplingRate, Settings.GlobalSamplingRate);
}
else
{
Sampler.RegisterRule(new GlobalSamplingRule(globalRate));
}
}
// Register callbacks to make sure we flush the traces before exiting
AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit;
AppDomain.CurrentDomain.DomainUnload += CurrentDomain_DomainUnload;
try
{
// Registering for the AppDomain.UnhandledException event cannot be called by a security transparent method
// This will only happen if the Tracer is not run full-trust
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
}
catch (Exception ex)
{
Log.Warning(ex, "Unable to register a callback to the AppDomain.UnhandledException event.");
}
try
{
// Registering for the cancel key press event requires the System.Security.Permissions.UIPermission
Console.CancelKeyPress += Console_CancelKeyPress;
}
catch (Exception ex)
{
Log.Warning(ex, "Unable to register a callback to the Console.CancelKeyPress event.");
}
// start the heartbeat loop
_heartbeatTimer = new Timer(HeartbeatCallback, state: null, dueTime: TimeSpan.Zero, period: TimeSpan.FromMinutes(1));
// If configured, add/remove the correlation identifiers into the
// LibLog logging context when a scope is activated/closed
if (Settings.LogsInjectionEnabled)
{
InitializeLibLogScopeEventSubscriber(_scopeManager, DefaultServiceName, Settings.ServiceVersion, Settings.Environment);
}
if (Interlocked.Exchange(ref _firstInitialization, 0) == 1)
{
if (Settings.StartupDiagnosticLogEnabled)
{
_ = WriteDiagnosticLog();
}
if (Settings.RuntimeMetricsEnabled)
{
_runtimeMetricsWriter = new RuntimeMetricsWriter(Statsd ?? CreateDogStatsdClient(Settings, DefaultServiceName, Settings.DogStatsdPort), 10000);
}
}
}
internal Tracer(TracerSettings settings, IAgentWriter agentWriter, ISampler sampler, IScopeManager scopeManager, IDogStatsd statsd)
{
// update the count of Tracer instances
Interlocked.Increment(ref _liveTracerCount);
Settings = settings ?? TracerSettings.FromDefaultSources();
Settings.Freeze();
// if not configured, try to determine an appropriate service name
DefaultServiceName = Settings.ServiceName ??
GetApplicationName() ??
UnknownServiceName;
// only set DogStatsdClient if tracer metrics are enabled
if (Settings.TracerMetricsEnabled)
{
Statsd = statsd ?? CreateDogStatsdClient(Settings, DefaultServiceName, Settings.DogStatsdPort);
}
// fall back to default implementations of each dependency if not provided
if (agentWriter != null)
{
_agentWriter = agentWriter;
}
else
{
IApi api = null;
switch (Settings.Exporter)
{
case ExporterType.Zipkin:
api = new ZipkinApi(Settings);
break;
case ExporterType.DatadogAgent:
default:
api = new Api(Settings.AgentUri, TransportStrategy.Get(Settings), Statsd);
break;
}
_agentWriter = new AgentWriter(api, Statsd, queueSize: Settings.TraceQueueSize);
}
_scopeManager = scopeManager ?? new AsyncLocalScopeManager();
Sampler = sampler ?? new RuleBasedSampler(new RateLimiter(Settings.MaxTracesSubmittedPerSecond));
if (!string.IsNullOrWhiteSpace(Settings.CustomSamplingRules))
{
foreach (var rule in CustomSamplingRule.BuildFromConfigurationString(Settings.CustomSamplingRules))
{
Sampler.RegisterRule(rule);
}
}
if (Settings.GlobalSamplingRate != null)
{
var globalRate = (float)Settings.GlobalSamplingRate;
if (globalRate < 0f || globalRate > 1f)
{
Log.Warning("{ConfigurationKey} configuration of {ConfigurationValue} is out of range", ConfigurationKeys.GlobalSamplingRate, Settings.GlobalSamplingRate);
}
else
{
Sampler.RegisterRule(new GlobalSamplingRule(globalRate));
}
}
// Register callbacks to make sure we flush the traces before exiting
AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit;
AppDomain.CurrentDomain.DomainUnload += CurrentDomain_DomainUnload;
try
{
// Registering for the AppDomain.UnhandledException event cannot be called by a security transparent method
// This will only happen if the Tracer is not run full-trust
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
}
catch (Exception ex)
{
Log.Warning(ex, "Unable to register a callback to the AppDomain.UnhandledException event.");
}
try
{
// Registering for the cancel key press event requires the System.Security.Permissions.UIPermission
Console.CancelKeyPress += Console_CancelKeyPress;
}
catch (Exception ex)
{
Log.Warning(ex, "Unable to register a callback to the Console.CancelKeyPress event.");
}
// start the heartbeat loop
_heartbeatTimer = new Timer(HeartbeatCallback, state: null, dueTime: TimeSpan.Zero, period: TimeSpan.FromMinutes(1));
// If configured, add/remove the correlation identifiers into the
// LibLog logging context when a scope is activated/closed
if (Settings.LogsInjectionEnabled)
{
InitializeLibLogScopeEventSubscriber(_scopeManager, DefaultServiceName, Settings.ServiceVersion, Settings.Environment);
}
if (Interlocked.Exchange(ref _firstInitialization, 0) == 1)
{
if (Settings.StartupDiagnosticLogEnabled)
{
_ = Task.Run(WriteDiagnosticLog);
}
if (Settings.RuntimeMetricsEnabled)
{
_runtimeMetricsWriter = new RuntimeMetricsWriter(Statsd ?? CreateDogStatsdClient(Settings, DefaultServiceName, Settings.DogStatsdPort), TimeSpan.FromSeconds(10));
}
}
}
