public OtpEngine(Action <string> traceMessage, IOtpStoreFactory factory, TelemetryManager telemetryManager, MetricManager metricManager)
{
this.traceMessage = traceMessage;
this.otpStore = factory.GetStore();
this.otpStorage = telemetryManager;
this.metricManager = metricManager;
}
void Start()
{
player = transform.GetComponentInParent <Player>();
shotTimer = shotTimeLimit;
LockSign.GetComponent <SpriteRenderer>().enabled = false;
mm = GameObject.Find("EventSystem").GetComponent <MetricManager>();
}
public OperationController(
ISmsStoreFactory factory,
ServiceConfiguration configuration,
IReportManager reportManager,
IInboundManager inboundManager,
ICredentialManager credentialManager,
MetricManager metricManager)
{
this.store = factory.GetStore();
this.configuration = configuration;
this.reportManager = reportManager;
this.inboundManager = inboundManager;
this.credentialManager = credentialManager;
this.metricManager = metricManager;
this.random = new Random();
this.proxyFactory = new ServiceProxyFactory((c) =>
{
return(new FabricTransportServiceRemotingClientFactory(
serializationProvider: new ServiceRemotingJsonSerializationProvider()));
});
if (this.configuration.SmsOpsInfo.IsValid())
{
this.mailHelper = new MailHelper(this.configuration.SmsOpsInfo);
}
}
void Awake()
{
//We want to make sure that only one instance of the script
//exists throughout the game
//Therefore we destroy any instances created after the first instantiation
//of the script
if (Instance != null) //another Instance already exists
{
DestroyImmediate(gameObject);
}
else //Instance == null - First instantiation of script
{
DontDestroyOnLoad(gameObject);
Instance = this;
levelNameToIndex = new Dictionary <string, int>();
levelNameToIndex.Add("RitualLevel", 0);
levelNameToIndex.Add("CaveLevel", 1);
levelNameToIndex.Add("VillageLevel", 2);
levelNameToIndex.Add("CombatLevel", 3);
levelNameToIndex.Add("LastLevel", 4);
levelTimeMetrics = new int[5];
levelTimeMetrics[0] = 0;
levelTimeMetrics[1] = 0;
levelTimeMetrics[2] = 0;
levelTimeMetrics[3] = 0;
levelTimeMetrics[4] = 0;
deathTypeMetrics = new int[3];
deathTypeMetrics[0] = 0; //Fallen
deathTypeMetrics[1] = 0; //Gem
deathTypeMetrics[2] = 0; //Spikes
}
}
public SocialEngine(Action <string> traceMessage, string connectionString, MetricManager metricManager)
{
this.traceMessage = traceMessage;
this.storeManager = new StoreManager(connectionString);
this.telemetryManager = new TelemetryManager();
this.metricManager = metricManager;
}
void Start()
{
player = transform.GetComponentInParent <Player>();
shotTimer = 0;
//rapidCdDisplay.fillAmount = 1;
mm = GameObject.Find("EventSystem").GetComponent <MetricManager>();
}
private static MetricManager GetOrCreateMetricManager(TelemetryClient telemetryClient)
{
ConditionalWeakTable <TelemetryClient, MetricManager> metricManagers = s_metricManagersForTelemetryClients;
if (metricManagers == null)
{
ConditionalWeakTable <TelemetryClient, MetricManager> newTable = new ConditionalWeakTable <TelemetryClient, MetricManager>();
ConditionalWeakTable <TelemetryClient, MetricManager> prevTable = Interlocked.CompareExchange(ref s_metricManagersForTelemetryClients, newTable, null);
metricManagers = prevTable ?? newTable;
}
// Get the manager from the table:
MetricManager createdManager = null;
MetricManager chosenManager = metricManagers.GetValue(
telemetryClient,
(tc) =>
{
createdManager = new MetricManager(new ApplicationInsightsTelemetryPipeline(tc));
return(createdManager);
});
// If there was a race and we did not end up returning the manager we just created, we will notify it to give up its agregation cycle thread.
if (createdManager != null && false == Object.ReferenceEquals(createdManager, chosenManager))
{
Task fireAndForget = createdManager.StopDefaultAggregationCycleAsync();
}
return(chosenManager);
}
/// <summary>
/// Stops metric aggregation in advanced scenarios where a MetricManager was explicitly created using its ctor.
/// </summary>
/// <remarks>
/// Metric Manager does not encapsulate any disposable or native resourses. However, it encapsulates a managed thread.
/// In normal cases, a metric manager is accessed via convenience methods and consumers never need to worry about that thread.
/// However, advanced scenarios may explicitly create a metric manager instance. In such cases, consumers may need to call
/// this method on the explicitly created instance to let the thread know that it no longer needs to run. The thread will not
/// be aborted proactively. Instead, it will complete the ongoing aggregation cycle and then gracfully exit instead of scheduling
/// the next iteration. However, the background thread will not send any aggregated metrics if it has been notified to stop.
/// Therefore, this method flushes current data before sending the notification.
/// </remarks>
/// <param name="metricManager">The metric manager</param>
/// <returns>
/// You can await the returned Task if you want to be sure that the encapsulated thread completed.
/// If you just want to notify the thread to stop without waiting for it, do not await this method.
/// </returns>
public static Task StopDefaultAggregationCycleAsync(this MetricManager metricManager)
{
Util.ValidateNotNull(metricManager, nameof(metricManager));
metricManager.Flush();
return(metricManager.AggregationCycle.StopAsync());
}
/// <summary>
///
/// </summary>
/// <param name="metricManager"></param>
/// <param name="aggregationCycleKind"></param>
/// <param name="tactTimestamp"></param>
/// <returns></returns>
public static AggregationPeriodSummary StopAggregators(
this MetricManager metricManager,
MetricAggregationCycleKind aggregationCycleKind,
DateTimeOffset tactTimestamp)
{
Util.ValidateNotNull(metricManager, nameof(metricManager));
return(metricManager.AggregationManager.StopAggregators(aggregationCycleKind, tactTimestamp));
}
/// <summary>
///
/// </summary>
/// <param name="metricManager"></param>
/// <param name="aggregationCycleKind"></param>
/// <param name="tactTimestamp"></param>
/// <param name="futureFilter"></param>
/// <returns></returns>
public static AggregationPeriodSummary StartOrCycleAggregators(
this MetricManager metricManager,
MetricAggregationCycleKind aggregationCycleKind,
DateTimeOffset tactTimestamp,
IMetricSeriesFilter futureFilter)
{
Util.ValidateNotNull(metricManager, nameof(metricManager));
return(metricManager.AggregationManager.StartOrCycleAggregators(aggregationCycleKind, tactTimestamp, futureFilter));
}
public EmailEngine(
IEmailStoreFactory factory,
ServiceConfiguration configuration,
MetricManager metricManager,
ICredentialManager credentialManager)
{
this.store = factory.GetStore();
this.credentialManager = credentialManager;
this.metricManager = metricManager;
this.configuration = configuration;
}
private static void Metrics_SpecifiedPipeline(TelemetryConfiguration telemetryPipeline)
{
telemetryPipeline.InstrumentationKey = Guid.NewGuid().ToString("D");
MetricManager manager1 = telemetryPipeline.GetMetricManager();
Assert.IsNotNull(manager1);
MetricManager manager2 = telemetryPipeline.GetMetricManager();
Assert.IsNotNull(manager2);
Assert.AreEqual(manager1, manager2);
Assert.AreSame(manager1, manager2);
Assert.IsTrue(Object.ReferenceEquals(manager1, manager2));
StubTelemetryChannel telemetryCollector = new StubTelemetryChannel();
telemetryPipeline.TelemetryChannel = telemetryCollector;
Assert.AreSame(telemetryCollector, telemetryPipeline.TelemetryChannel);
//CollectingTelemetryInitializer telemetryCollector = new CollectingTelemetryInitializer();
//defaultTelemetryPipeline.TelemetryInitializers.Add(coll);
IMetricSeriesConfiguration seriesConfig = new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: false);
manager1.CreateNewSeries("ns", "Metric A", seriesConfig).TrackValue(42);
manager1.CreateNewSeries("ns", "Metric A", seriesConfig).TrackValue("18");
manager2.CreateNewSeries("ns", "Metric A", seriesConfig).TrackValue(10000);
manager2.CreateNewSeries("ns", "Metric B", seriesConfig).TrackValue(-0.001);
manager1.Flush();
Assert.AreEqual(4, telemetryCollector.TelemetryItems.Count);
Assert.IsInstanceOfType(telemetryCollector.TelemetryItems[0], typeof(MetricTelemetry));
Assert.AreEqual("Metric B", ((MetricTelemetry)telemetryCollector.TelemetryItems[0]).Name);
Assert.AreEqual(1, ((MetricTelemetry)telemetryCollector.TelemetryItems[0]).Count);
Assert.AreEqual(-0.001, ((MetricTelemetry)telemetryCollector.TelemetryItems[0]).Sum);
Assert.IsInstanceOfType(telemetryCollector.TelemetryItems[1], typeof(MetricTelemetry));
Assert.AreEqual("Metric A", ((MetricTelemetry)telemetryCollector.TelemetryItems[1]).Name);
Assert.AreEqual(1, ((MetricTelemetry)telemetryCollector.TelemetryItems[1]).Count);
Assert.AreEqual(10000, ((MetricTelemetry)telemetryCollector.TelemetryItems[1]).Sum);
Assert.IsInstanceOfType(telemetryCollector.TelemetryItems[2], typeof(MetricTelemetry));
Assert.AreEqual("Metric A", ((MetricTelemetry)telemetryCollector.TelemetryItems[2]).Name);
Assert.AreEqual(1, ((MetricTelemetry)telemetryCollector.TelemetryItems[2]).Count);
Assert.AreEqual(18, ((MetricTelemetry)telemetryCollector.TelemetryItems[2]).Sum);
Assert.IsInstanceOfType(telemetryCollector.TelemetryItems[3], typeof(MetricTelemetry));
Assert.AreEqual("Metric A", ((MetricTelemetry)telemetryCollector.TelemetryItems[3]).Name);
Assert.AreEqual(1, ((MetricTelemetry)telemetryCollector.TelemetryItems[3]).Count);
Assert.AreEqual(42, ((MetricTelemetry)telemetryCollector.TelemetryItems[3]).Sum);
}
private static Metric GetOrCreateMetric(
TelemetryClient telemetryClient,
MetricAggregationScope aggregationScope,
MetricIdentifier metricIdentifier,
MetricConfiguration metricConfiguration)
{
Util.ValidateNotNull(telemetryClient, nameof(telemetryClient));
MetricManager metricManager = telemetryClient.GetMetricManager(aggregationScope);
Metric metric = metricManager.Metrics.GetOrCreate(metricIdentifier, metricConfiguration);
return(metric);
}
void Awake()
{
// DontDestroyOnLoad (transform.gameObject);
if (Instance == null)
{
DontDestroyOnLoad(gameObject);
Instance = this;
}
else if (Instance != this)
{
Destroy(gameObject);
}
}
StopAggregators(
object metricManager,
int aggregationCycleKind,
DateTimeOffset tactTimestamp)
{
MetricManager manager = (MetricManager)metricManager;
MetricAggregationCycleKind cycle = SafeConvertMetricAggregationCycleKind(aggregationCycleKind);
AggregationPeriodSummary summary = MetricManagerExtensions.StopAggregators(manager, cycle, tactTimestamp);
var result = Tuple.Create(summary.NonpersistentAggregates, summary.PersistentAggregates);
return(result);
}
void Start()
{
spawnRatio = idealRatio;
StartCoroutine(SpawnWords());
collider = GetComponent <CircleCollider2D>();
audio = GetComponent <AudioSource>();
stored = FindObjectOfType <ScoreKeeper>();
stored.StartMeditation();
fade = FindObjectOfType <Fading>();
ps = GetComponent <ParticleSystem>();
metrics = GameObject.Find("ScoreKeeper").GetComponent <MetricManager>();
metrics.AddToAttempts(1);
}
static void Main(string[] args)
{
var metricManager = new MetricManager(new MetricsManagerHelpers());
var metrics = metricManager.GetOsMetrics();
Console.WriteLine();
Console.WriteLine("****** Mnemox Metrics ********************");
Console.WriteLine();
Console.WriteLine($"Memory total(bytes): {metrics.MemoryCapacityBytes}");
Console.WriteLine($"Memory used(bytes): {metrics.MemoryUsedBytes}");
Console.WriteLine($"Memory used(%): {metrics.MemoryUsedPercents}");
Console.WriteLine($"Total CPU usage(%): {metrics.TotalCpuUsagePercentage}");
Console.WriteLine($"Process CPU usage(%): {metrics.CurrentProcessCpuUsagePercentage}");
Console.WriteLine();
Console.WriteLine("******************************************");
Console.WriteLine();
}
public void InitializeExtractor(MetricManager metricManager)
{
this.responseSuccessTimeMetric = metricManager.CreateMetric(
MetricTerms.Autocollection.Metric.RequestDuration.Name,
new Dictionary <string, string>()
{
[MetricTerms.Autocollection.Request.PropertyNames.Success] = Boolean.TrueString,
[MetricTerms.Autocollection.MetricId.Moniker.Key] = MetricTerms.Autocollection.Metric.RequestDuration.Id,
});
this.responseFailureTimeMetric = metricManager.CreateMetric(
MetricTerms.Autocollection.Metric.RequestDuration.Name,
new Dictionary <string, string>()
{
[MetricTerms.Autocollection.Request.PropertyNames.Success] = Boolean.FalseString,
[MetricTerms.Autocollection.MetricId.Moniker.Key] = MetricTerms.Autocollection.Metric.RequestDuration.Id,
});
}
StartOrCycleAggregators(
object metricManager,
int aggregationCycleKind,
DateTimeOffset tactTimestamp,
Func <Tuple <bool,
Tuple <Func <object, double, bool>,
Func <object, object, bool> > > > metricSeriesFilter)
{
MetricManager manager = (MetricManager)metricManager;
MetricAggregationCycleKind cycle = SafeConvertMetricAggregationCycleKind(aggregationCycleKind);
var filter = new MetricSeriesFilterAdapter(metricSeriesFilter);
AggregationPeriodSummary summary = MetricManagerExtensions.StartOrCycleAggregators(manager, cycle, tactTimestamp, filter);
var result = Tuple.Create(summary.NonpersistentAggregates, summary.PersistentAggregates);
return(result);
}
void MethodX()
{
MetricManager manager = TelemetryConfiguration.Active.Metrics();
IMetricSeriesConfiguration config = new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false);
MetricSeries series1 = TelemetryConfiguration.Active.Metrics().CreateNewSeries(
"Cows Sold",
new Dictionary <string, string> {
["Color of Cow"] = "Red",
["Gender of Cow"] = "Female"
},
config);
series1.TrackValue(42);
series1.TrackValue(1);
series1.TrackValue(1);
series1.TrackValue(1);
}
/// <summary>@ToDo: Complete documentation before stable release. {811}</summary>
/// <param name="telemetryClient">@ToDo: Complete documentation before stable release. {225}</param>
/// <param name="aggregationScope">@ToDo: Complete documentation before stable release. {281}</param>
/// <returns>@ToDo: Complete documentation before stable release. {736}</returns>
public static MetricManager GetMetricManager(this TelemetryClient telemetryClient, MetricAggregationScope aggregationScope)
{
Util.ValidateNotNull(telemetryClient, nameof(telemetryClient));
switch (aggregationScope)
{
case MetricAggregationScope.TelemetryConfiguration:
TelemetryConfiguration pipeline = telemetryClient.TelemetryConfiguration;
return(pipeline.GetMetricManager());
case MetricAggregationScope.TelemetryClient:
MetricManager manager = GetOrCreateMetricManager(telemetryClient);
return(manager);
default:
throw new ArgumentException(Invariant($"Invalid value of {nameof(aggregationScope)} ({aggregationScope}). Only the following values are supported:")
+ Invariant($" ['{nameof(MetricAggregationScope)}.{MetricAggregationScope.TelemetryClient.ToString()}',")
+ Invariant($" '{nameof(MetricAggregationScope)}.{MetricAggregationScope.TelemetryConfiguration.ToString()}']."));
}
}
public void Metrics_CustomPipeline()
{
;
using (TelemetryConfiguration defaultTelemetryPipeline = TelemetryConfiguration.Active)
using (TelemetryConfiguration customTelemetryPipeline1 = Util.CreateAITelemetryConfig())
using (TelemetryConfiguration customTelemetryPipeline2 = Util.CreateAITelemetryConfig())
{
Assert.IsFalse(Object.ReferenceEquals(defaultTelemetryPipeline, customTelemetryPipeline1));
Assert.IsFalse(Object.ReferenceEquals(defaultTelemetryPipeline, customTelemetryPipeline2));
Assert.IsFalse(Object.ReferenceEquals(customTelemetryPipeline1, customTelemetryPipeline2));
MetricManager managerDef = defaultTelemetryPipeline.GetMetricManager();
MetricManager managerCust1 = customTelemetryPipeline1.GetMetricManager();
MetricManager managerCust2 = customTelemetryPipeline2.GetMetricManager();
Assert.IsNotNull(managerDef);
Assert.IsNotNull(managerCust1);
Assert.IsNotNull(managerCust2);
Assert.AreNotEqual(managerDef, managerCust1);
Assert.AreNotEqual(managerDef, managerCust2);
Assert.AreNotEqual(managerCust1, managerCust2);
Assert.AreNotSame(managerDef, managerCust1);
Assert.AreNotSame(managerDef, managerCust2);
Assert.AreNotSame(managerCust1, managerCust2);
Assert.IsFalse(Object.ReferenceEquals(managerDef, managerCust1));
Assert.IsFalse(Object.ReferenceEquals(managerDef, managerCust2));
Assert.IsFalse(Object.ReferenceEquals(managerCust1, managerCust2));
Metrics_SpecifiedPipeline(customTelemetryPipeline1);
Metrics_SpecifiedPipeline(customTelemetryPipeline2);
Util.CompleteDefaultAggregationCycle(managerDef);
Util.CompleteDefaultAggregationCycle(managerCust1);
Util.CompleteDefaultAggregationCycle(managerCust2);
}
}
public SmsProvider(StatelessServiceContext context)
: base(context)
{
this.configuration = new ServiceConfiguration(FabricRuntime.GetNodeContext(), context.CodePackageActivationContext);
this.storeFactory = new SmsStoreFactory(this.configuration.DefaultConnectionString);
this.billingAgent = new BillingAgent();
this.metricManager = new MetricManager(this.configuration);
// this.timeSeriesManager = this.BuildTimeSeriesManager();
this.credentialManager = new CredentialManager(this.storeFactory);
this.reportManager = new ReportManager(
this.storeFactory,
this.configuration,
this.billingAgent,
this.metricManager,
this.credentialManager);
this.inboundManager = new InboundManager(
this.storeFactory,
this.configuration,
this.reportManager,
this.credentialManager);
}
public OperationController(
IEmailStoreFactory factory,
IEmailEngine engine,
ServiceConfiguration configuration,
IReportManager reportManager,
ICredentialManager credentialManager,
MetricManager metricManager)
{
this.store = factory.GetStore();
this.engine = engine;
this.configuration = configuration;
this.reportManager = reportManager;
this.credentialManager = credentialManager;
this.metricManager = metricManager;
this.random = new Random();
this.proxyFactory = new ServiceProxyFactory((c) =>
{
return(new FabricTransportServiceRemotingClientFactory(
serializationProvider: new ServiceRemotingJsonSerializationProvider()));
});
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="metricManager"></param>
/// <param name="newExtensionStateInstanceFactory"></param>
/// <returns></returns>
public static T GetOrCreateExtensionState <T>(this MetricManager metricManager, Func <MetricManager, T> newExtensionStateInstanceFactory)
where T : class
{
Util.ValidateNotNull(metricManager, nameof(metricManager));
object cache = metricManager.GetOrCreateExtensionStateUnsafe(newExtensionStateInstanceFactory);
if (cache == null)
{
return(null);
}
T typedCache = cache as T;
if (typedCache == null)
{
throw new InvalidOperationException($"{nameof(MetricManagerExtensions)}.{nameof(GetOrCreateExtensionState)}<T>(..) expected to find a"
+ $" cache of type {typeof(T).FullName}, but the present cache was of"
+ $" type {cache.GetType().FullName}. This indicates that multiple extensions attempt to use"
+ $" this extension point of the {nameof(MetricManager)} in a conflicting manner.");
}
return(typedCache);
}
private static Metric GetOrCreateMetric(
TelemetryClient telemetryClient,
MetricAggregationScope aggregationScope,
string metricId,
string dimension1Name,
string dimension2Name,
IMetricConfiguration metricConfiguration)
{
Util.ValidateNotNull(telemetryClient, nameof(telemetryClient));
MetricManager metricManager = telemetryClient.GetMetricManager(aggregationScope);
MetricsCache cache = metricManager.GetOrCreateExtensionState(MetricsCache.CreateNewInstance);
if (cache == null)
{
throw new InvalidOperationException($"telemetryConfiguration.GetMetricManager().GetOrCreateExtensionState(..) unexpectedly returned null."
+ $" This indicates that multiple extensions attempt to use"
+ $" the \"Cache\" extension point of the {nameof(MetricManager)} in a conflicting manner.");
}
Metric metric = cache.GetOrCreateMetric(metricId, dimension1Name, dimension2Name, metricConfiguration);
return(metric);
}
void Start()
{
player = transform.GetComponent <Player>();
jump_timer = 0;
mm = GameObject.Find("EventSystem").GetComponent <MetricManager>();
}
internal static bool TryGetMetricManager(this TelemetryClient telemetryClient, out MetricManager metricManager)
{
if (telemetryClient == null)
{
metricManager = null;
return(false);
}
ConditionalWeakTable <TelemetryClient, MetricManager> metricManagers = metricManagersForTelemetryClients;
if (metricManagers == null)
{
metricManager = null;
return(false);
}
return(metricManagers.TryGetValue(telemetryClient, out metricManager));
}
public void SetMetricManager( MetricManager mmMetricManager )
{
// get the variable (attribute) by name
FieldInfo fiTest =
_objInstantiatedEvaluator.GetType().GetField( "mmMetricManager" );
if( fiTest == null )
throw new Exception( "Could not find attribute mmMetricManager" +
" in " + strLoadedDLLName );
// change the value of the variable
fiTest.SetValue( _objInstantiatedEvaluator, (object) mmMetricManager );
}
public DependencyFilteringWithMetricsTelemetryProcessor(ITelemetryProcessor next, TelemetryConfiguration configuration)
{
this.next = next;
this.manager = new MetricManager(new TelemetryClient(configuration));
}
static void Main_backup(string[] args)
{
var state = new _State();
state.Initialize();
TelemetryConfiguration configuration = new TelemetryConfiguration();
configuration.InstrumentationKey = "fb8a0b03-235a-4b52-b491-307e9fd6b209";
var telemetryChannel = new ServerTelemetryChannel();
telemetryChannel.Initialize(configuration);
configuration.TelemetryChannel = telemetryChannel;
// data collection modules
var dependencies = new DependencyTrackingTelemetryModule();
dependencies.Initialize(configuration);
// telemetry initializers
configuration.TelemetryInitializers.Add(new AppVersionTelemetryInitializer());
configuration.TelemetryInitializers.Add(new DefaultTelemetryInitializer());
configuration.TelemetryInitializers.Add(new BusinessTelemetryInitializer());
configuration.TelemetryInitializers.Add(new NodeNameTelemetryInitializer());
configuration.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
// telemetry processors
configuration.TelemetryProcessorChainBuilder
.Use((next) => { return(new PriceCalculatorTelemetryProcessor(next, state.Collected)); })
// .Use((next) => { return new MyTelemetryProcessor(next); })
// .Use((next) => { return new CleanAutoCollecctedTelemetryProcessor(next); })
// .Use((next) => { return new ExampleTelemetryProcessor(next); })
// send only 10% of all dependency data
.Use((next) =>
{
return(new SamplingTelemetryProcessor(next)
{
IncludedTypes = "Dependency",
SamplingPercentage = 10
});
})
// start sampling when load exceeds 2 events per second for all telemetry types except events
.Use((next) =>
{
return(new AdaptiveSamplingTelemetryProcessor(next)
{
ExcludedTypes = "Event",
MaxTelemetryItemsPerSecond = 2,
SamplingPercentageIncreaseTimeout = TimeSpan.FromSeconds(1),
SamplingPercentageDecreaseTimeout = TimeSpan.FromSeconds(1),
EvaluationInterval = TimeSpan.FromSeconds(1),
InitialSamplingPercentage = 25
});
})
.Use((next) => { return(new PriceCalculatorTelemetryProcessor(next, state.Sent)); })
.Build();
TelemetryClient client = new TelemetryClient(configuration);
var iterations = 0;
MetricManager metricManager = new MetricManager(client);
var itemsProcessed = metricManager.CreateMetric("Items processed");
var processingFailed = metricManager.CreateMetric("Failed processing");
var processingSize = metricManager.CreateMetric("Processing size");
while (!state.IsTerminated)
{
iterations++;
using (var operaiton = client.StartOperation <RequestTelemetry>("Process item"))
{
client.TrackEvent("test");
client.TrackTrace("Something happened");
try
{
HttpClient http = new HttpClient();
var task = http.GetStringAsync("http://bing.com");
task.Wait();
// metrics aggregation:
//itemsProcessed.Track(1);
//processingSize.Track(task.Result.Length);
//processingFailed.Track(0);
//client.TrackMetric("Response size", task.Result.Length);
//client.TrackMetric("Successful responses", 1);
}
catch (Exception exc)
{
//client.TrackMetric("Successful responses", 0);
//operaiton.Telemetry.Success = false;
// metrics aggregation:
//processingFailed.Track(1);
}
}
}
Console.WriteLine($"Program sent 1Mb of telemetry in {iterations} iterations!");
Console.ReadLine();
}
/// <summary>
/// Initializes the telemetry module.
/// </summary>
/// <param name="configuration">Telemetry Configuration used for creating TelemetryClient for sending exception statistics to Application Insights.</param>
public void Initialize(TelemetryConfiguration configuration)
{
// Core SDK creates 1 instance of a module but calls Initialize multiple times
if (!this.isInitialized)
{
lock (this.lockObject)
{
if (!this.isInitialized)
{
this.isInitialized = true;
this.telemetryClient = new TelemetryClient(configuration);
this.telemetryClient.Context.GetInternalContext().SdkVersion = SdkVersionUtils.GetSdkVersion("exstat:");
this.metricManager = new MetricManager(this.telemetryClient);
this.registerAction(this.CalculateStatistics);
}
}
}
}
