public void DependencyInjectionConfiguration_NoFilterConfiguresSampling() { var samplingSettings = new SamplingPercentageEstimatorSettings { MaxTelemetryItemsPerSecond = 1 }; using (var host = new HostBuilder() .ConfigureLogging(b => { b.AddApplicationInsights(o => { o.InstrumentationKey = "some key"; o.SamplingSettings = samplingSettings; }); }).Build()) { var config = host.Services.GetService <TelemetryConfiguration>(); Assert.Equal(5, config.TelemetryProcessors.Count); Assert.IsType <OperationFilteringTelemetryProcessor>(config.TelemetryProcessors[0]); Assert.IsType <QuickPulseTelemetryProcessor>(config.TelemetryProcessors[1]); Assert.IsType <FilteringTelemetryProcessor>(config.TelemetryProcessors[2]); Assert.IsType <AdaptiveSamplingTelemetryProcessor>(config.TelemetryProcessors[3]); Assert.Equal(samplingSettings.MaxTelemetryItemsPerSecond, ((AdaptiveSamplingTelemetryProcessor)config.TelemetryProcessors[3]).MaxTelemetryItemsPerSecond); } }
public static TelemetryConfiguration ConfigureWithSampling(this TelemetryConfiguration configuration, AdaptiveSamplingWorker worker) { // Automatically collect dependency calls var dependencies = new DependencyTrackingTelemetryModule(); dependencies.Initialize(configuration); // Automatically correlate all telemetry data with request configuration.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer()); // Build telemetry processing pipeline configuration.TelemetryProcessorChainBuilder // This telemetry processor will be executed // first for all telemetry items to calculate the size and # of items .Use((next) => { return(new TelemetryRecordSizeProcessor(next, size => worker.OnCollectedItems(size))); }) // This is a standard fixed sampling processor that'll let only 10% .Use((next) => { return(new SamplingTelemetryProcessor(next) { IncludedTypes = "Dependency", SamplingPercentage = 10, }); }) // This is a standard adaptive sampling telemetry processor // that will sample in/out any telemetry item it receives .Use((next) => { var settings = new SamplingPercentageEstimatorSettings { MaxTelemetryItemsPerSecond = 1, // Default: 5 calls/sec SamplingPercentageIncreaseTimeout = TimeSpan.FromSeconds(1), // Default: 2 min SamplingPercentageDecreaseTimeout = TimeSpan.FromSeconds(1), // Default: 30 sec EvaluationInterval = TimeSpan.FromSeconds(1), // Default: 15 sec InitialSamplingPercentage = 25, // Default: 100% }; var adaptiveSamplingProcessor = new AdaptiveSamplingTelemetryProcessor(settings, new AdaptiveSamplingPercentageEvaluatedCallback(AdaptiveSamplingEvaluated), next) { ExcludedTypes = "Event", // Exclude custom events from being sampled }; return(adaptiveSamplingProcessor); }) // This telemetry processor will be executed ONLY when telemetry is sampled in .Use((next) => { return(new TelemetryRecordSizeProcessor(next, size => worker.OnSentItems(size))); }) .Build(); return(configuration); }
/// <summary> /// Adds <see cref="AdaptiveSamplingTelemetryProcessor"/> to the <see cref="TelemetryProcessorChainBuilder" /> /// </summary> /// <param name="builder">Instance of <see cref="TelemetryProcessorChainBuilder"/></param> /// <param name="settings">Set of settings applicable to dynamic sampling percentage algorithm.</param> /// <param name="callback">Callback invoked every time sampling percentage evaluation occurs.</param> /// <return>Instance of <see cref="TelemetryProcessorChainBuilder"/>.</return> public static TelemetryProcessorChainBuilder UseAdaptiveSampling( this TelemetryProcessorChainBuilder builder, SamplingPercentageEstimatorSettings settings, AdaptiveSamplingPercentageEvaluatedCallback callback) { return(builder.Use((next) => new AdaptiveSamplingTelemetryProcessor(settings, callback, next) { InitialSamplingPercentage = 100.0 / settings.EffectiveInitialSamplingRate })); }
public TelemetryClient Create(string instrumentationKey, SamplingPercentageEstimatorSettings samplingSettings) { ITelemetryClientFactory defaultFactory = new DefaultTelemetryClientFactory(); TelemetryClient client = defaultFactory.Create(instrumentationKey, samplingSettings); string assemblyVersion = ScriptHost.GetAssemblyFileVersion(typeof(ScriptHost).Assembly); client.Context.GetInternalContext().SdkVersion = $"azurefunctions: {assemblyVersion}"; return(client); }
/// <summary> /// Initializes a new instance of the <see cref="AdaptiveSamplingTelemetryProcessor"/> class. /// <param name="settings">Sampling percentage estimator settings.</param> /// <param name="callback">Callback invoked every time sampling percentage is evaluated.</param> /// <param name="next">Next TelemetryProcessor in call chain.</param> /// </summary> public AdaptiveSamplingTelemetryProcessor( SamplingPercentageEstimatorSettings settings, AdaptiveSamplingPercentageEvaluatedCallback callback, ITelemetryProcessor next) { this.estimatorSettings = settings; this.evaluationCallback = callback; // make estimatortelemetry processor work after sampling was done this.estimatorProcessor = new SamplingPercentageEstimatorTelemetryProcessor(settings, this.SamplingPercentageChanged, next); this.samplingProcessor = new SamplingTelemetryProcessor(this.estimatorProcessor); }
public static void AdaptiveSamplingEvaluated( double afterSamplingTelemetryItemRatePerSecond, double currentSamplingPercentage, double newSamplingPercentage, bool isSamplingPercentageChanged, SamplingPercentageEstimatorSettings settings) { if (isSamplingPercentageChanged) { Cmd.Ln.EOL() .Gray("New Sampling Rate: ").Green(newSamplingPercentage).Green("% ") .Gray(", Before it was: ").Cyan(currentSamplingPercentage).Cyan("% "); } }
private void TraceSamplingPercentageEvaluation( double afterSamplingTelemetryItemRatePerSecond, double currentSamplingPercentage, double newSamplingPercentage, bool isSamplingPercentageChanged, SamplingPercentageEstimatorSettings settings) { Trace.WriteLine(string.Format( "[Sampling% evaluation] {0}, Eps: {1}, Current %: {2}, New %: {3}, Changed: {4}", DateTimeOffset.UtcNow.ToString("o"), afterSamplingTelemetryItemRatePerSecond, currentSamplingPercentage, newSamplingPercentage, isSamplingPercentageChanged)); }
private void AddSampling(TelemetryConfiguration configuration) { if (this.applicationInsightsServiceOptions.EnableAdaptiveSampling) { AdaptiveSamplingPercentageEvaluatedCallback samplingCallback = (ratePerSecond, currentPercentage, newPercentage, isChanged, estimatorSettings) => { if (isChanged) { configuration.SetLastObservedSamplingPercentage(SamplingTelemetryItemTypes.Request, newPercentage); } }; SamplingPercentageEstimatorSettings settings = new SamplingPercentageEstimatorSettings(); settings.MaxTelemetryItemsPerSecond = 5; configuration.DefaultTelemetrySink.TelemetryProcessorChainBuilder.UseAdaptiveSampling(settings, samplingCallback, excludedTypes: "Event"); configuration.DefaultTelemetrySink.TelemetryProcessorChainBuilder.UseAdaptiveSampling(5, includedTypes: "Event"); } }
private void SamplingPercentageChanged( double afterSamplingTelemetryItemRatePerSecond, double currentSamplingPercentage, double newSamplingPercentage, bool isSamplingPercentageChanged, SamplingPercentageEstimatorSettings settings) { if (isSamplingPercentageChanged) { this.samplingProcessor.SamplingPercentage = newSamplingPercentage; TelemetryChannelEventSource.Log.SamplingChanged(newSamplingPercentage); } this.evaluationCallback?.Invoke( afterSamplingTelemetryItemRatePerSecond, currentSamplingPercentage, newSamplingPercentage, isSamplingPercentageChanged, settings); }
/// <summary> /// Adds <see cref="AdaptiveSamplingTelemetryProcessor"/> to the <see cref="TelemetryProcessorChainBuilder" /> /// </summary> /// <param name="builder">Instance of <see cref="TelemetryProcessorChainBuilder"/></param> /// <param name="settings">Set of settings applicable to dynamic sampling percentage algorithm.</param> /// <param name="callback">Callback invoked every time sampling percentage evaluation occurs.</param> /// <return>Instance of <see cref="TelemetryProcessorChainBuilder"/>.</return> public static TelemetryProcessorChainBuilder UseAdaptiveSampling( this TelemetryProcessorChainBuilder builder, SamplingPercentageEstimatorSettings settings, AdaptiveSamplingPercentageEvaluatedCallback callback) { if (builder == null) { throw new ArgumentNullException("builder"); } if (settings == null) { throw new ArgumentNullException("settings"); } return(builder.Use(next => new AdaptiveSamplingTelemetryProcessor(settings, callback, next) { InitialSamplingPercentage = 100.0 / settings.EffectiveInitialSamplingRate })); }
/// <summary> /// Instantiates an instance. /// </summary> /// <param name="instrumentationKey">The Application Insights instrumentation key.</param> /// <param name="samplingSettings">The <see cref="SamplingPercentageEstimatorSettings"/> to use for configuring adaptive sampling. If null, sampling is disabled.</param> public DefaultTelemetryClientFactory(string instrumentationKey, SamplingPercentageEstimatorSettings samplingSettings) { _instrumentationKey = instrumentationKey; _samplingSettings = samplingSettings; }
private static void SetupTelemetryConfiguration( TelemetryConfiguration configuration, string instrumentationKey, SamplingPercentageEstimatorSettings samplingSettings, SnapshotCollectorConfiguration snapshotCollectorConfiguration, ITelemetryChannel channel, IEnumerable <ITelemetryInitializer> telemetryInitializers, IEnumerable <ITelemetryModule> telemetryModules, IApplicationIdProvider applicationIdProvider, LoggerFilterOptions filterOptions) { if (instrumentationKey != null) { configuration.InstrumentationKey = instrumentationKey; // Because of https://github.com/Microsoft/ApplicationInsights-dotnet-server/issues/943 // we have to touch (and create) Active configuration before initializing telemetry modules TelemetryConfiguration.Active.InstrumentationKey = instrumentationKey; } configuration.TelemetryChannel = channel; foreach (ITelemetryInitializer initializer in telemetryInitializers) { configuration.TelemetryInitializers.Add(initializer); } (channel as ServerTelemetryChannel)?.Initialize(configuration); QuickPulseTelemetryModule quickPulseModule = null; foreach (ITelemetryModule module in telemetryModules) { if (module is QuickPulseTelemetryModule telemetryModule) { quickPulseModule = telemetryModule; } module.Initialize(configuration); } QuickPulseTelemetryProcessor quickPulseProcessor = null; configuration.TelemetryProcessorChainBuilder .Use((next) => { quickPulseProcessor = new QuickPulseTelemetryProcessor(next); return(quickPulseProcessor); }) .Use((next) => new FilteringTelemetryProcessor(filterOptions, next)); if (samplingSettings != null) { configuration.TelemetryProcessorChainBuilder.Use((next) => new AdaptiveSamplingTelemetryProcessor(samplingSettings, null, next)); } if (snapshotCollectorConfiguration != null) { configuration.TelemetryProcessorChainBuilder.UseSnapshotCollector(snapshotCollectorConfiguration); } configuration.TelemetryProcessorChainBuilder.Build(); quickPulseModule?.RegisterTelemetryProcessor(quickPulseProcessor); foreach (ITelemetryProcessor processor in configuration.TelemetryProcessors) { if (processor is ITelemetryModule module) { module.Initialize(configuration); } } configuration.ApplicationIdProvider = applicationIdProvider; }
public ConsoleTelemetryClientFactory(string instrumentationKey, SamplingPercentageEstimatorSettings samplingSettings, Func <string, LogLevel, bool> filter) : base(instrumentationKey, samplingSettings, filter) { }
/// <summary> /// Instantiates an instance. /// </summary> /// <param name="instrumentationKey">The Application Insights instrumentation key.</param> /// <param name="samplingSettings">The <see cref="SamplingPercentageEstimatorSettings"/> to use for configuring adaptive sampling. If null, sampling is disabled.</param> /// <param name="filter"></param> public DefaultTelemetryClientFactory(string instrumentationKey, SamplingPercentageEstimatorSettings samplingSettings, Func <string, LogLevel, bool> filter) { _instrumentationKey = instrumentationKey; _samplingSettings = samplingSettings; _filter = filter; }
public Worker(ILogger <Worker> logger, TelemetryClient telemetryClient, IOptions <SamplingPercentageEstimatorSettings> settings) { _logger = logger; this._telemetryClient = telemetryClient; _settings = settings.Value; }
public ScriptTelemetryClientFactory(string instrumentationKey, SamplingPercentageEstimatorSettings samplingSettings) : base(instrumentationKey, samplingSettings) { }