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)
{
}
