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 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; }