public ZipkinExporter(ImmutableTracerSettings settings)
{
Log.Debug("Creating new Zipkin exporter");
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
_tracesEndpoint = _settings.ExporterSettings.AgentUri;
}
public CIAgentWriter(ImmutableTracerSettings settings, ISampler sampler, int maxBufferSize = DefaultMaxBufferSize)
{
var isPartialFlushEnabled = settings.ExporterSettings.PartialFlushEnabled;
var apiRequestFactory = TracesTransportStrategy.Get(settings.ExporterSettings);
var api = new Api(apiRequestFactory, null, rates => sampler.SetDefaultSampleRates(rates), isPartialFlushEnabled);
_agentWriter = new AgentWriter(api, null, maxBufferSize: maxBufferSize);
}
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),
})
{
}
public void SetAnalyticsSampleRate(IntegrationId integration, ImmutableTracerSettings settings, bool enabledWithGlobalSetting)
{
if (settings != null)
{
#pragma warning disable 618 // App analytics is deprecated, but still used
AnalyticsSampleRate = settings.GetIntegrationAnalyticsSampleRate(integration, enabledWithGlobalSetting);
#pragma warning restore 618
}
}
/// <summary>
/// Initializes the managed-side thread sample reader.
/// </summary>
/// <param name="tracerSettings">Configuration settings.</param>
public static void Initialize(ImmutableTracerSettings tracerSettings)
{
_tracerSettings = tracerSettings;
var thread = new Thread(SampleReadingThread)
{
Name = BackgroundThreadName,
IsBackground = true
};
thread.Start();
}
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));
}
public void RecordTracerSettings(ImmutableTracerSettings settings)
{
for (var i = 0; i < settings.Integrations.Settings.Length; i++)
{
var integration = settings.Integrations.Settings[i];
if (integration.Enabled == false)
{
_integrationsById[i].WasExplicitlyDisabled = 1;
}
}
SetHasChanges();
}
protected ThreadSampleExporter(ImmutableTracerSettings tracerSettings)
{
FixedLogRecordAttributes = new ReadOnlyCollection <KeyValue>(new List <KeyValue>
{
GdiProfilingConventions.LogRecord.Attributes.Source,
GdiProfilingConventions.LogRecord.Attributes.Period((long)tracerSettings.ThreadSamplingPeriod.TotalMilliseconds),
GdiProfilingConventions.LogRecord.Attributes.Format(tracerSettings.ExporterSettings.ProfilerExportFormat),
GdiProfilingConventions.LogRecord.Attributes.Type
});
LogsEndpointUrl = tracerSettings.ExporterSettings.LogsEndpointUrl;
LogsData = GdiProfilingConventions.CreateLogsData(tracerSettings.GlobalTags);
}
public CIAgentlessWriter(ImmutableTracerSettings settings, ISampler sampler, ICIAgentlessWriterSender sender)
{
_eventQueue = new BlockingCollection <IEvent>(MaxItemsInQueue);
_flushTaskCompletionSource = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
_flushDelayEvent = new AutoResetEvent(false);
_ciTestCycleBuffer = new CITestCyclePayload();
_sender = sender;
_periodicFlush = Task.Factory.StartNew(InternalFlushEventsAsync, this, TaskCreationOptions.LongRunning);
_periodicFlush.ContinueWith(t => Log.Error(t.Exception, "Error in sending ciapp events"), TaskContinuationOptions.OnlyOnFaulted);
Log.Information("CIAgentlessWriter Initialized.");
}
public void RecordTracerSettings(
ImmutableTracerSettings tracerSettings,
string defaultServiceName,
AzureAppServices appServicesMetadata)
{
// Increment number of times this has been called
var reconfigureCount = Interlocked.Increment(ref _tracerInstanceCount);
var appData = new ApplicationTelemetryData(
serviceName: defaultServiceName,
env: tracerSettings.Environment,
tracerVersion: TracerConstants.AssemblyVersion,
languageName: "dotnet",
languageVersion: FrameworkDescription.Instance.ProductVersion)
{
ServiceVersion = tracerSettings.ServiceVersion,
RuntimeName = FrameworkDescription.Instance.Name,
};
_settings = new CurrentSettings(tracerSettings, appData);
// The remaining properties can't change, so only need to set them the first time
if (reconfigureCount != 1)
{
SetHasChanges();
return;
}
_azureApServicesMetadata = appServicesMetadata;
var host = HostMetadata.Instance;
_hostData = new HostTelemetryData
{
ContainerId = ContainerMetadata.GetContainerId(),
Os = FrameworkDescription.Instance.OSPlatform,
OsVersion = Environment.OSVersion.ToString(),
Hostname = host.Hostname,
KernelName = host.KernelName,
KernelRelease = host.KernelRelease,
KernelVersion = host.KernelVersion,
};
_isTracerInitialized = true;
SetHasChanges();
}
public TelemetrySettings(IConfigurationSource source, ImmutableTracerSettings tracerSettings)
{
var explicitlyEnabled = source?.GetBool(ConfigurationKeys.Telemetry.Enabled);
TelemetryEnabled = explicitlyEnabled ?? false;
var apiKey = source?.GetString(ConfigurationKeys.ApiKey);
if (explicitlyEnabled != false && !string.IsNullOrEmpty(apiKey))
{
// We have an API key, so try to send directly to intake
ApiKey = apiKey;
TelemetryEnabled = true;
var requestedTelemetryUri = source?.GetString(ConfigurationKeys.Telemetry.Uri);
if (!string.IsNullOrEmpty(requestedTelemetryUri) &&
Uri.TryCreate(requestedTelemetryUri, UriKind.Absolute, out var telemetryUri))
{
// telemetry URI provided and well-formed
TelemetryUri = telemetryUri;
}
else
{
// use the default intake. Use DD_SITE if provided, otherwise use default
var siteFromEnv = source.GetString(ConfigurationKeys.Site);
var ddSite = string.IsNullOrEmpty(siteFromEnv) ? "datadoghq.com" : siteFromEnv;
TelemetryUri = new Uri($"{TelemetryConstants.TelemetryIntakePrefix}.{ddSite}/");
}
}
else if (TelemetryEnabled)
{
// no API key provided, so send to the agent instead
// We only support http at the moment so disable telemetry for now if we're using something else
if (tracerSettings.Exporter.TracesTransport == TracesTransportType.Default)
{
TelemetryUri = new Uri(tracerSettings.Exporter.AgentUri, TelemetryConstants.AgentTelemetryEndpoint);
}
else
{
TelemetryEnabled = false;
}
}
}
private IApiRequestFactory GetRequestFactory(ImmutableTracerSettings settings)
{
IApiRequestFactory factory = null;
TimeSpan agentlessTimeout = TimeSpan.FromSeconds(15);
#if NETCOREAPP
Log.Information("Using {FactoryType} for trace transport.", nameof(HttpClientRequestFactory));
factory = new HttpClientRequestFactory(settings.ExporterSettings.AgentUri, AgentHttpHeaderNames.DefaultHeaders, timeout: agentlessTimeout);
#else
Log.Information("Using {FactoryType} for trace transport.", nameof(ApiWebRequestFactory));
factory = new ApiWebRequestFactory(settings.ExporterSettings.AgentUri, AgentHttpHeaderNames.DefaultHeaders, timeout: agentlessTimeout);
#endif
if (!string.IsNullOrWhiteSpace(_settings.ProxyHttps))
{
var proxyHttpsUriBuilder = new UriBuilder(_settings.ProxyHttps);
var userName = proxyHttpsUriBuilder.UserName;
var password = proxyHttpsUriBuilder.Password;
proxyHttpsUriBuilder.UserName = string.Empty;
proxyHttpsUriBuilder.Password = string.Empty;
if (proxyHttpsUriBuilder.Scheme == "https")
{
// HTTPS proxy is not supported by .NET BCL
Log.Error($"HTTPS proxy is not supported. ({proxyHttpsUriBuilder})");
return(factory);
}
NetworkCredential credential = null;
if (!string.IsNullOrWhiteSpace(userName))
{
credential = new NetworkCredential(userName, password);
}
Log.Information("Setting proxy to: {ProxyHttps}", proxyHttpsUriBuilder.Uri.ToString());
factory.SetProxy(new WebProxy(proxyHttpsUriBuilder.Uri, true, _settings.ProxyNoProxy, credential), credential);
}
return(factory);
}
protected override IAgentWriter GetAgentWriter(ImmutableTracerSettings settings, IDogStatsd statsd, ISampler sampler)
{
// Check for agentless scenario
if (_settings.Agentless)
{
if (!string.IsNullOrEmpty(_settings.ApiKey))
{
return(new CIAgentlessWriter(new CIWriterHttpSender(GetRequestFactory(settings))));
}
else
{
Environment.FailFast("An API key is required in Agentless mode.");
return(null);
}
}
else
{
// With agent scenario:
// Set the tracer buffer size to the max
var traceBufferSize = 1024 * 1024 * 45; // slightly lower than the 50mb payload agent limit.
return(new CIAgentWriter(settings, sampler, traceBufferSize));
}
}
public TelemetrySettingsTests()
{
_tracerSettings = new(new TracerSettings());
_defaultAgentUrl = $"{_tracerSettings.Exporter.AgentUri}{TelemetryConstants.AgentTelemetryEndpoint}";
_defaultIntakeUrl = "https://instrumentation-telemetry-intake.datadoghq.com/";
}
public CurrentSettings(ImmutableTracerSettings settings, ApplicationTelemetryData applicationData)
{
Settings = settings;
ApplicationData = applicationData;
}
public ThreadSampleExporterFactory(ImmutableTracerSettings tracerSettings)
{
_tracerSettings = tracerSettings;
}
public PprofThreadSampleExporter(ImmutableTracerSettings tracerSettings)
: base(tracerSettings)
{
}
internal PlainTextThreadSampleExporter(ImmutableTracerSettings tracerSettings)
: base(tracerSettings)
{
}
internal static void SetHttpStatusCode(this Span span, int statusCode, bool isServer, ImmutableTracerSettings tracerSettings)
{
if (statusCode < 100 || statusCode >= 600)
{
// not a valid status code. Likely the default integer value
return;
}
string statusCodeString = ConvertStatusCodeToString(statusCode);
if (span.Tags is IHasStatusCode statusCodeTags)
{
statusCodeTags.HttpStatusCode = statusCodeString;
}
else
{
span.SetTag(Tags.HttpStatusCode, statusCodeString);
}
// Check the customers http statuses that should be marked as errors
if (tracerSettings.IsErrorStatusCode(statusCode, isServer))
{
span.Error = true;
// if an error message already exists (e.g. from a previous exception), don't replace it
if (string.IsNullOrEmpty(span.GetTag(Tags.ErrorMsg)))
{
span.SetTag(Tags.ErrorMsg, $"The HTTP response has status code {statusCodeString}.");
}
}
}
protected override ISampler GetSampler(ImmutableTracerSettings settings)
{
return(new CISampler());
}
public ZipkinSerializer(ImmutableTracerSettings settings)
{
_settings = settings;
}
public ZipkinSpan(Span span, ImmutableTracerSettings settings)
{
_span = span;
_tags = BuildTags(span, settings);
}
public static TelemetrySettings FromDefaultSources(ImmutableTracerSettings tracerSettings) => new TelemetrySettings(GlobalSettings.CreateDefaultConfigurationSource(), tracerSettings);
