internal Scope(Scope parent, Span span, IScopeManager scopeManager, bool finishOnClose)
{
Parent = parent;
Span = span;
_scopeManager = scopeManager;
_finishOnClose = finishOnClose;
}
// IMPORTANT: For all logging frameworks, do not set any default values for
// "dd.trace_id" and "dd.span_id" when initializing the subscriber
// because the Tracer may be initialized at a time when it is not safe
// to add properties logging context of the underlying logging framework.
//
// Failure to abide by this can cause a SerializationException when
// control is passed from one AppDomain to another where the originating
// AppDomain used a logging framework that stored logging context properties
// inside the System.Runtime.Remoting.Messaging.CallContext structure
// but the target AppDomain is unable to de-serialize the object --
// this can easily happen if the target AppDomain cannot find/load the
// logging framework assemblies.
public LibLogScopeEventSubscriber(IScopeManager scopeManager, string defaultServiceName, string version, string env)
{
_scopeManager = scopeManager;
_defaultServiceName = defaultServiceName;
_version = version;
_env = env;
try
{
_logProvider = LogProvider.CurrentLogProvider ?? LogProvider.ResolveLogProvider();
if (_logProvider is SerilogLogProvider)
{
// Do not set default values for Serilog because it is unsafe to set
// except at the application startup, but this would require auto-instrumentation
_scopeManager.SpanOpened += StackOnSpanOpened;
_scopeManager.SpanClosed += StackOnSpanClosed;
}
else
{
_scopeManager.SpanActivated += MapOnSpanActivated;
_scopeManager.TraceEnded += MapOnTraceEnded;
}
}
catch (Exception ex)
{
Log.SafeLogError(ex, "Could not successfully start the LibLogScopeEventSubscriber. There was an issue resolving the application logger.");
}
}
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);
}
}
public OtTracer(string serviceName, IScopeManager scopeManager, ITraceInjector traceInjector, ITraceExtractor traceExtractor)
{
ServiceName = serviceName ?? throw new ArgumentNullException(nameof(serviceName));
ScopeManager = scopeManager ?? throw new ArgumentNullException(nameof(scopeManager));
_traceInjector = traceInjector ?? throw new ArgumentNullException(nameof(traceInjector));
_traceExtractor = traceExtractor ?? throw new ArgumentNullException(nameof(traceExtractor));
}
static NoOp()
{
var noOpTracer = NoopTracerFactory.Create();
Span = noOpTracer.BuildSpan("foo").Start();
Scope = noOpTracer.ScopeManager.Active;
ScopeManager = noOpTracer.ScopeManager;
}
public IValueNode <TwisterPrimitive> ParseArithmeticExpression(ITokenMatcher matcher, IScopeManager scopeManager,
Func <IValueNode <TwisterPrimitive> > assignmentCallback)
{
_matcher = matcher;
_scopeManager = scopeManager;
_assignmentCallback = assignmentCallback;
return(Evaluate());
}
public Tracer Build()
{
if (_loggerFactory == null)
{
_loggerFactory = NullLoggerFactory.Instance;
}
if (_metrics == null)
{
_metrics = NoopMetricsFactory.Instance.CreateMetrics();
}
if (_reporter == null)
{
if (_transport == null)
{
if (_loggerFactory == NullLoggerFactory.Instance)
{
// TODO: Technically, it would be fine to get rid of NullReporter since the NullLogger does the same.
// Check the performance penalty between using LoggingReporter with NullReporter compared to NullReporter!
_reporter = new NullReporter();
}
else
{
_reporter = new LoggingReporter(_loggerFactory);
}
}
else
{
_reporter = new RemoteReporter.Builder(_transport)
.WithLoggerFactory(_loggerFactory)
.WithMetrics(_metrics)
.Build();
}
}
if (_sampler == null)
{
if (_samplingManager == null)
{
_sampler = new ConstSampler(true);
}
else
{
_sampler = new RemoteControlledSampler.Builder(_serviceName, _samplingManager)
.WithLoggerFactory(_loggerFactory)
.WithMetrics(_metrics)
.Build();
}
}
if (_scopeManager == null)
{
_scopeManager = new AsyncLocalScopeManager();
}
if (_propagationRegistry == null)
{
_propagationRegistry = Propagators.TextMap;
}
return(new Tracer(_serviceName, _initialTags, _scopeManager, _loggerFactory, _propagationRegistry, _sampler, _reporter, _metrics));
}
public Tracer(
IScopeManager scopeManager,
ISampler sampler = null)
{
EnsureArg.IsNotNull(scopeManager, nameof(scopeManager));
this.ScopeManager = scopeManager;
this.Sampler = sampler ?? new ConstantSampler();
}
/// <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));
}
public ActivateSpanOnDispose(
ISpan span,
IScopeManager scopeManager,
YieldReadyScope setCurrentlyActiveOn)
{
this.span = span;
this.scopeManager = scopeManager;
this.setCurrentlyActiveOn = setCurrentlyActiveOn;
}
public static IYieldReadyScope StartActiveYieldReadyScope(
this ISpanBuilder spanBuilder,
bool finishOnDispose,
IScopeManager scopeManager)
{
IScope startActive = spanBuilder.StartActive(false);
return(new YieldReadyScope(startActive, finishOnDispose, scopeManager));
}
public OpenTracingTracer(IDatadogTracer datadogTracer, IScopeManager scopeManager)
{
DatadogTracer = datadogTracer;
DefaultServiceName = datadogTracer.DefaultServiceName;
ScopeManager = scopeManager;
_codecs = new Dictionary <string, ICodec> {
{ BuiltinFormats.HttpHeaders.ToString(), new HttpHeadersCodec() }
};
}
public Scope([NotNull] IScopeManager scopeManager, [NotNull] ILockObject lockObject, IContainer container, bool isDefault = false)
{
ScopeKey = Interlocked.Increment(ref _currentScopeKey);
_scopeHashCode = ScopeKey.GetHashCode();
_scopeManager = scopeManager;
_lockObject = lockObject ?? throw new ArgumentNullException(nameof(lockObject));
_container = container;
_isDefault = isDefault;
}
public override void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
{
base.Init(componentActivator, kernel, model);
manager = kernel.GetSubSystem("scope") as IScopeManager;
if (manager == null)
{
throw new InvalidOperationException("Scope Subsystem not found. Did you forget to add it?");
}
}
public void EndCurrentScope_InScope_EndsScope()
{
var container = new ServiceContainer();
IScopeManager manager = container.ScopeManagerProvider.GetScopeManager(container);
container.BeginScope();
container.ScopeManagerProvider.GetScopeManager(container).CurrentScope.Dispose();
Assert.Null(manager.CurrentScope);
}
public ApplicationInsightsTracer(TelemetryConfiguration config, IScopeManager scopeManager,
IPropagator <ITextMap> propagator, ITimeProvider timeProvider, Endpoint localEndpoint)
{
Client = new TelemetryClient(config);
_config = config;
ScopeManager = scopeManager;
_propagator = propagator;
TimeProvider = timeProvider;
LocalEndpoint = localEndpoint;
}
public CurrentScopeAccessor(IScopeManager scopeManager, ComponentModel componentModel)
{
this.scopeManager = scopeManager;
this.componentModel = componentModel;
var baseType = (Type)componentModel.ExtendedProperties[Constants.ScopeRoot];
if (baseType != null)
{
selector = new BasedOnTypeScopeRootSelector(baseType);
}
}
protected UnitOfWork(TContext context, IScopeManager scopeManager, IServiceLocator serviceLocator, ScopeType scopeType)
{
Context = context ?? throw new ArgumentNullException(nameof(context));
_scopeManager = scopeManager ?? throw new ArgumentNullException(nameof(scopeManager));
_serviceLocator = serviceLocator ?? throw new ArgumentNullException(nameof(serviceLocator));
Id = UniqueIdGenerator.Generate();
ScopeType = scopeType;
}
public override void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
{
base.Init(componentActivator, kernel, model);
manager = kernel.GetSubSystem("scope") as IScopeManager;
if (manager == null)
{
throw new InvalidOperationException("Scope Subsystem not found. Did you forget to add it?");
}
}
public CurrentScopeAccessor(IScopeManager scopeManager, ComponentModel componentModel)
{
this.scopeManager = scopeManager;
this.componentModel = componentModel;
var baseType = (Type)componentModel.ExtendedProperties[Constants.ScopeRoot];
if (baseType != null)
{
selector = new BasedOnTypeScopeRootSelector(baseType);
}
}
public YieldReadyScope(
IScope startActive,
bool finishOnDispose,
IScopeManager scopeManager)
{
this.currentlyActiveScope = startActive;
this.finishOnDispose = finishOnDispose;
this.scopeManager = scopeManager;
this.Span = this.currentlyActiveScope.Span;
}
public TracerBuilderTests()
{
_mockReporter = Substitute.For <IReporter>();
_serviceName = "testingService";
_mockSampler = Substitute.For <ISampler>();
_mockScopeManager = Substitute.For <IScopeManager>();
_mockPropagationRegistry = Substitute.For <IPropagationRegistry>();
_mockMetrics = Substitute.For <IMetrics>();
_mockTransport = Substitute.For <ITransport>();
_baseBuilder = new Tracer.Builder(_serviceName);
}
private void SetupParser(IEnumerable <IToken> tokens)
{
if (tokens == null)
{
throw new InvalidProgramException("Source text is empty");
}
_matcher = _createTokenMatcher(tokens);
_scopeManager = new ScopeManager();
_hasMain = false;
}
public MockZipkinTracer(Endpoint localEndpoint = null, ITimeProvider timeProvider = null,
ISpanIdProvider idProvider = null,
IScopeManager scopeManager = null, IPropagator <ITextMap> propagtor = null, ITraceSampler sampler = null)
{
LocalEndpoint = localEndpoint ?? Endpoint.Testing;
TimeProvider = timeProvider ?? new DateTimeOffsetTimeProvider();
IdProvider = idProvider ?? ThreadLocalRngSpanIdProvider.TraceId128BitProvider;
ScopeManager = scopeManager ?? NoOp.ScopeManager;
_propagator = propagtor ?? new B3Propagator();
Sampler = sampler ?? NoSampler.Instance;
CollectedSpans = new ConcurrentQueue <Span>();
}
public OtTracer(string serviceName, IScopeManager scopeManager, IPropagation <string> propagation)
{
ServiceName = serviceName ?? throw new ArgumentNullException(nameof(serviceName));
ScopeManager = scopeManager ?? throw new ArgumentNullException(nameof(scopeManager));
if (propagation == null)
{
throw new ArgumentNullException(nameof(propagation));
}
_injector = propagation.Injector <ITextMap>((c, key, value) => c.Set(key, value));
_extractor = propagation.Extractor <ITextMap>((c, key) => c.Where(x => x.Key == key).Select(x => x.Value).FirstOrDefault());
}
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);
}
}
/// <summary>
/// Wraps the enumeration with the specified <see cref="spanBuilder"/>, returning to the parent context (removing
/// the 'enumerate' scope from <see cref="IScopeManager.Active"/>) before each yield return to the caller.
/// </summary>
public static IEnumerable <T> WrapWithTracing <T>(
this IEnumerable <T> source,
Func <ISpanBuilder> spanBuilder,
IScopeManager scopeManager)
{
using (IYieldReadyScope scope = spanBuilder().StartActiveYieldReadyScope(scopeManager))
{
foreach (var item in source)
{
using (scope.Yielding())
yield return(item);
}
}
}
/// <summary>
/// Returns the <see cref="IScopeManager"/> that is responsible for managing scopes.
/// </summary>
/// <param name="serviceFactory">The <see cref="IServiceFactory"/> to be associated with this <see cref="ScopeManager"/>.</param>
/// <returns>The <see cref="IScopeManager"/> that is responsible for managing scopes.</returns>
public IScopeManager GetScopeManager(IServiceFactory serviceFactory)
{
if (scopeManager == null)
{
lock (lockObject)
{
if (scopeManager == null)
{
scopeManager = CreateScopeManager(serviceFactory);
}
}
}
return(scopeManager);
}
public NavigationService(
ILogger logger,
IScreenController router,
IScopeManager scopeManager,
IScreenToViewModelMapper mapper,
IEntryScreenNameProvider entryScreenNameProvider
)
{
_entryScreenNameProvider = entryScreenNameProvider;
_mapper = mapper;
_scopeManager = scopeManager;
_router = router;
_logger = logger;
}
// IMPORTANT: For all logging frameworks, do not set any default values for
// "dd.trace_id" and "dd.span_id" when initializing the subscriber
// because the Tracer may be initialized at a time when it is not safe
// to add properties logging context of the underlying logging framework.
//
// Failure to abide by this can cause a SerializationException when
// control is passed from one AppDomain to another where the originating
// AppDomain used a logging framework that stored logging context properties
// inside the System.Runtime.Remoting.Messaging.CallContext structure
// but the target AppDomain is unable to de-serialize the object --
// this can easily happen if the target AppDomain cannot find/load the
// logging framework assemblies.
public LibLogScopeEventSubscriber(Tracer tracer, IScopeManager scopeManager, string defaultServiceName, string version, string env)
{
_tracer = tracer;
_scopeManager = scopeManager;
_defaultServiceName = defaultServiceName;
_version = version;
_env = env;
#if NETFRAMEWORK
if (_executingIISPreStartInit)
{
_scopeManager.TraceStarted += OnTraceStarted_RefreshIISState;
}
#endif
try
{
_logProvider = LogProvider.CurrentLogProvider ?? LogProvider.ResolveLogProvider();
if (_logProvider is SerilogLogProvider)
{
// Do not set default values for Serilog because it is unsafe to set
// except at the application startup, but this would require auto-instrumentation
_scopeManager.SpanOpened += StackOnSpanOpened;
_scopeManager.SpanClosed += StackOnSpanClosed;
if (_logProvider is CustomSerilogLogProvider customSerilogLogProvider)
{
_serilogEnricher = customSerilogLogProvider.CreateEnricher(tracer);
}
}
else if (_logProvider is CustomNLogLogProvider)
{
_nlogEnricher = new NLogEnricher(tracer);
_scopeManager.TraceStarted += RegisterNLogEnricher;
_scopeManager.TraceEnded += ClearNLogEnricher;
}
else
{
_scopeManager.SpanActivated += MapOnSpanActivated;
_scopeManager.TraceEnded += MapOnTraceEnded;
}
}
catch (Exception ex)
{
Log.Error(ex, "Could not successfully start the LibLogScopeEventSubscriber. There was an issue resolving the application logger.");
}
}
private Tracer(IScopeManager scopeManager, IPropagator propagator, Options options, ISpanRecorder spanRecorder, ILightStepHttpClient client)
{
ScopeManager = scopeManager;
_spanRecorder = spanRecorder;
_propagator = propagator;
_options = options;
_logger.Debug(
$"Creating new tracer with GUID {_options.TracerGuid}. Project Access Token: {_options.AccessToken}, Report Period: {_options.ReportPeriod}, Report Timeout: {_options.ReportTimeout}.");
var protocol = _options.Satellite.UsePlaintext ? "http" : "https";
var url =
$"{protocol}://{_options.Satellite.SatelliteHost}:{_options.Satellite.SatellitePort}/{LightStepConstants.SatelliteReportPath}";
_httpClient = client ?? new LightStepHttpClient(url, _options);
_logger.Debug($"Tracer is reporting to {url}.");
_reportLoop = new Timer(e => Flush(), null, TimeSpan.Zero, _options.ReportPeriod);
_firstReportHasRun = false;
}
