/// <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); }