public Manager(IAgentReader <T> reader, IAgentWriter <T> writer)
{
this.metadata = Activator.CreateInstance <T>();
this.reader = reader;
this.writer = writer;
MetadataWatcher.MetadataUpdateEvent += new MetadataWatcher.EventHandler(Synchronize);
}
internal Tracer(TracerSettings settings, IAgentWriter agentWriter, ISampler sampler, IScopeManager scopeManager)
{
// fall back to default implementations of each dependency if not provided
Settings = settings ?? TracerSettings.FromDefaultSources();
_agentWriter = agentWriter ?? new AgentWriter(new Api(Settings.AgentUri));
_scopeManager = scopeManager ?? new AsyncLocalScopeManager();
Sampler = sampler ?? new RateByServiceSampler();
// if not configured, try to determine an appropriate service name
DefaultServiceName = Settings.ServiceName ??
GetApplicationName() ??
UnknownServiceName;
// 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;
// If configured, add/remove the correlation identifiers into the
// LibLog logging context when a scope is activated/closed
if (Settings.LogsInjectionEnabled)
{
InitializeLibLogScopeEventSubscriber(_scopeManager);
}
}
static AgentWriterBenchmark()
{
var settings = TracerSettings.FromDefaultSources();
settings.StartupDiagnosticLogEnabled = false;
settings.TraceEnabled = false;
var api = new Api(settings.Exporter.AgentUri, new FakeApiRequestFactory(), statsd: null, updateSampleRates: null, isPartialFlushEnabled: false);
AgentWriter = new AgentWriter(api, statsd: null, automaticFlush: false);
var enrichedSpans = new Span[SpanCount];
var now = DateTimeOffset.UtcNow;
for (int i = 0; i < SpanCount; i++)
{
enrichedSpans[i] = new Span(new SpanContext((ulong)i, (ulong)i, SamplingPriorityValues.UserReject, "Benchmark", null), now);
enrichedSpans[i].SetTag(Tags.Env, "Benchmark");
enrichedSpans[i].SetMetric(Metrics.SamplingRuleDecision, 1.0);
}
EnrichedSpans = new ArraySegment <Span>(enrichedSpans);
// Run benchmarks once to reduce noise
new AgentWriterBenchmark().WriteAndFlushEnrichedTraces().GetAwaiter().GetResult();
}
void IAgentConnector.DisconnectAgent(IAgentWriter proxy)
{
proxy.Close();
Interlocked.Increment(ref _counters.AgentDisconnected);
_log.Info("Agent at '{0}' is disconnected", proxy.AgentUri);
}
private static Tracer GetTracer(IAgentWriter writer = null, IConfigurationSource configSource = null)
{
var settings = new TracerSettings(configSource);
var agentWriter = writer ?? new Mock <IAgentWriter>().Object;
var samplerMock = new Mock <ISampler>();
return(new Tracer(settings, agentWriter, samplerMock.Object, scopeManager: null, statsd: null));
}
public CITracerManager(ImmutableTracerSettings settings, IAgentWriter agentWriter, ISampler sampler, IScopeManager scopeManager, IDogStatsd statsd, RuntimeMetricsWriter runtimeMetricsWriter, ITraceIdConvention traceIdConvention, DirectLogSubmissionManager logSubmissionManager, ITelemetryController telemetry, string defaultServiceName)
: base(settings, agentWriter, sampler, scopeManager, statsd, runtimeMetricsWriter, traceIdConvention, logSubmissionManager, telemetry, defaultServiceName, new Trace.Processors.ITraceProcessor[]
{
new Trace.Processors.NormalizerTraceProcessor(),
new Trace.Processors.TruncatorTraceProcessor(),
new Processors.OriginTagTraceProcessor(settings.ExporterSettings.PartialFlushEnabled, agentWriter is CIAgentlessWriter),
})
{
}
/// <summary>
/// Create a test instance of the Tracer, that doesn't used any shared instances
/// </summary>
public static Tracer Create(
TracerSettings settings = null,
IAgentWriter agentWriter = null,
ISampler sampler = null,
IScopeManager scopeManager = null,
IDogStatsd statsd = null)
{
return(new Tracer(settings, agentWriter, sampler, scopeManager, statsd));
}
internal Tracer(IAgentWriter agentWriter, string defaultServiceName = null, bool isDebugEnabled = false)
{
_isDebugEnabled = isDebugEnabled;
_agentWriter = agentWriter;
DefaultServiceName = defaultServiceName ?? CreateDefaultServiceName() ?? UnknownServiceName;
// 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;
_scopeManager = new AsyncLocalScopeManager();
}
protected override TracerManager CreateTracerManagerFrom(
ImmutableTracerSettings settings,
IAgentWriter agentWriter,
ISampler sampler,
IScopeManager scopeManager,
IDogStatsd statsd,
RuntimeMetricsWriter runtimeMetrics,
DirectLogSubmissionManager logSubmissionManager,
ITelemetryController telemetry,
string defaultServiceName)
{
return(new CITracerManager(settings, agentWriter, sampler, scopeManager, statsd, runtimeMetrics, logSubmissionManager, telemetry, defaultServiceName));
}
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);
}
}
internal Tracer(TracerSettings settings, IAgentWriter agentWriter, ISampler sampler, IScopeManager scopeManager)
{
// fall back to default implementations of each dependency if not provided
Settings = settings ?? TracerSettings.FromDefaultSources();
_agentWriter = agentWriter ?? new AgentWriter(new Api(Settings.AgentUri));
_scopeManager = scopeManager ?? new AsyncLocalScopeManager();
Sampler = sampler ?? new RateByServiceSampler();
// if not configured, try to determine an appropriate service name
DefaultServiceName = Settings.ServiceName ??
GetApplicationName() ??
UnknownServiceName;
// 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;
}
static AgentWriterBenchmark()
{
var settings = TracerSettings.FromDefaultSources();
settings.StartupDiagnosticLogEnabled = false;
settings.TraceEnabled = false;
var api = new Api(settings.AgentUri, new FakeApiRequestFactory(), statsd: null);
_agentWriter = new AgentWriter(api, statsd: null, automaticFlush: false);
_spans = new Span[SpanCount];
var now = DateTimeOffset.UtcNow;
for (int i = 0; i < SpanCount; i++)
{
_spans[i] = new Span(new SpanContext((ulong)i, (ulong)i, SamplingPriority.UserReject, "Benchmark", null), now);
}
}
internal Tracer(TracerSettings settings, IAgentWriter agentWriter, ISampler sampler, IScopeManager scopeManager, IStatsd statsd)
{
// fall back to default implementations of each dependency if not provided
Settings = settings ?? TracerSettings.FromDefaultSources();
// only set DogStatsdClient if tracer metrics are enabled
if (Settings.TracerMetricsEnabled)
{
Statsd = statsd ?? CreateDogStatsdClient(Settings);
}
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))
{
foreach (var rule in RegexSamplingRule.BuildFromConfigurationString(Settings.CustomSamplingRules))
{
Sampler.RegisterRule(rule);
}
}
// if not configured, try to determine an appropriate service name
DefaultServiceName = Settings.ServiceName ??
GetApplicationName() ??
UnknownServiceName;
// 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;
// If configured, add/remove the correlation identifiers into the
// LibLog logging context when a scope is activated/closed
if (Settings.LogsInjectionEnabled)
{
InitializeLibLogScopeEventSubscriber(_scopeManager);
}
}
static AgentWriterBenchmark()
{
var settings = TracerSettings.FromDefaultSources();
settings.StartupDiagnosticLogEnabled = false;
settings.TraceEnabled = false;
var api = new Api(settings.AgentUri, new FakeApiRequestFactory(), statsd: null);
AgentWriter = new AgentWriter(api, statsd: null, automaticFlush: false);
Spans = new Span[SpanCount];
EnrichedSpans = new Span[SpanCount];
SpansWithOrigin = new Span[SpanCount];
EnrichedSpansWithOrigin = new Span[SpanCount];
var now = DateTimeOffset.UtcNow;
for (int i = 0; i < SpanCount; i++)
{
Spans[i] = new Span(new SpanContext((ulong)i, (ulong)i, SamplingPriority.UserReject, "Benchmark", null), now);
EnrichedSpans[i] = new Span(new SpanContext((ulong)i, (ulong)i, SamplingPriority.UserReject, "Benchmark", null), now);
EnrichedSpans[i].SetTag(Tags.Env, "Benchmark");
EnrichedSpans[i].SetMetric(Metrics.SamplingRuleDecision, 1.0);
//
SpansWithOrigin[i] = new Span(new SpanContext((ulong)i, (ulong)i, SamplingPriority.UserReject, "Benchmark", null), now);
SpansWithOrigin[i].SetTag(Tags.Origin, "synthetics");
EnrichedSpansWithOrigin[i] = new Span(new SpanContext((ulong)i, (ulong)i, SamplingPriority.UserReject, "Benchmark", null), now);
EnrichedSpansWithOrigin[i].SetTag(Tags.Origin, "synthetics");
EnrichedSpansWithOrigin[i].SetTag(Tags.Env, "Benchmark");
EnrichedSpansWithOrigin[i].SetMetric(Metrics.SamplingRuleDecision, 1.0);
}
// Run benchmarks once to reduce noise
new AgentWriterBenchmark().WriteAndFlushTraces().GetAwaiter().GetResult();
new AgentWriterBenchmark().WriteAndFlushEnrichedTraces().GetAwaiter().GetResult();
new AgentWriterBenchmark().WriteAndFlushTracesWithOrigin().GetAwaiter().GetResult();
new AgentWriterBenchmark().WriteAndFlushEnrichedTracesWithOrigin().GetAwaiter().GetResult();
}
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);
}
}
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));
}
}
}
void IMessengerEngine.IoFailed(IAgentWriter proxy, comm.IoMsg msg, Exception ex, string at)
{
Interlocked.Increment(ref _counters.IoFailed);
update_failure_counters(msg);
var msgType = msg.GetType().Name;
_log.Error("Msg ({0}): io error in '{1}' of '{2}' (retryCount={3}) to agent '{4}' (agent will be reconnected); {5}",
msg.Guid.AsStr(), at, msgType, msg.RetryCount, msg.AgentUri, ex.Message);
var removedAgent = _agents.RemoveAgent(proxy);
if (removedAgent == null)
return;
_connector.DisconnectAgent(removedAgent);
retry_io(msg);
}
private void set_agent_proxy(string uri, IAgentWriter proxy)
{
var prev = _agents.SetAgentProxy(uri, proxy);
if (prev == null)
return;
_connector.DisconnectAgent(prev);
}
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);
}
}
}
