public static void LogTelemetry(string text, SeverityLevel severity = SeverityLevel.Information, Dictionary <string, string> properties = null)
{
if (TelemetryEnabled)
{
telemetry.TrackTrace($"UWP::{text}", severity, properties);
}
}
public ActionResult Index()
{
var tc = new TelemetryClient();
tc.TrackTrace("I made it to the home page", SeverityLevel.Error);
return View();
}
// GET api/values/5
public string Get(int id)
{
var client = new TelemetryClient();
client.TrackTrace("trace");
return "value";
}
public ActionResult Index()
{
ViewBag.Title = "Home Page";
var client = new TelemetryClient();
client.TrackTrace("trace");
return View();
}
public override void WriteLine(string message)
{
//// Note: A single instance of telemetry client is sufficient to track multiple telemetry items.
//var ai = new TelemetryClient();
//ai.TrackException(filterContext.Exception);
//var ai = new TelemetryClient();
//var trace = new TraceTelemetry("test2 " + message);
//trace.SeverityLevel = SeverityLevel.Critical;
//ai.Track(trace);
try
{
throw new Exception("error2" + message);
}
catch (Exception exc)
{
var telemetry = new Microsoft.ApplicationInsights.TelemetryClient();
telemetry.TrackTrace("anders test", SeverityLevel.Error);
telemetry.TrackTrace("Slow database response",
SeverityLevel.Warning,
new System.Collections.Generic.Dictionary <string, string> {
{ "database", "1111" }
});
telemetry.TrackException(exc);
}
//var storageAccount = CloudStorageAccount.Parse(Startup.Configuration.GetConnectionString("AzureWebJobsStorage"));
//var blobClient = storageAccount.CreateCloudBlobClient();
//var logBlobContainer = blobClient.GetContainerReference("websitelog");
//logBlobContainer.CreateIfNotExists();
//var now = DateTime.Now;
//var logBlob = logBlobContainer.GetBlockBlobReference($"{now.Year.ToString("D4")}/{now.Month.ToString("D2")}/{now.Day.ToString("D2")} {now.Hour.ToString("D2")}:{now.Minute.ToString("D2")}:{now.Second.ToString("D2")};{now.Millisecond} ERROR");
//logBlob.UploadText(message);
}
public void TrackDoesNotInitializeInstrumentationKeyFromConfigWhenItWasSetExplicitly()
{
var configuration = new TelemetryConfiguration
{
TelemetryChannel = new StubTelemetryChannel(),
InstrumentationKey = Guid.NewGuid().ToString()
};
var client = new TelemetryClient(configuration);
var expectedKey = Guid.NewGuid().ToString();
client.Context.InstrumentationKey = expectedKey;
client.TrackTrace("Test Message");
Assert.Equal(expectedKey, client.Context.InstrumentationKey);
}
public static void LogTelemetry(string text)
{
if (TelemetryEnabled)
{
//telemetry.TrackTrace($"UWP::{text}", 1,{ });
// var obj = {
// message: "Channel::" + message,
// severityLevel: 1,
// properties: logDetails
//};
Dictionary <string, string> dict = new Dictionary <string, string>();
dict.Add("Parameter1", "value1");
dict.Add("parameter2", "value2");
telemetry.TrackTrace("", 1, dict);
}
}
public void GrandChildTelemetryIsReportedProperlyBetweenBeginEndRequestWhenActivityIsLost()
{
this.module = this.CreateModule();
this.aspNetDiagnosticsSource.StartActivity();
var activity = Activity.Current;
Activity.Current.Stop();
Assert.IsNull(Activity.Current);
this.aspNetDiagnosticsSource.RestoreLostActivity(activity);
var restoredActivity = Activity.Current;
var trace = new TraceTelemetry();
var client = new TelemetryClient(this.configuration);
client.TrackTrace(trace);
this.aspNetDiagnosticsSource.ReportRestoredActivity(restoredActivity);
Assert.AreEqual(1, this.sendItems.Count);
restoredActivity.Stop();
this.aspNetDiagnosticsSource.StopLostActivity(activity);
Assert.AreEqual(3, this.sendItems.Count);
var requestRestoredTelemetry = (RequestTelemetry)this.sendItems[1];
Assert.IsNotNull(requestRestoredTelemetry);
Assert.AreEqual(3, this.sendItems.Count);
var requestTelemetry = (RequestTelemetry)this.sendItems[2];
Assert.IsNotNull(requestTelemetry);
Assert.AreEqual(requestTelemetry.Id, requestRestoredTelemetry.Context.Operation.ParentId);
Assert.AreEqual(restoredActivity.Id, requestRestoredTelemetry.Id);
Assert.AreEqual(requestTelemetry.Context.Operation.Id, requestRestoredTelemetry.Context.Operation.Id);
Assert.AreEqual(restoredActivity.ParentId, requestTelemetry.Id);
Assert.AreEqual(restoredActivity.Id, trace.Context.Operation.ParentId);
Assert.AreEqual(requestTelemetry.Context.Operation.Id, trace.Context.Operation.Id);
}
public void TrackUsesInstrumentationKeyFromConfigurationWhenTheInstrumenationKeyIsEmpty()
{
ITelemetry sentTelemetry = null;
var channel = new StubTelemetryChannel {
OnSend = telemetry => sentTelemetry = telemetry
};
var configuration = new TelemetryConfiguration {
TelemetryChannel = channel
};
var client = new TelemetryClient(configuration);
var observe = client.Context.InstrumentationKey;
string expectedKey = Guid.NewGuid().ToString();
configuration.InstrumentationKey = expectedKey;
Assert.DoesNotThrow(() => client.TrackTrace("Test Message"));
Assert.Equal(expectedKey, sentTelemetry.Context.InstrumentationKey);
}
public void TrackUsesInstrumentationKeyFromConfigIfEnvironmentVariableIsEmpty()
{
ITelemetry sentTelemetry = null;
var channel = new StubTelemetryChannel {
OnSend = telemetry => sentTelemetry = telemetry
};
var configuration = new TelemetryConfiguration {
TelemetryChannel = channel
};
var client = new TelemetryClient(configuration);
string expectedKey = Guid.NewGuid().ToString();
configuration.InstrumentationKey = expectedKey; // Set in config
Environment.SetEnvironmentVariable("APPINSIGHTS_INSTRUMENTATIONKEY", null); // Not set via env. variable
Assert.DoesNotThrow(() => client.TrackTrace("Test Message"));
Assert.Equal(expectedKey, sentTelemetry.Context.InstrumentationKey);
}
public void AppInsightsUsesActivityWhenDiagnosticSourceIsAvailableW3C()
{
// Regular use case - System.DiagnosticSource is available. Regular unit test can cover this scenario.
var config = new TelemetryConfiguration();
config.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
var tc = new TelemetryClient(config);
using (var requestOperation = tc.StartOperation <RequestTelemetry>("request", "guid"))
{
using (var dependencyOperation = tc.StartOperation <DependencyTelemetry>("dependency", "guid"))
{
// "guid" is not w3c compatible. Ignored
Assert.IsFalse(dependencyOperation.Telemetry.Id.StartsWith("|guid."));
// but "guid" will be stored in custom properties
Assert.AreEqual("guid", dependencyOperation.Telemetry.Properties["ai_legacyRootId"]);
tc.TrackTrace("Hello World!");
}
}
}
public void ChildTelemetryIsReportedProperlyBetweenBeginEndRequest()
{
this.module = this.CreateModule();
this.aspNetDiagnosticsSource.StartActivity();
var trace = new TraceTelemetry();
var client = new TelemetryClient(this.configuration);
client.TrackTrace(trace);
this.aspNetDiagnosticsSource.StopActivity();
Assert.AreEqual(2, this.sendItems.Count);
var requestTelemetry = this.sendItems[0] as RequestTelemetry ?? this.sendItems[1] as RequestTelemetry;
Assert.IsNotNull(requestTelemetry);
Assert.AreEqual(requestTelemetry.Id, trace.Context.Operation.ParentId);
Assert.AreEqual(requestTelemetry.Context.Operation.Id, trace.Context.Operation.Id);
}
public async Task UpdateSettings(string trainArguments = null, float? initialExplorationEpsilon = null, bool? isExplorationEnabled = null)
{
var token = Request.Headers["Authorization"];
if (token != ConfigurationManager.AppSettings[ApplicationMetadataStore.AKPassword])
throw new UnauthorizedAccessException();
var telemetry = new TelemetryClient();
try
{
telemetry.TrackTrace($"UpdateSettings(trainArguments={trainArguments}, initialExplorationEpsilon={initialExplorationEpsilon}, isExplorationEnabled={isExplorationEnabled})");
string azureStorageConnectionString = ConfigurationManager.AppSettings[ApplicationMetadataStore.AKConnectionString];
var storageAccount = CloudStorageAccount.Parse(azureStorageConnectionString);
var blobClient = storageAccount.CreateCloudBlobClient();
var settingsBlobContainer = blobClient.GetContainerReference(ApplicationBlobConstants.SettingsContainerName);
var blob = settingsBlobContainer.GetBlockBlobReference(ApplicationBlobConstants.LatestClientSettingsBlobName);
ApplicationClientMetadata clientMeta;
if (await blob.ExistsAsync())
clientMeta = JsonConvert.DeserializeObject<ApplicationClientMetadata>(await blob.DownloadTextAsync());
else
clientMeta = new ApplicationClientMetadata();
if (trainArguments != null)
clientMeta.TrainArguments = trainArguments;
if (initialExplorationEpsilon != null)
clientMeta.InitialExplorationEpsilon = (float)initialExplorationEpsilon;
if (isExplorationEnabled != null)
clientMeta.IsExplorationEnabled = (bool)isExplorationEnabled;
await blob.UploadTextAsync(JsonConvert.SerializeObject(clientMeta));
}
catch (Exception e)
{
telemetry.TrackException(e);
}
}
static void Main(string[] args)
{
if (args.Length == 1)
{
TelemetryClient client = new TelemetryClient(TelemetryConfiguration.Active);
client.TrackTrace("One trace is sent to make sure that SDK is initialized.");
string param = args[0];
switch (param)
{
case "unhandled" :
GenerateUnhandledException();
break;
case "unobserved" :
GenerateUnobservedException(client);
break;
}
}
else
throw new ArgumentException("One parameter is required");
}
public void AppInsightsUsesActivityWhenDiagnosticSourceIsAvailableNonW3C()
{
try
{
// Regular use case - System.DiagnosticSource is available. Regular unit test can cover this scenario.
var config = new TelemetryConfiguration();
DisableW3CFormatInActivity();
config.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
var tc = new TelemetryClient(config);
using (var requestOperation = tc.StartOperation <RequestTelemetry>("request", "guid"))
{
using (var dependencyOperation = tc.StartOperation <DependencyTelemetry>("dependency", "guid"))
{
Assert.IsTrue(dependencyOperation.Telemetry.Id.StartsWith("|guid."));
tc.TrackTrace("Hello World!");
}
}
}
finally
{
EnableW3CFormatInActivity();
}
}
public void TrackDoesNotInitializeInstrumentationKeyWhenItWasSetExplicitly()
{
var configuration = new TelemetryConfiguration { TelemetryChannel = new StubTelemetryChannel(), InstrumentationKey = Guid.NewGuid().ToString() };
var client = new TelemetryClient(configuration);
var expectedKey = Guid.NewGuid().ToString();
client.Context.InstrumentationKey = expectedKey;
client.TrackTrace("Test Message");
Assert.Equal(expectedKey, client.Context.InstrumentationKey);
}
/// <summary>
/// Reports a log event to telemetry.
/// </summary>
/// <param name="eventName"></param>
/// <param name="metric"></param>
public void ReportLog(object component, string message, SeverityLevel level = SeverityLevel.Information)
{
TelemetryClient client = new TelemetryClient();
client.TrackTrace($"[{component.GetType().Name}] {message}", level);
}
public void TrackWhenChannelIsNullWillThrowInvalidOperationException()
{
var config = new TelemetryConfiguration();
config.InstrumentationKey = "Foo";
var client = new TelemetryClient(config);
Assert.Throws<InvalidOperationException>(() => client.TrackTrace("test trace"));
}
public void TrackUsesInstrumentationKeyFromConfigurationWhenTheInstrumenationKeyIsEmpty()
{
ITelemetry sentTelemetry = null;
var channel = new StubTelemetryChannel { OnSend = telemetry => sentTelemetry = telemetry };
var configuration = new TelemetryConfiguration { TelemetryChannel = channel };
var client = new TelemetryClient(configuration);
var observe = client.Context.InstrumentationKey;
string expectedKey = Guid.NewGuid().ToString();
configuration.InstrumentationKey = expectedKey;
Assert.DoesNotThrow(() => client.TrackTrace("Test Message"));
Assert.Equal(expectedKey, sentTelemetry.Context.InstrumentationKey);
}
