public void SinkProcessorsAreInvoked()
{
var configuration = new TelemetryConfiguration();
var sentTelemetry = new List <ITelemetry>(1);
var channel = new StubTelemetryChannel();
channel.OnSend = (telemetry) => sentTelemetry.Add(telemetry);
configuration.TelemetryChannel = channel;
var chainBuilder = new TelemetryProcessorChainBuilder(configuration, configuration.DefaultTelemetrySink);
configuration.DefaultTelemetrySink.TelemetryProcessorChainBuilder = chainBuilder;
chainBuilder.Use((next) =>
{
var first = new StubTelemetryProcessor(next);
first.OnProcess = (telemetry) => telemetry.Context.Properties.Add("SeenByFirst", "true");
return(first);
});
chainBuilder.Use((next) =>
{
var second = new StubTelemetryProcessor(next);
second.OnProcess = (telemetry) => telemetry.Context.Properties.Add("SeenBySecond", "true");
return(second);
});
var client = new TelemetryClient(configuration);
client.TrackTrace("t1");
Assert.IsFalse(configuration.TelemetryProcessors.OfType <StubTelemetryProcessor>().Any()); // Both processors belong to the sink, not to the common chain.
Assert.AreEqual(1, sentTelemetry.Count);
Assert.IsTrue(sentTelemetry[0].Context.Properties.ContainsKey("SeenByFirst"));
Assert.IsTrue(sentTelemetry[0].Context.Properties.ContainsKey("SeenBySecond"));
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
//ApplicationInsight
//Initializers:
TelemetryConfiguration.Active.TelemetryInitializers.Add(new HttpTelemetryInitializer());
TelemetryConfiguration.Active.TelemetryInitializers.Add(new HttpRequestTelemetryInitializer());
TelemetryConfiguration.Active.TelemetryInitializers.Add(new WebMethodInitializer());
//Procesors:
TelemetryProcessorChainBuilder builder = TelemetryConfiguration.Active.DefaultTelemetrySink.TelemetryProcessorChainBuilder;
builder.Use((next) => new TelemetryUnAuthorizedFilter(next));
builder.Use((next) => new TelemetryPathFilter(next));
builder.Use((next) => new TelemetryBotFilter(next));
builder.Use((next) => new TelemetryFastRemoteDependencyCallsFilter(next));
builder.Use((next) => new SuccessfulDependencyFilter(next));
builder.Build();
}
public void CommonTelemetryProcessorsAreInvoked()
{
var configuration = new TelemetryConfiguration();
var sentTelemetry = new List <ITelemetry>(1);
var channel = new StubTelemetryChannel();
channel.OnSend = (telemetry) => sentTelemetry.Add(telemetry);
configuration.TelemetryChannel = channel;
var chainBuilder = new TelemetryProcessorChainBuilder(configuration);
configuration.TelemetryProcessorChainBuilder = chainBuilder;
chainBuilder.Use((next) =>
{
var first = new StubTelemetryProcessor(next);
first.OnProcess = (telemetry) => telemetry.Context.Properties.Add("SeenByFirst", "true");
return(first);
});
chainBuilder.Use((next) =>
{
var second = new StubTelemetryProcessor(next);
second.OnProcess = (telemetry) => telemetry.Context.Properties.Add("SeenBySecond", "true");
return(second);
});
var client = new TelemetryClient(configuration);
client.TrackTrace("t1");
Assert.AreEqual(1, sentTelemetry.Count);
Assert.IsTrue(sentTelemetry[0].Context.Properties.ContainsKey("SeenByFirst"));
Assert.IsTrue(sentTelemetry[0].Context.Properties.ContainsKey("SeenBySecond"));
}
internal static TelemetryConfiguration CreateTelemetryConfigWithExtractor(IList <ITelemetry> telemetrySentToChannel,
Func <ITelemetryProcessor, AutocollectedMetricsExtractor> extractorFactory)
{
ITelemetryChannel channel = new StubTelemetryChannel {
OnSend = (t) => telemetrySentToChannel.Add(t)
};
string iKey = Guid.NewGuid().ToString("D");
TelemetryConfiguration telemetryConfig = new TelemetryConfiguration(iKey, channel);
var channelBuilder = new TelemetryProcessorChainBuilder(telemetryConfig);
channelBuilder.Use(extractorFactory);
channelBuilder.Build();
TelemetryProcessorChain processors = telemetryConfig.TelemetryProcessorChain;
foreach (ITelemetryProcessor processor in processors.TelemetryProcessors)
{
ITelemetryModule m = processor as ITelemetryModule;
if (m != null)
{
m.Initialize(telemetryConfig);
}
}
return(telemetryConfig);
}
private static TelemetryProcessorChain CreateTelemetryProcessorChainWithSampling(IList <ITelemetry> sentTelemetry, double samplingPercentage, string excludedTypes = null, string includedTypes = null)
{
var tc = new TelemetryConfiguration {
TelemetryChannel = new StubTelemetryChannel()
};
tc.InstrumentationKey = Guid.NewGuid().ToString("D");
var channelBuilder = new TelemetryProcessorChainBuilder(tc);
channelBuilder.UseSampling(samplingPercentage, excludedTypes, includedTypes);
channelBuilder.Use(next => new StubTelemetryProcessor(next)
{
OnProcess = t => sentTelemetry.Add(t)
});
channelBuilder.Build();
TelemetryProcessorChain processors = tc.TelemetryProcessorChain;
foreach (ITelemetryProcessor processor in processors.TelemetryProcessors)
{
ITelemetryModule m = processor as ITelemetryModule;
if (m != null)
{
m.Initialize(tc);
}
}
return(processors);
}
/// <summary>
/// Adds <see cref="AdaptiveSamplingTelemetryProcessor"/> to the <see cref="TelemetryProcessorChainBuilder" />
/// </summary>
/// <param name="builder">Instance of <see cref="TelemetryProcessorChainBuilder"/></param>
/// <param name="maxTelemetryItemsPerSecond">Maximum number of telemetry items to be generated on this application instance.</param>
/// <return>Instance of <see cref="TelemetryProcessorChainBuilder"/>.</return>
public static TelemetryProcessorChainBuilder UseAdaptiveSampling(this TelemetryProcessorChainBuilder builder, double maxTelemetryItemsPerSecond)
{
return(builder.Use((next) => new AdaptiveSamplingTelemetryProcessor(next)
{
MaxTelemetryItemsPerSecond = maxTelemetryItemsPerSecond
}));
}
/// <summary>
/// Adds <see cref="SamplingTelemetryProcessor"/> to the given<see cref="TelemetryProcessorChainBuilder" />
/// </summary>
/// <param name="builder">Instance of <see cref="TelemetryProcessorChainBuilder"/></param>
/// <param name="samplingPercentage">Sampling Percentage to configure.</param>
/// <return>Instance of <see cref="TelemetryProcessorChainBuilder"/>.</return>
public static TelemetryProcessorChainBuilder UseSampling(this TelemetryProcessorChainBuilder builder, double samplingPercentage)
{
return(builder.Use((next) => new SamplingTelemetryProcessor(next)
{
SamplingPercentage = samplingPercentage
}));
}
public ApplicationInsightsWriter(string instrumentationKey, WriterOptions options)
{
TelemetryConfiguration.Active.InstrumentationKey = instrumentationKey;
TelemetryProcessorChainBuilder builder = TelemetryConfiguration.Active.TelemetryProcessorChainBuilder;
QuickPulseTelemetryProcessor quickPulseProcessor = null;
// add our own telemetry processor that can override session based variables
//builder.Use(next => new LogMagicTelemetryProcessor(next));
// optionally enable QuickPulse
/*
* - Free and is not counted towards the bill.
* - The latency is 1 second compared to a few minutes.
* - Retention is while the data is on the chart, not 90 days.
* - Data is only streamed while you are in Live Metrics view.
*/
if (options.EnableQuickPulse)
{
builder.Use((next) =>
{
quickPulseProcessor = new QuickPulseTelemetryProcessor(next);
return(quickPulseProcessor);
});
}
builder.Build();
_telemetryClient = new TelemetryClient(TelemetryConfiguration.Active);
_telemetryClient.InstrumentationKey = instrumentationKey;
_context = new InsightsContext(_telemetryClient, options);
if (options.EnableQuickPulse)
{
var quickPulse = new QuickPulseTelemetryModule();
quickPulse.Initialize(TelemetryConfiguration.Active);
quickPulse.RegisterTelemetryProcessor(quickPulseProcessor);
}
#if NETFULL
// see https://github.com/Microsoft/ApplicationInsights-dotnet-server/blob/develop/Src/PerformanceCollector/Perf.Shared/PerformanceCollectorModule.cs
if (options.CollectPerformanceCounters)
{
//optionally enable performance counters collection
var pcm = new PerformanceCollectorModule();
//custom counters can be easily added here if required
pcm.Counters.Add(new PerformanceCounterCollectionRequest(@"\.NET CLR Memory(LogMagic.Console)\# GC Handles", "GC Handles"));
pcm.Initialize(TelemetryConfiguration.Active);
}
#endif
TelemetryConfiguration.Active.TelemetryInitializers.Add(new OperationTelemetryInitialiser());
_options = options;
}
public Task <bool> UseProcessorSink(IConfiguration config, ILogger logger, TelemetryProcessorChainBuilder aiClientBuilder)
{
aiClientBuilder.Use((next) => new AppInsightAggMetricSink(
next: next,
logger: logger,
config: config));
return(Task.FromResult <bool>(true));
}
/// <summary>
/// Uses AppId information into the telemetry.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="appId">The AppId identify the application.</param>
/// <returns>The builder.</returns>
public static TelemetryProcessorChainBuilder UseAppId(
this TelemetryProcessorChainBuilder builder,
AppId appId)
{
builder
.Use((next) => new TelemetryReplicationProcessor(next, appId))
.Build();
return(builder);
}
/// <summary>
/// Adds <see cref="AdaptiveSamplingTelemetryProcessor"/> to the <see cref="TelemetryProcessorChainBuilder" />
/// </summary>
/// <param name="builder">Instance of <see cref="TelemetryProcessorChainBuilder"/></param>
/// <return>Instance of <see cref="TelemetryProcessorChainBuilder"/>.</return>
public static TelemetryProcessorChainBuilder UseAdaptiveSampling(this TelemetryProcessorChainBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
return(builder.Use(next => new AdaptiveSamplingTelemetryProcessor(next)));
}
/// <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 void ProactivelySampledInItemsPassAccordingToScoreIfCurrentRateIsHigherThanExpected()
{
var sentTelemetry = new List <ITelemetry>();
var tc = new TelemetryConfiguration
{
TelemetryChannel = new StubTelemetryChannel(),
InstrumentationKey = Guid.NewGuid().ToString("D")
};
var channelBuilder = new TelemetryProcessorChainBuilder(tc);
channelBuilder.Use(next => new SamplingTelemetryProcessor(next)
{
SamplingPercentage = 50,
ProactiveSamplingPercentage = 50
});
channelBuilder.Use(next => new StubTelemetryProcessor(next)
{
OnProcess = t => sentTelemetry.Add(t)
});
channelBuilder.Build();
int count = 5000;
for (int i = 0; i < count; i++)
{
var item = new RequestTelemetry();
item.Context.Operation.Id = ActivityTraceId.CreateRandom().ToHexString();
// generate a lot sampled-in items, only 1/CurrentProactiveSampledInRatioToTarget of them should pass through
// and SamplingPercentage of sampled-out items
if (SamplingScoreGenerator.GetSamplingScore(item.Context.Operation.Id) < 80)
{
item.ProactiveSamplingDecision = SamplingDecision.SampledIn;
}
tc.TelemetryProcessorChain.Process(item);
}
Assert.AreEqual(0, sentTelemetry.Count(i => ((ISupportAdvancedSampling)i).ProactiveSamplingDecision == SamplingDecision.None));
Assert.AreEqual(count / 2, sentTelemetry.Count(i => ((ISupportAdvancedSampling)i).ProactiveSamplingDecision == SamplingDecision.SampledIn), count / 2 / 10);
}
public void ProactivelySampledInItemsPassIfCurrentRateIsLowerThanExpected()
{
var sentTelemetry = new List <ITelemetry>();
var tc = new TelemetryConfiguration
{
TelemetryChannel = new StubTelemetryChannel(),
InstrumentationKey = Guid.NewGuid().ToString("D")
};
var channelBuilder = new TelemetryProcessorChainBuilder(tc);
channelBuilder.Use(next => new SamplingTelemetryProcessor(next)
{
SamplingPercentage = 50,
ProactiveSamplingPercentage = 100
});
channelBuilder.Use(next => new StubTelemetryProcessor(next)
{
OnProcess = t => sentTelemetry.Add(t)
});
channelBuilder.Build();
int sampledInCount = 0;
for (int i = 0; i < 1000; i++)
{
var item = new RequestTelemetry();
item.Context.Operation.Id = ActivityTraceId.CreateRandom().ToHexString();
// sample in random items - they all should pass through regardless of the score
if (i % 2 == 0)
{
item.ProactiveSamplingDecision = SamplingDecision.SampledIn;
sampledInCount++;
}
tc.TelemetryProcessorChain.Process(item);
}
// all proactively sampled in items passed through regardless of their score.
Assert.AreEqual(sampledInCount, sentTelemetry.Count(i => ((ISupportAdvancedSampling)i).ProactiveSamplingDecision == SamplingDecision.SampledIn));
}
/// <summary>
/// Adds <see cref="AdaptiveSamplingTelemetryProcessor"/> to the <see cref="TelemetryProcessorChainBuilder" />
/// </summary>
/// <param name="builder">Instance of <see cref="TelemetryProcessorChainBuilder"/></param>
/// <param name="maxTelemetryItemsPerSecond">Maximum number of telemetry items to be generated on this application instance.</param>
/// <return>Instance of <see cref="TelemetryProcessorChainBuilder"/>.</return>
public static TelemetryProcessorChainBuilder UseAdaptiveSampling(this TelemetryProcessorChainBuilder builder, double maxTelemetryItemsPerSecond)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
return(builder.Use(next => new AdaptiveSamplingTelemetryProcessor(next)
{
MaxTelemetryItemsPerSecond = maxTelemetryItemsPerSecond
}));
}
/// <summary>
/// Adds <see cref="SamplingTelemetryProcessor"/> to the given<see cref="TelemetryProcessorChainBuilder" />
/// </summary>
/// <param name="builder">Instance of <see cref="TelemetryProcessorChainBuilder"/></param>
/// <param name="samplingPercentage">Sampling Percentage to configure.</param>
/// <return>Instance of <see cref="TelemetryProcessorChainBuilder"/>.</return>
public static TelemetryProcessorChainBuilder UseSampling(this TelemetryProcessorChainBuilder builder, double samplingPercentage)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
return(builder.Use(next => new SamplingTelemetryProcessor(next)
{
SamplingPercentage = samplingPercentage
}));
}
/// <summary>
/// Adds <see cref="AdaptiveSamplingTelemetryProcessor"/> to the <see cref="TelemetryProcessorChainBuilder" />
/// </summary>
/// <param name="builder">Instance of <see cref="TelemetryProcessorChainBuilder"/></param>
/// <param name="excludedTypes">Semicolon separated list of types that should not be sampled.</param>
/// <param name="includedTypes">Semicolon separated list of types that should be sampled. All types are sampled when left empty.</param>
/// <return>Instance of <see cref="TelemetryProcessorChainBuilder"/>.</return>
public static TelemetryProcessorChainBuilder UseAdaptiveSampling(this TelemetryProcessorChainBuilder builder, string excludedTypes = null, string includedTypes = null)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
return(builder.Use(next => new AdaptiveSamplingTelemetryProcessor(next)
{
ExcludedTypes = excludedTypes,
IncludedTypes = includedTypes
}));
}
public void ConfigurationDisposesAllSinks()
{
var configuration = new TelemetryConfiguration();
var commonChainBuilder = new TelemetryProcessorChainBuilder(configuration);
configuration.TelemetryProcessorChainBuilder = commonChainBuilder;
var firstChannel = new StubTelemetryChannel();
bool firstChannelDisposed = false;
firstChannel.OnDispose = () => firstChannelDisposed = true;
configuration.DefaultTelemetrySink.TelemetryChannel = firstChannel;
var firstSinkChainBuilder = new TelemetryProcessorChainBuilder(configuration, configuration.DefaultTelemetrySink);
bool firstSinkTelemetryProcessorDisposed = false;
firstSinkChainBuilder.Use((next) =>
{
var firstSinkTelemetryProcessor = new StubTelemetryProcessor(next);
firstSinkTelemetryProcessor.OnDispose = () => firstSinkTelemetryProcessorDisposed = true;
return(firstSinkTelemetryProcessor);
});
configuration.DefaultTelemetrySink.TelemetryProcessorChainBuilder = firstSinkChainBuilder;
var secondChannel = new StubTelemetryChannel();
bool secondChannelDisposed = false;
secondChannel.OnDispose = () => secondChannelDisposed = true;
var secondSink = new TelemetrySink(configuration, secondChannel);
var secondSinkChainBuilder = new TelemetryProcessorChainBuilder(configuration, secondSink);
bool secondSinkTelemetryProcessorDisposed = false;
secondSinkChainBuilder.Use((next) =>
{
var secondSinkTelemetryProcessor = new StubTelemetryProcessor(next);
secondSinkTelemetryProcessor.OnDispose = () => secondSinkTelemetryProcessorDisposed = true;
return(secondSinkTelemetryProcessor);
});
secondSink.TelemetryProcessorChainBuilder = secondSinkChainBuilder;
configuration.TelemetrySinks.Add(secondSink);
var client = new TelemetryClient(configuration);
client.TrackTrace("t1");
configuration.Dispose();
// We expect the channels to not be disposed (because they were created externally to sinks), but the processors should be disposed.
Assert.IsTrue(firstSinkTelemetryProcessorDisposed);
Assert.IsTrue(secondSinkTelemetryProcessorDisposed);
Assert.IsFalse(firstChannelDisposed);
Assert.IsFalse(secondChannelDisposed);
}
internal TelemetryConfiguration InitializeConfiguration()
{
TelemetryConfiguration config = new TelemetryConfiguration()
{
InstrumentationKey = _instrumentationKey
};
AddInitializers(config);
// Plug in Live stream and adaptive sampling
QuickPulseTelemetryProcessor processor = null;
TelemetryProcessorChainBuilder builder = config.TelemetryProcessorChainBuilder
.Use((next) =>
{
processor = new QuickPulseTelemetryProcessor(next);
return(processor);
});
if (_samplingSettings != null)
{
builder.Use((next) =>
{
return(new AdaptiveSamplingTelemetryProcessor(_samplingSettings, null, next));
});
}
builder.Build();
_quickPulseModule = new QuickPulseTelemetryModule();
_quickPulseModule.Initialize(config);
_quickPulseModule.RegisterTelemetryProcessor(processor);
// Plug in perf counters
_perfModule = new PerformanceCollectorModule();
_perfModule.Initialize(config);
// Configure the TelemetryChannel
ITelemetryChannel channel = CreateTelemetryChannel();
// call Initialize if available
ITelemetryModule module = channel as ITelemetryModule;
if (module != null)
{
module.Initialize(config);
}
config.TelemetryChannel = channel;
return(config);
}
/// <summary>
/// Adds <see cref="SamplingTelemetryProcessor"/> to the given<see cref="TelemetryProcessorChainBuilder" />.
/// </summary>
/// <param name="builder">Instance of <see cref="TelemetryProcessorChainBuilder"/>.</param>
/// <param name="samplingPercentage">Sampling Percentage to configure.</param>
/// <param name="excludedTypes">Semicolon separated list of types that should not be sampled.</param>
/// <param name="includedTypes">Semicolon separated list of types that should be sampled. All types are sampled when left empty.</param>
/// <return>Same instance of <see cref="TelemetryProcessorChainBuilder"/>.</return>
public static TelemetryProcessorChainBuilder UseSampling(this TelemetryProcessorChainBuilder builder, double samplingPercentage, string excludedTypes = null, string includedTypes = null)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder.Use(next => new SamplingTelemetryProcessor(next)
{
SamplingPercentage = samplingPercentage,
ExcludedTypes = excludedTypes,
IncludedTypes = includedTypes,
}));
}
/// <summary>
/// Adds <see cref="AdaptiveSamplingTelemetryProcessor"/> to the <see cref="TelemetryProcessorChainBuilder" />.
/// </summary>
/// <param name="builder">Instance of <see cref="TelemetryProcessorChainBuilder"/>.</param>
/// <param name="maxTelemetryItemsPerSecond">Maximum number of telemetry items to be generated on this application instance.</param>
/// <param name="excludedTypes">Semicolon separated list of types that should not be sampled.</param>
/// <param name="includedTypes">Semicolon separated list of types that should be sampled. All types are sampled when left empty.</param>
/// <return>Same instance of <see cref="TelemetryProcessorChainBuilder"/>.</return>
public static TelemetryProcessorChainBuilder UseAdaptiveSampling(this TelemetryProcessorChainBuilder builder, double maxTelemetryItemsPerSecond, string excludedTypes = null, string includedTypes = null)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder.Use(next => new AdaptiveSamplingTelemetryProcessor(next)
{
MaxTelemetryItemsPerSecond = maxTelemetryItemsPerSecond,
ExcludedTypes = excludedTypes,
IncludedTypes = includedTypes,
}));
}
public ApplicationInsightsWriter(string instrumentationKey, WriterOptions options)
{
TelemetryConfiguration.Active.InstrumentationKey = instrumentationKey;
TelemetryProcessorChainBuilder builder = TelemetryConfiguration.Active.TelemetryProcessorChainBuilder;
builder.Use(next => new LogMagicTelemetryProcessor(next));
builder.Build();
_telemetryClient = new TelemetryClient(TelemetryConfiguration.Active);
_telemetryClient.InstrumentationKey = instrumentationKey;
_context = new InsightsContext(_telemetryClient, options);
_options = options;
}
private static TelemetryProcessorChain CreateTelemetryProcessorChainWithSampling(IList <ITelemetry> sentTelemetry, double samplingPercentage, string excludedTypes = null, string includedTypes = null)
{
var tc = new TelemetryConfiguration {
TelemetryChannel = new StubTelemetryChannel()
};
var channelBuilder = new TelemetryProcessorChainBuilder(tc);
channelBuilder.UseSampling(samplingPercentage, excludedTypes, includedTypes);
channelBuilder.Use(next => new StubTelemetryProcessor(next)
{
OnProcess = t => sentTelemetry.Add(t)
});
channelBuilder.Build();
return(tc.TelemetryProcessorChain);
}
private static TelemetryProcessorChain CreateTelemetryProcessorChainWithSampling(IList <ITelemetry> sentTelemetry, double samplingPercentage)
{
var tc = new TelemetryConfiguration()
{
TelemetryChannel = new StubTelemetryChannel()
};
var channelBuilder = new TelemetryProcessorChainBuilder(tc);
channelBuilder.UseSampling(samplingPercentage);
channelBuilder.Use((next) => new StubTelemetryProcessor(next)
{
OnProcess = (t) => sentTelemetry.Add(t)
});
channelBuilder.Build();
return(tc.TelemetryProcessors);
}
internal static TelemetryConfiguration CreateTelemetryConfigWithExtractor(IList <ITelemetry> telemetrySentToChannel,
Func <ITelemetryProcessor, AutocollectedMetricsExtractor> extractorFactory)
{
ITelemetryChannel channel = new StubTelemetryChannel
{
OnSend = (t) => telemetrySentToChannel.Add(t)
};
string iKey = Guid.NewGuid().ToString("D");
TelemetryConfiguration telemetryConfig = new TelemetryConfiguration(iKey, channel);
var channelBuilder = new TelemetryProcessorChainBuilder(telemetryConfig);
channelBuilder.Use(extractorFactory);
channelBuilder.Build();
return(telemetryConfig);
}
/// <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
}));
}
private TelemetryConfiguration GetAppInsightsTestTelemetryConfiguration()
{
var config = new TelemetryConfiguration();
config.InstrumentationKey = "58ce4b98-2e30-4ac1-982b-e47c85b8d31d"; // Fake, but needs to be there in order for TelemetryClient to call the processor chain.
var channel = new TestTelemetryChannel();
config.DefaultTelemetrySink.TelemetryChannel = channel;
var chainbuilder = new TelemetryProcessorChainBuilder(config, config.DefaultTelemetrySink);
chainbuilder.Use((next) =>
{
var p1 = new EventFlowTelemetryProcessor(next);
return(p1);
});
config.DefaultTelemetrySink.TelemetryProcessorChainBuilder = chainbuilder;
chainbuilder.Build();
return(config);
}
public void CommonAndSinkProcessorsAreInvoked()
{
var configuration = new TelemetryConfiguration();
var sentTelemetry = new List <ITelemetry>(1);
var channel = new StubTelemetryChannel();
channel.OnSend = (telemetry) => sentTelemetry.Add(telemetry);
configuration.TelemetryChannel = channel;
var commonChainBuilder = new TelemetryProcessorChainBuilder(configuration);
configuration.TelemetryProcessorChainBuilder = commonChainBuilder;
commonChainBuilder.Use((next) =>
{
var commonProcessor = new StubTelemetryProcessor(next);
commonProcessor.OnProcess = (telemetry) => telemetry.Context.Properties.Add("SeenByCommonProcessor", "true");
return(commonProcessor);
});
var sinkChainBuilder = new TelemetryProcessorChainBuilder(configuration, configuration.DefaultTelemetrySink);
configuration.DefaultTelemetrySink.TelemetryProcessorChainBuilder = sinkChainBuilder;
sinkChainBuilder.Use((next) =>
{
var sinkProcessor = new StubTelemetryProcessor(next);
sinkProcessor.OnProcess = (telemetry) => telemetry.Context.Properties.Add("SeenBySinkProcessor", "true");
return(sinkProcessor);
});
var client = new TelemetryClient(configuration);
client.TrackTrace("t1");
Assert.AreEqual(1, sentTelemetry.Count);
Assert.IsTrue(sentTelemetry[0].Context.Properties.ContainsKey("SeenByCommonProcessor"));
Assert.IsTrue(sentTelemetry[0].Context.Properties.ContainsKey("SeenBySinkProcessor"));
}
/// <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>
/// <param name="excludedTypes">Semicolon separated list of types that should not be sampled.</param>
/// <param name="includedTypes">Semicolon separated list of types that should be sampled. All types are sampled when left empty.</param>
/// <return>Instance of <see cref="TelemetryProcessorChainBuilder"/>.</return>
public static TelemetryProcessorChainBuilder UseAdaptiveSampling(
this TelemetryProcessorChainBuilder builder,
WindowsServer.Channel.Implementation.SamplingPercentageEstimatorSettings settings,
WindowsServer.Channel.Implementation.AdaptiveSamplingPercentageEvaluatedCallback callback,
string excludedTypes = null,
string includedTypes = null)
{
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,
ExcludedTypes = excludedTypes,
IncludedTypes = includedTypes
}));
}
/// <summary>
/// Adds <see cref="AdaptiveSamplingTelemetryProcessor"/> to the <see cref="TelemetryProcessorChainBuilder" />
/// </summary>
/// <param name="builder">Instance of <see cref="TelemetryProcessorChainBuilder"/></param>
/// <return>Instance of <see cref="TelemetryProcessorChainBuilder"/>.</return>
public static TelemetryProcessorChainBuilder UseAdaptiveSampling(this TelemetryProcessorChainBuilder builder)
{
return(builder.Use((next) => new AdaptiveSamplingTelemetryProcessor(next)));
}
