public static Module Get(Guid moduleVersionId)
{
// First attempt at cached values with no blocking
if (_modules.TryGetValue(moduleVersionId, out Module value))
{
return(value);
}
// Block if a population event is happening
_populationResetEvent.Wait();
// See if the previous population event populated what we need
if (_modules.TryGetValue(moduleVersionId, out value))
{
return(value);
}
if (_failures >= MaxFailures)
{
// For some unforeseeable reason we have failed on a lot of AppDomain lookups
if (!_shortCircuitLogicHasLogged)
{
Log.Warning("Datadog is unable to continue attempting module lookups for this AppDomain. Falling back to legacy method lookups.");
}
return(null);
}
// Block threads on this event
_populationResetEvent.Reset();
try
{
PopulateModules();
}
catch (Exception ex)
{
_failures++;
Log.Error(ex, "Error when populating modules.");
}
finally
{
// Continue threads blocked on this event
_populationResetEvent.Set();
}
_modules.TryGetValue(moduleVersionId, out value);
return(value);
}
private string CompileResourceId()
{
string resourceId = null;
try
{
var success = true;
if (SubscriptionId == null)
{
success = false;
Log.Warning("Could not successfully retrieve the subscription ID from variable: {0}", WebsiteOwnerNameKey);
}
if (SiteName == null)
{
success = false;
Log.Warning("Could not successfully retrieve the deployment ID from variable: {0}", SiteNameKey);
}
if (ResourceGroup == null)
{
success = false;
Log.Warning("Could not successfully retrieve the resource group name from variable: {0}", ResourceGroupKey);
}
if (success)
{
resourceId = $"/subscriptions/{SubscriptionId}/resourcegroups/{ResourceGroup}/providers/microsoft.web/sites/{SiteName}".ToLowerInvariant();
}
}
catch (Exception ex)
{
Log.Error(ex, "Could not successfully setup the resource id for azure app services.");
}
return(resourceId);
}
public async Task FlushAndCloseAsync()
{
if (!_processExit.TrySetResult(true))
{
return;
}
await Task.WhenAny(_flushTask, Task.Delay(TimeSpan.FromSeconds(20)))
.ConfigureAwait(false);
if (!_flushTask.IsCompleted)
{
Log.Warning("Could not flush all traces before process exit");
}
}
private static string GetContainerIdInternal()
{
try
{
var isLinux = string.Equals(FrameworkDescription.Create().OSPlatform, "Linux", StringComparison.OrdinalIgnoreCase);
if (isLinux &&
File.Exists(ControlGroupsFilePath))
{
var lines = File.ReadLines(ControlGroupsFilePath);
return(ParseCgroupLines(lines));
}
}
catch (Exception ex)
{
Log.Warning("Error reading cgroup file. Will not report container id.", ex);
}
return(null);
}
private static Scope CreateScope(object wireProtocol, object connection)
{
if (!Tracer.Instance.Settings.IsIntegrationEnabled(IntegrationName))
{
// integration disabled, don't create a scope, skip this trace
return(null);
}
string databaseName = null;
string host = null;
string port = null;
try
{
if (wireProtocol.TryGetFieldValue("_databaseNamespace", out object databaseNamespace))
{
databaseNamespace?.TryGetPropertyValue("DatabaseName", out databaseName);
}
}
catch (Exception ex)
{
Log.Warning(ex, "Unable to access DatabaseName property.");
}
try
{
if (connection != null && connection.TryGetPropertyValue("EndPoint", out object endpoint))
{
if (endpoint is IPEndPoint ipEndPoint)
{
host = ipEndPoint.Address.ToString();
port = ipEndPoint.Port.ToString();
}
else if (endpoint is DnsEndPoint dnsEndPoint)
{
host = dnsEndPoint.Host;
port = dnsEndPoint.Port.ToString();
}
}
}
catch (Exception ex)
{
Log.Warning(ex, "Unable to access EndPoint properties.");
}
Tracer tracer = Tracer.Instance;
string statement = null;
string operationName = null;
string collectionName = null;
string query = null;
try
{
if (wireProtocol.TryGetFieldValue("_command", out object command) && command != null)
{
if (tracer.Settings.TagMongoCommands)
{
string document = command.ToString();
statement = document.Length > 1024 ? document.Substring(0, 1024) : document;
}
// the name of the first element in the command BsonDocument will be the operation type (insert, delete, find, etc)
// and its value is the collection name
if (command.TryCallMethod("GetElement", 0, out object firstElement) && firstElement != null)
{
firstElement.TryGetPropertyValue("Name", out operationName);
if (firstElement.TryGetPropertyValue("Value", out object collectionNameObj) && collectionNameObj != null)
{
collectionName = collectionNameObj.ToString();
}
}
// get the "query" element from the command BsonDocument, if it exists
if (command.TryCallMethod("Contains", "query", out bool found) && found)
{
if (command.TryCallMethod("GetElement", "query", out object queryElement) && queryElement != null)
{
if (queryElement.TryGetPropertyValue("Value", out object queryValue) && queryValue != null)
{
query = queryValue.ToString();
}
}
}
}
}
catch (Exception ex)
{
Log.Warning(ex, "Unable to access IWireProtocol.Command properties.");
}
operationName = operationName ?? OperationName;
Span parent = tracer.ActiveScope?.Span;
if (parent != null &&
parent.GetTag(Tags.DbType) == SpanTypes.MongoDb &&
parent.OperationName == operationName &&
parent.GetTag(Tags.DbStatement) == statement)
{
// we are already instrumenting this command execution,
return(null);
}
Scope scope = null;
try
{
scope = tracer.StartActive(operationName, serviceName: tracer.DefaultServiceName);
var span = scope.Span;
span.SetTag(Tags.DbType, SpanTypes.MongoDb);
span.SetTag(Tags.InstrumentationName, IntegrationName);
span.SetTag(Tags.SpanKind, SpanKinds.Client);
span.SetTag(Tags.DbName, databaseName);
span.SetTag(Tags.DbStatement, statement);
span.SetTag(Tags.MongoDbQuery, query);
span.SetTag(Tags.MongoDbCollection, collectionName);
span.SetTag(Tags.OutHost, host);
span.SetTag(Tags.OutPort, port);
// set analytics sample rate if enabled
var analyticsSampleRate = tracer.Settings.GetIntegrationAnalyticsSampleRate(IntegrationName, enabledWithGlobalSetting: false);
span.SetMetric(Tags.Analytics, analyticsSampleRate);
}
catch (Exception ex)
{
Log.Error(ex, "Error creating or populating scope.");
}
return(scope);
}
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);
}
IApi apiClient = null;
if (agentWriter == null)
{
if (Settings.ApiType.ToLower().Equals("zipkin"))
{
apiClient = new ZipkinApi(Settings, delegatingHandler: null);
}
}
_agentWriter = agentWriter ?? new AgentWriter(apiClient, Statsd, Settings.SynchronousSend);
_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);
}
}