public async Task LogEventWithVersion_SinksToApplicationInsights_ResultsInTelemetryWithVersion()
        {
            // Arrange
            var eventName = "Update version";

            using (ILoggerFactory loggerFactory = CreateLoggerFactory(config => config.Enrich.WithVersion()))
            {
                ILogger logger = loggerFactory.CreateLogger <ApplicationInsightsSinkTests>();

                // Act
                logger.LogEvent(eventName);
            }

            // Assert
            using (ApplicationInsightsDataClient client = CreateApplicationInsightsClient())
            {
                await RetryAssertUntilTelemetryShouldBeAvailableAsync(async() =>
                {
                    EventsResults <EventsCustomEventResult> events = await client.Events.GetCustomEventsAsync(ApplicationId, filter: OnlyLastHourFilter);
                    Assert.Contains(events.Value, ev =>
                    {
                        return(ev.CustomEvent.Name == eventName &&
                               ev.CustomDimensions.TryGetValue(VersionEnricher.DefaultPropertyName, out string actualVersion) &&
                               !String.IsNullOrWhiteSpace(actualVersion));
                    });
                });
            }
        }
Beispiel #2
0
        public void LogEvent_WithEvent_CreatesEventTelemetry()
        {
            // Arrange
            const string eventName   = "Order Invoiced";
            var          spySink     = new InMemoryLogSink();
            string       operationId = $"operation-id-{Guid.NewGuid()}";
            ILogger      logger      = CreateLogger(spySink, config => config.Enrich.WithProperty(ContextProperties.Correlation.OperationId, operationId));

            var telemetryContext = new Dictionary <string, object>
            {
                ["OrderId"] = "ABC",
                ["Vendor"]  = "Contoso"
            };

            logger.LogEvent(eventName, telemetryContext);
            LogEvent logEvent = Assert.Single(spySink.CurrentLogEmits);

            Assert.NotNull(logEvent);

            var converter = ApplicationInsightsTelemetryConverter.Create();

            // Act
            IEnumerable <ITelemetry> telemetries = converter.Convert(logEvent, formatProvider: null);

            // Assert
            AssertDoesNotContainLogProperty(logEvent, EventTracking.EventLogEntry);
            Assert.Collection(telemetries, telemetry =>
            {
                var eventTelemetry = Assert.IsType <EventTelemetry>(telemetry);
                Assert.Equal(eventName, eventTelemetry.Name);
                AssertOperationContext(eventTelemetry, operationId);
                AssertContainsTelemetryProperty(eventTelemetry, "OrderId", "ABC");
                AssertContainsTelemetryProperty(eventTelemetry, "Vendor", "Contoso");
            });
        }
        public async Task LogEvent_SinksToApplicationInsights_ResultsInEventTelemetry()
        {
            // Arrange
            string eventName = BogusGenerator.Finance.AccountName();

            using (ILoggerFactory loggerFactory = CreateLoggerFactory())
            {
                ILogger logger = loggerFactory.CreateLogger <ApplicationInsightsSinkTests>();
                Dictionary <string, object> telemetryContext = CreateTestTelemetryContext();

                // Act
                logger.LogEvent(eventName, telemetryContext);
            }

            // Assert
            using (ApplicationInsightsDataClient client = CreateApplicationInsightsClient())
            {
                await RetryAssertUntilTelemetryShouldBeAvailableAsync(async() =>
                {
                    EventsResults <EventsCustomEventResult> results = await client.Events.GetCustomEventsAsync(ApplicationId, filter: OnlyLastHourFilter);
                    Assert.Contains(results.Value, result => result.CustomEvent.Name == eventName);
                });
            }
        }