/// <summary>
/// Creating the Trace Telemetry event.
/// </summary>
private TraceTelemetry CreateTraceTelemetry(string message, object data = null, params JsonConverter[] dataConverters)
{
var traceTelemetry = new TraceTelemetry()
{
// Remaining properties should be set by Core SDK property providers.
InstrumentationKey = this.InstrumentationKey,
Timestamp = DateTimeOffset.UtcNow,
Message = message
};
if (data != null)
{
Type dataType = data.GetType();
traceTelemetry.Properties["SourceType"] = dataType.AssemblyQualifiedName;
string serializedData = Serializer.SerializeData(data, dataConverters);
traceTelemetry.Properties[dataType.Name] = serializedData;
}
return(traceTelemetry);
}
public void InitializeReadsRootIdFromCustomHeader()
{
var httpHeaders = new HttpRequestMessageProperty();
httpHeaders.Headers["headerName"] = "RootId";
var context = new MockOperationContext();
context.SetHttpHeaders(httpHeaders);
var initializer = new OperationCorrelationTelemetryInitializer();
initializer.RootOperationIdHeaderName = "headerName";
var requestTelemetry = context.Request;
var customerTelemetry = new TraceTelemetry();
initializer.Initialize(customerTelemetry, context);
Assert.AreEqual("RootId", customerTelemetry.Context.Operation.Id);
Assert.AreEqual("RootId", requestTelemetry.Context.Operation.Id);
}
protected static void ValidateTrace(TraceTelemetry telemetry, string expectedMessageContains,
string expectedCategory, string expectedOperationName = null, string expectedOperationId = null,
SeverityLevel expectedLevel = SeverityLevel.Information)
{
Assert.Contains(expectedMessageContains, telemetry.Message);
Assert.Equal(expectedLevel, telemetry.SeverityLevel);
Assert.Equal(expectedCategory, telemetry.Properties[LogConstants.CategoryNameKey]);
if (expectedCategory == LogCategories.Function || expectedCategory == LogCategories.Executor)
{
ValidateTelemetry(telemetry, expectedOperationId, expectedOperationName, expectedCategory, expectedLevel);
}
else
{
Assert.Null(telemetry.Context.Operation.Name);
Assert.Null(telemetry.Context.Operation.Id);
}
ValidateSdkVersion(telemetry);
}
private void InternalSendTraceTelemetry(TraceEvent eventData)
{
if (this.telemetryClient.TelemetryConfiguration.TelemetryChannel == null)
{
return;
}
var traceTelemetry = new TraceTelemetry
{
Message = eventData.ToString(),
};
if (!string.IsNullOrEmpty(this.DiagnosticsInstrumentationKey))
{
traceTelemetry.Context.InstrumentationKey = this.DiagnosticsInstrumentationKey;
}
traceTelemetry.Context.Operation.SyntheticSource = SdkTelemetrySyntheticSourceName;
this.telemetryClient.TrackTrace(traceTelemetry);
}
public int Compare(object x, object y)
{
TraceTelemetry template = x as TraceTelemetry;
TraceTelemetry actual = y as TraceTelemetry;
if (template == null || actual == null)
{
return(Comparer.DefaultInvariant.Compare(x, y));
}
bool equal = template.Message == actual.Message &&
template.SeverityLevel == actual.SeverityLevel &&
HaveProperties(template.Properties, actual.Properties);
if (equal)
{
return(0);
}
return(template.GetHashCode() < actual.GetHashCode() ? -1 : 1);
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = "company")] HttpRequestMessage req,
TraceWriter log,
ExecutionContext context)
{
log.Info("C# HTTP trigger function processed a request.");
TelemetryConfiguration.Active.InstrumentationKey = Environment.GetEnvironmentVariable("APPINSIGHTS_INSTRUMENTATIONKEY");
var instanceId = Environment.GetEnvironmentVariable("WEBSITE_INSTANCE_ID", EnvironmentVariableTarget.Process);
var writer = new TelemetryClient();
var traceTelemetry = new TraceTelemetry($"(Id={context.InvocationId})", SeverityLevel.Information);
traceTelemetry.Context.Operation.Id = context.InvocationId.ToString();
traceTelemetry.Context.Operation.ParentId = context.InvocationId.ToString();
traceTelemetry.Properties["WEBSITE_INSTANCE_ID"] = instanceId;
writer.TrackTrace(traceTelemetry);
await Task.Delay(300);
return(req.CreateResponse(HttpStatusCode.OK, "Company"));
}
/// <summary>
/// Send a trace.
/// </summary>
/// <param name="traceTelemetry">The trace record.</param>
public void TrackTrace(TraceTelemetryRecord traceTelemetry)
{
if (traceTelemetry is null)
{
throw new ArgumentNullException(nameof(traceTelemetry));
}
var t = new TraceTelemetry(
traceTelemetry.Message,
this.GetSeverityLevel(traceTelemetry.SeverityLevel));
foreach (var k in traceTelemetry.Properties.Keys)
{
t.Properties.Add(k, traceTelemetry.Properties[k]);
}
t.Timestamp = traceTelemetry.Timestamp;
t.Sequence = traceTelemetry.Sequence;
this.client.TrackTrace(t);
}
public static TraceTelemetry CreateTraceTelemetry(this IDialogContext ctx, string message = null, IDictionary <string, string> properties = null)
{
var t = new TraceTelemetry(message);
AddContextData(t.Properties, ctx);
var m = ctx.MakeMessage();
t.Properties.Add("ConversationId", m.Conversation.Id);
t.Properties.Add("UserId", m.Recipient.Id);
if (properties != null)
{
foreach (var p in properties)
{
t.Properties.Add(p);
}
}
return(t);
}
private static void SerializeTraceTelemetry(TraceTelemetry traceTelemetry, JsonWriter writer)
{
writer.WriteStartObject();
traceTelemetry.WriteTelemetryName(writer, "Message");
traceTelemetry.WriteEnvelopeProperties(writer);
writer.WritePropertyName("data");
writer.WriteStartObject();
writer.WriteProperty("baseType", traceTelemetry.BaseType);
writer.WritePropertyName("baseData");
writer.WriteStartObject();
writer.WriteProperty("ver", traceTelemetry.Data.ver);
writer.WriteProperty("message", traceTelemetry.Message);
if (traceTelemetry.SeverityLevel.HasValue)
{
writer.WriteProperty("severityLevel", traceTelemetry.SeverityLevel.Value.ToString());
}
writer.WriteProperty("properties", traceTelemetry.Properties);
writer.WriteEndObject();
writer.WriteEndObject();
writer.WriteEndObject();
}
public void ReportsSingleEvent()
{
using (var module = new DiagnosticSourceTelemetryModule())
{
var testDiagnosticSource = new TestDiagnosticSource();
var listeningRequest = new DiagnosticSourceListeningRequest(testDiagnosticSource.Name);
module.Sources.Add(listeningRequest);
module.Initialize(GetTestTelemetryConfiguration());
testDiagnosticSource.Write("Hey!", new { Prop1 = 1234 });
TraceTelemetry telemetry = (TraceTelemetry)this.adapterHelper.Channel.SentItems.First();
Assert.AreEqual("Hey!", telemetry.Message);
Assert.AreEqual(testDiagnosticSource.Name, telemetry.Properties["DiagnosticSource"]);
Assert.AreEqual(SeverityLevel.Information, telemetry.SeverityLevel);
Assert.AreEqual(1234.ToString(), telemetry.Properties["Prop1"]);
string expectedVersion = SdkVersionHelper.GetExpectedSdkVersion(typeof(DiagnosticSourceTelemetryModule), prefix: "dsl:");
Assert.AreEqual(expectedVersion, telemetry.Context.GetInternalContext().SdkVersion);
}
}
public async Task <List <string> > RunOrchestrator(
[OrchestrationTrigger] IDurableOrchestrationContext context)
{
var correlationContext = CorrelationTraceContext.Current as W3CTraceContext;
var trace = new TraceTelemetry(
$"Activity Id: {correlationContext?.TraceParent} ParentSpanId: {correlationContext?.ParentSpanId}");
trace.Context.Operation.Id = correlationContext?.TelemetryContextOperationId;
trace.Context.Operation.ParentId = correlationContext?.TelemetryContextOperationParentId;
_telemetryClient.Track(trace);
var outputs = new List <string>();
// Replace "hello" with the name of your Durable Activity Function.
outputs.Add(await context.CallActivityAsync <string>("Function1_Hello", "Tokyo"));
outputs.Add(await context.CallActivityAsync <string>("Function1_Hello", "Seattle"));
outputs.Add(await context.CallActivityAsync <string>("Function1_Hello", "London"));
// returns ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]
return(outputs);
}
/// <inheritdoc />
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter)
{
if (this.IsEnabled(logLevel))
{
TraceTelemetry traceTelemetry = new TraceTelemetry(formatter(state, exception), this.GetSeverityLevel(logLevel));
IDictionary <string, string> dict = traceTelemetry.Context.Properties;
dict["CategoryName"] = this.categoryName;
dict["Exception"] = exception?.ToString();
IReadOnlyList <KeyValuePair <string, object> > stateDictionary = state as IReadOnlyList <KeyValuePair <string, object> >;
if (stateDictionary != null)
{
foreach (KeyValuePair <string, object> item in stateDictionary)
{
dict[item.Key] = Convert.ToString(item.Value);
}
}
traceTelemetry.Context.GetInternalContext().SdkVersion = this.sdkVersion;
this.telemetryClient.TrackTrace(traceTelemetry);
}
}
public void TimeoutGettingK8sEnvNoException()
{
var envMock = new Mock <IK8sEnvironment>();
envMock.Setup(env => env.ContainerID).Returns("Cid");
var envFactoryMock = new Mock <IK8sEnvironmentFactory>();
envFactoryMock.Setup(f => f.CreateAsync(It.IsAny <DateTime>())).ReturnsAsync(envMock.Object, TimeSpan.FromMinutes(1));
KubernetesTelemetryInitializer target = new KubernetesTelemetryInitializer(
envFactoryMock.Object,
GetOptions(TimeSpan.FromSeconds(1)),
SDKVersionUtils.Instance);
ITelemetry telemetry = new TraceTelemetry();
ISupportProperties telemetryWithProperties = telemetry as ISupportProperties;
telemetryWithProperties.Properties["K8s.Container.ID"] = "No Crash";
target.Initialize(telemetry);
Assert.Equal("No Crash", telemetryWithProperties.Properties["K8s.Container.ID"]);
}
public ActionResult Register(RegisterModel model)
{
if (ModelState.IsValid)
{
// Attempt to register the user
try
{
WebSecurity.CreateUserAndAccount(model.UserName, model.Password);
WebSecurity.Login(model.UserName, model.Password);
// Migrate the newly registered user's shopping cart
MigrateShoppingCart(model.UserName);
var telemetryClient = new Microsoft.ApplicationInsights.TelemetryClient();
//Sample Trace telemetry
TraceTelemetry traceSample = new TraceTelemetry();
traceSample.Message = "Registered succesfully";
traceSample.SeverityLevel = SeverityLevel.Information;
telemetryClient.TrackTrace(traceSample);
return(RedirectToAction("Index", "Home"));
}
catch (MembershipCreateUserException e)
{
var telemetryClient = new Microsoft.ApplicationInsights.TelemetryClient();
//Sample Trace telemetry
TraceTelemetry traceSample = new TraceTelemetry();
traceSample.Message = "Registration failed";
traceSample.SeverityLevel = SeverityLevel.Error;
telemetryClient.TrackTrace(traceSample);
ModelState.AddModelError("", ErrorCodeToString(e.StatusCode));
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public void InitializeWithEmptyForOptionalPropertyDoesNotLogError()
{
var listener = new TestDiagnosticSourceObserver();
ApplicationInsightsKubernetesDiagnosticSource.Instance.Observable.SubscribeWithAdapter(listener);
var envMock = new Mock <IK8sEnvironment>();
envMock.Setup(env => env.ContainerName).Returns("Hello RoleName");
envMock.Setup(env => env.ContainerID).Returns("Cid");
envMock.Setup(env => env.ContainerName).Returns("CName");
envMock.Setup(env => env.PodID).Returns("Pid");
envMock.Setup(env => env.PodName).Returns("PName");
envMock.Setup(env => env.PodLabels).Returns("PLabels");
// The following properties are optional.
envMock.Setup(env => env.ReplicaSetUid).Returns <string>(null);
envMock.Setup(env => env.ReplicaSetName).Returns <string>(null);
envMock.Setup(env => env.DeploymentUid).Returns <string>(null);
envMock.Setup(env => env.DeploymentName).Returns <string>(null);
envMock.Setup(env => env.PodNamespace).Returns <string>(null);
envMock.Setup(env => env.NodeUid).Returns("Nid");
envMock.Setup(env => env.NodeName).Returns("NName");
var envFactoryMock = new Mock <IK8sEnvironmentFactory>();
envFactoryMock.Setup(f => f.CreateAsync(It.IsAny <DateTime>())).ReturnsAsync(() => envMock.Object);
KubernetesTelemetryInitializer target = new KubernetesTelemetryInitializer(
envFactoryMock.Object,
GetOptions(TimeSpan.FromSeconds(1)),
SDKVersionUtils.Instance);
ITelemetry telemetry = new TraceTelemetry();
target.Initialize(telemetry);
Assert.Equal(0, listener.GetCount(DiagnosticLogLevel.Error));
}
/// <summary>
/// Adds a property to a telemetry item.
/// </summary>
/// <param name="telemetry">Telemetry item that receives a new property.</param>
/// <param name="name">Property name.</param>
/// <param name="value">Property value.</param>
/// <remarks>There is a potential of naming conflicts between standard ETW properties (like Keywords, Channel)
/// and properties that are part of EventSource event payload. Because both end up in the same ITelemetry.Properties dictionary,
/// we need some sort of conflict resolution. When calling into this method, property name will be suffixed with a random number when duplicated name exists.</remarks>
private static void AddProperty(this TraceTelemetry telemetry, string name, string value)
{
Debug.Assert(!string.IsNullOrEmpty(name), "Property name should always be specified");
IDictionary <string, string> properties = telemetry.Properties;
if (!properties.ContainsKey(name))
{
properties.Add(name, value);
return;
}
string newKey = name + "_";
// Update property key till there is no such key in dict
do
{
newKey += TraceEventExtensions.random.Value.Next(0, 10);
}while (properties.ContainsKey(newKey));
properties.Add(newKey, value);
}
private static void SendTelemetry(HttpRequestMessage request, HttpResponseMessage response, TimeSpan duration)
{
TraceTelemetry telemetry;
if (response.StatusCode == HttpStatusCode.OK)
{
telemetry = new TraceTelemetry(TELEMETRY_NAME, SeverityLevel.Information);
telemetry.Properties.Add("response", $"STATUS: OK");
}
else
{
telemetry = new TraceTelemetry(TELEMETRY_NAME, SeverityLevel.Error);
telemetry.Properties.Add("response", $"STATUS: {response.StatusCode}; CONTENT: {response.Content.ReadAsStringAsync().Result}");
}
telemetry.Properties.Add("request", $"METHOD: {request.Method.ToString()}; URL: {request.RequestUri.AbsoluteUri}");
telemetry.Properties.Add("duration", duration.ToString("G"));
var client = new TelemetryClient();
client.TrackTrace(telemetry);
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequest req)
{
if (req.Query.ContainsKey("number") == false)
{
return(new BadRequestResult());
}
int number = Convert.ToInt32(req.Query["number"]);
if (number % 2 != 0)
{
_logger.TrackTrace("Number is not even", SeverityLevel.Error,
new Dictionary <string, string>()
{
{ "number", number.ToString() }
});
_logger.TrackException(new InvalidOperationException("Number not even"));
return(new OkObjectResult("number not even"));
}
else
{
await Http.GetAsync("http://google.com");
var trace = new TraceTelemetry("number is even", SeverityLevel.Information);
if (Activity.Current != null)
{
trace.Context.Operation.Id = Activity.Current.RootId;
trace.Context.Operation.ParentId = Activity.Current.ParentId;
}
_logger.TrackTrace(trace);
return(new OkObjectResult("number even"));
}
}
/// <summary>
/// Populates a standard set of properties on the <see cref="TraceTelemetry"/> with values from the a given EventSource event.
/// </summary>
/// <param name="telemetry">Telemetry item to populate with properties.</param>
/// <param name="eventSourceEvent">Event to extract values from.</param>
public static TraceTelemetry PopulateStandardProperties(this TraceTelemetry telemetry, EventWrittenEventArgs eventSourceEvent)
{
if (!string.IsNullOrWhiteSpace(eventSourceEvent.EventSource.Name))
{
telemetry.AddProperty(ProviderNameProperty, eventSourceEvent.EventSource.Name);
}
if (eventSourceEvent.EventSource.Guid != Guid.Empty)
{
telemetry.AddProperty(ProviderGuidProperty, eventSourceEvent.EventSource.Guid.ToString());
}
telemetry.AddProperty(nameof(EventWrittenEventArgs.EventId), eventSourceEvent.EventId.ToString(CultureInfo.InvariantCulture));
telemetry.AddProperty(nameof(EventWrittenEventArgs.EventName), eventSourceEvent.EventName);
if (eventSourceEvent.ActivityId != default(Guid))
{
telemetry.AddProperty(nameof(EventWrittenEventArgs.ActivityId), ActivityPathDecoder.GetActivityPathString(eventSourceEvent.ActivityId));
}
if (eventSourceEvent.RelatedActivityId != default(Guid))
{
telemetry.AddProperty(nameof(EventWrittenEventArgs.RelatedActivityId), ActivityPathDecoder.GetActivityPathString(eventSourceEvent.RelatedActivityId));
}
telemetry.AddProperty(nameof(EventWrittenEventArgs.Channel), eventSourceEvent.Channel.GetChannelName());
telemetry.AddProperty(nameof(EventWrittenEventArgs.Keywords), GetHexRepresentation((long)eventSourceEvent.Keywords));
telemetry.AddProperty(nameof(EventWrittenEventArgs.Opcode), eventSourceEvent.Opcode.GetOpcodeName());
if (eventSourceEvent.Tags != EventTags.None)
{
telemetry.AddProperty(nameof(EventWrittenEventArgs.Tags), GetHexRepresentation((int)eventSourceEvent.Tags));
}
if (eventSourceEvent.Task != EventTask.None)
{
telemetry.AddProperty(nameof(EventWrittenEventArgs.Task), GetHexRepresentation((int)eventSourceEvent.Task));
}
return(telemetry);
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
try
{
var bodyStr = JsonConvert.SerializeObject(filterContext.ActionArguments);
var telemetryClient = new TelemetryClient();
var traceTelemetry = new TraceTelemetry
{
Message = bodyStr,
SeverityLevel = SeverityLevel.Verbose
};
//Send a trace message for display in Diagnostic Search.
telemetryClient.TrackTrace(traceTelemetry);
}
catch { }
if (!filterContext.ModelState.IsValid)
{
filterContext.Result = new BadRequestObjectResult(filterContext.ModelState);
}
}
public void CreateFilingTarget_OperationIdIsDifferent()
{
// After initialization, the operation_Id should be set to a GUID.
TraceTelemetry telemetry = new TraceTelemetry();
ApplicationInsightsTelemetryInitializer initializer = new ApplicationInsightsTelemetryInitializer();
telemetry.Context.Operation.Id.Should().BeNull();
initializer.Initialize(telemetry);
telemetry.Context.Operation.Id.Should().NotBeNull();
Guid.TryParse(telemetry.Context.Operation.Id, out Guid temp).Should().BeTrue();
// A second telemetry item using a different Initializer should be assigned a different operation_Id
TraceTelemetry telemetry2 = new TraceTelemetry();
ApplicationInsightsTelemetryInitializer initializer2 = new ApplicationInsightsTelemetryInitializer();
telemetry2.Context.Operation.Id.Should().BeNull();
initializer2.Initialize(telemetry2);
telemetry2.Context.Operation.Id.Should().NotBeNull();
Guid.TryParse(telemetry2.Context.Operation.Id, out Guid temp2).Should().BeTrue();
telemetry.Context.Operation.Id.Should().NotBe(telemetry2.Context.Operation.Id);
}
public void AppInsightInit(AppInsightPayload _payload)
{
IServiceCollection services = new ServiceCollection();
services.AddApplicationInsightsTelemetryWorkerService("{AppInsight Key}");
IServiceProvider serviceProvider = services.BuildServiceProvider();
ILogger <Program> logger = serviceProvider.GetRequiredService <ILogger <Program> >();
telemetryClient = serviceProvider.GetRequiredService <TelemetryClient>();
using (telemetryClient.StartOperation <RequestTelemetry>(_payload._operation))
{
if (_payload._type.CompareTo(AppInsightLanguage.AppInsightEvent) == 0)
{
EventTelemetry _evt = new EventTelemetry();
_evt.Context.Operation.Id = _payload._correlationId;
_evt.Name = _payload._payload;
telemetryClient.TrackEvent(_payload._payload);
}
if (_payload._type.CompareTo(AppInsightLanguage.AppInsightTrace) == 0)
{
TraceTelemetry _trct = new TraceTelemetry();
_trct.Message = _payload._payload;
_trct.Context.Operation.Id = _payload._correlationId;
telemetryClient.TrackTrace(_trct);
}
if (_payload._type.CompareTo(AppInsightLanguage.AppInsightException) == 0)
{
ExceptionTelemetry _et = new ExceptionTelemetry();
_et.Exception = _payload._ex;
_et.Context.Operation.Id = _payload._correlationId;
telemetryClient.TrackException(_et);
}
}
telemetryClient.Flush();
}
public void TrackTrace(string message, LogLevel logLevel, EventId eventId)
{
try
{
var telemetry = new TraceTelemetry(
message,
LogLevelToSeverityLevel(logLevel));
telemetry.Properties[TelemetryPropertyEventId] = eventId.Id.ToString();
if (!string.IsNullOrWhiteSpace(eventId.Name))
{
telemetry.Properties[TelemetryPropertyEventName] = eventId.Name;
}
UnderlyingClient.TrackTrace(telemetry);
}
catch
{
// logging failed, don't allow exception to escape
}
}
/// <inheritdoc />
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter)
{
if (this.IsEnabled(logLevel))
{
var stateDictionary = state as IReadOnlyList <KeyValuePair <string, object> >;
if (exception == null)
{
var traceTelemetry = new TraceTelemetry(formatter(state, exception), this.GetSeverityLevel(logLevel));
PopulateTelemetry(traceTelemetry, stateDictionary);
this.telemetryClient.TrackTrace(traceTelemetry);
}
else
{
var exceptionTelemetry = new ExceptionTelemetry(exception);
exceptionTelemetry.Message = formatter(state, exception);
exceptionTelemetry.SeverityLevel = this.GetSeverityLevel(logLevel);
exceptionTelemetry.Context.Properties["Exception"] = exception.ToString();
PopulateTelemetry(exceptionTelemetry, stateDictionary);
this.telemetryClient.TrackException(exceptionTelemetry);
}
}
}
/// <summary>
/// Calls AI to report health.
/// </summary>
/// <param name="applicationName">Application name.</param>
/// <param name="serviceName">Service name.</param>
/// <param name="instance">Instance identifier.</param>
/// <param name="source">Name of the health source.</param>
/// <param name="property">Name of the health property.</param>
/// <param name="state">HealthState.</param>
/// <param name="cancellationToken">CancellationToken instance.</param>
public Task ReportHealthAsync(
string applicationName,
string serviceName,
string instance,
string source,
string property,
HealthState state,
CancellationToken cancellationToken)
{
if (this.IsEnabled)
{
SeverityLevel sev = (HealthState.Error == state)
? SeverityLevel.Error
: (HealthState.Warning == state) ? SeverityLevel.Warning : SeverityLevel.Information;
TraceTelemetry tt = new TraceTelemetry($"Health report: {source}:{property} is {Enum.GetName(typeof(HealthState), state)}", sev);
tt.Context.Cloud.RoleName = serviceName;
tt.Context.Cloud.RoleInstance = instance;
this._client.TrackTrace(tt);
}
return(Task.FromResult(0));
}
private void ValidateASingleMessageActionBased(
Action <ApplicationInsightsTraceListener, TraceEventCache> callTraceAction,
string instrumentationKey,
TraceOptions options)
{
TelemetryConfiguration.Active.TelemetryChannel = this.adapterHelper.Channel;
using (var listener = new ApplicationInsightsTraceListener(instrumentationKey))
{
listener.TraceOutputOptions = options;
TraceEventCache traceEventCache = new TraceEventCache();
PrivateObject privateObject = new PrivateObject(traceEventCache);
privateObject.SetField("timeStamp", DateTime.Now.Ticks);
privateObject.SetField("stackTrace", "Environment.StackTrace");
callTraceAction(listener, traceEventCache);
TraceTelemetry telemetry = (TraceTelemetry)this.adapterHelper.Channel.SentItems.FirstOrDefault();
Assert.IsNotNull(telemetry, "didn't got the event trace to the inner channel");
Assert.AreEqual(telemetry.Context.InstrumentationKey, instrumentationKey);
}
}
public void InitializerOverwritesProperties()
{
IDictionary context = new Dictionary <string, string> {
{ "APPINSIGHTS_APP_CONTEXT_a", "b" }, { "APPINSIGHTS_APP_CONTEXT_c", "d" }
};
var initializer = new ServiceContextTelemetryIntitializer("service-a", "1.2.3", context);
var traceTelemetry = new TraceTelemetry();
traceTelemetry.Context.Cloud.RoleName = "service-b";
traceTelemetry.Context.Component.Version = "1.0.0.0";
traceTelemetry.Properties.Add("a", "x");
initializer.Initialize(traceTelemetry);
Assert.Equal("service-a", traceTelemetry.Context.Cloud.RoleName);
Assert.Equal("1.2.3", traceTelemetry.Context.Component.Version);
Assert.Contains(traceTelemetry.Context.Properties, item => item.Key == "a" && item.Value == "b");
Assert.Contains(traceTelemetry.Context.Properties, item => item.Key == "c" && item.Value == "d");
Assert.Equal(2, traceTelemetry.Context.Properties.Count);
}
static void Main(string[] args)
{
_startupTime = DateTime.Now;
_logPrefix = $"[mrltest.net] [{_startupTime}] [{String.Join(" ", args)}]";
_appInsights = new TelemetryClient();
_appInsightsEnabled = false;
if (ConfigurationManager.AppSettings["ApplicationInsightsInstrumentationKey"] != null)
{
_appInsightsEnabled = true;
Console.WriteLine("ApplicationInsights is enabled");
//TelemetryConfiguration.Active.InstrumentationKey = ConfigurationManager.AppSettings["ApplicationInsightsInstrumentationKey"];
}
else
{
Console.WriteLine("ApplicationInsights is disabled");
}
log4net.Config.BasicConfigurator.Configure();
_log = log4net.LogManager.GetLogger(typeof(Program));
_log.Info($"{_logPrefix}: minima deify runagate cadence benzoin digitate");
if (_appInsightsEnabled)
{
var aiMsg = $"{_logPrefix}: wingmen pice careful hexagon assured usurp";
Console.WriteLine($"_appInsights.TrackEvent({aiMsg})");
_appInsights.TrackEvent(aiMsg);
}
_appInsights.TrackEvent($"{_logPrefix}: (.TrackEvent()) mosaic mire wane irvin must gt agnew hubbub");
var trace = new TraceTelemetry($"{_logPrefix}: (.Track()) elgin deus clarke feign clap soy infra velar");
_appInsights.Track(trace);
_appInsights.Flush();
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
/// <summary>
/// Emits the provided <paramref name="logEvent"/> to AI as an <see cref="TraceTelemetry"/>.
/// </summary>
/// <exception cref="ArgumentNullException"><paramref name="logEvent"/> is <see langword="null" />.</exception>
/// <exception cref="ArgumentException"><paramref name="logEvent"/> must have a <see cref="LogEvent.Exception"/>.</exception>
private void TrackAsTrace(LogEvent logEvent)
{
if (logEvent == null)
{
throw new ArgumentNullException("logEvent");
}
CheckForAndThrowIfDisposed();
var renderedMessage = logEvent.RenderMessage(FormatProvider);
var traceTelemetry = new TraceTelemetry(logEvent.MessageTemplate.Text)
{
Timestamp = logEvent.Timestamp,
SeverityLevel = logEvent.Level.ToSeverityLevel()
};
// write logEvent's .Properties to the AI one
ForwardLogEventPropertiesToTelemetryProperties(traceTelemetry, logEvent, renderedMessage);
TelemetryClient.TrackTrace(traceTelemetry);
}
public void InitializeSetsRoleName()
{
var envMock = new Mock <IK8sEnvironment>();
envMock.Setup(env => env.ContainerName).Returns("Hello RoleName");
var envFactoryMock = new Mock <IK8sEnvironmentFactory>();
envFactoryMock.Setup(f => f.CreateAsync(It.IsAny <DateTime>())).ReturnsAsync(() => envMock.Object);
Mock <ITelemetryKeyCache> keyCacheMock = new Mock <ITelemetryKeyCache>();
keyCacheMock.Setup(c => c.GetProcessedKey(It.IsAny <string>())).Returns <string>(input => input);
KubernetesTelemetryInitializer target = new KubernetesTelemetryInitializer(envFactoryMock.Object,
GetOptions(TimeSpan.FromSeconds(1)),
SDKVersionUtils.Instance,
keyCacheMock.Object);
ITelemetry telemetry = new TraceTelemetry();
target.Initialize(telemetry);
Assert.Equal("Hello RoleName", telemetry.Context.Cloud.RoleName);
}
/// <summary>
/// Send a trace message for display in Diagnostic Search.
/// </summary>
/// <param name="message">Message to display.</param>
/// <param name="severityLevel">Trace severity level.</param>
/// <param name="properties">Named string values you can use to search and classify events.</param>
public void TrackTrace(string message, SeverityLevel severityLevel, IDictionary<string, string> properties)
{
TraceTelemetry telemetry = new TraceTelemetry(message, severityLevel);
if (properties != null && properties.Count > 0)
{
Utils.CopyDictionary(properties, telemetry.Context.Properties);
}
this.TrackTrace(telemetry);
}
private static void SerializeTraceTelemetry(TraceTelemetry traceTelemetry, JsonWriter writer)
{
writer.WriteStartObject();
traceTelemetry.WriteTelemetryName(writer, TraceTelemetry.TelemetryName);
traceTelemetry.WriteEnvelopeProperties(writer);
writer.WritePropertyName("data");
{
writer.WriteStartObject();
// TODO: MetricTelemetry should write type as this.data.baseType once Common Schema 2.0 compliant.
writer.WriteProperty("baseType", traceTelemetry.BaseType);
writer.WritePropertyName("baseData");
{
writer.WriteStartObject();
writer.WriteProperty("ver", traceTelemetry.Data.ver);
writer.WriteProperty("message", traceTelemetry.Message);
if (traceTelemetry.SeverityLevel.HasValue)
{
writer.WriteProperty("severityLevel", traceTelemetry.SeverityLevel.Value.ToString());
}
writer.WriteProperty("properties", traceTelemetry.Properties); // TODO: handle case where the property dictionary doesn't need to be instantiated.
writer.WriteEndObject();
}
writer.WriteEndObject();
}
writer.WriteEndObject();
}
/// <summary>
/// Send a trace message for display in Diagnostic Search.
/// </summary>
/// <param name="telemetry">Message with optional properties.</param>
public void TrackTrace(TraceTelemetry telemetry)
{
telemetry = telemetry ?? new TraceTelemetry();
this.Track(telemetry);
}
