public void LogInformationWithMachineName_Without_CreatesTraceTelemetryWithPodNameAsRoleInstance()
{
// Arrange
var spySink = new InMemoryLogSink();
string operationId = $"operation-id-{Guid.NewGuid()}";
ILogger logger = CreateLogger(spySink, config =>
{
return(config.Enrich.WithProperty(ContextProperties.Correlation.OperationId, operationId)
.Enrich.WithProperty(General.ComponentName, "component")
.Enrich.WithProperty(General.MachineName, "machine"));
});
logger.LogInformation("trace message");
LogEvent logEvent = Assert.Single(spySink.CurrentLogEmits);
Assert.NotNull(logEvent);
var converter = ApplicationInsightsTelemetryConverter.Create();
// Act
IEnumerable <ITelemetry> telemetries = converter.Convert(logEvent, formatProvider: null);
// Assert
Assert.Collection(telemetries, telemetry =>
{
var traceTelemetry = Assert.IsType <TraceTelemetry>(telemetry);
Assert.Equal("trace message", traceTelemetry.Message);
Assert.Equal(logEvent.Timestamp, traceTelemetry.Timestamp);
Assert.Equal(SeverityLevel.Information, traceTelemetry.SeverityLevel);
Assert.Equal("component", traceTelemetry.Context.Cloud.RoleName);
Assert.Equal("machine", traceTelemetry.Context.Cloud.RoleInstance);
AssertOperationContext(traceTelemetry, operationId);
});
}
public void LogException_WithException_CreatesExceptionTelemetry()
{
// Arrange
string platform = $"platform-id-{Guid.NewGuid()}";
var exception = new PlatformNotSupportedException(platform);
var spySink = new InMemoryLogSink();
string operationId = $"operation-id-{Guid.NewGuid()}";
ILogger logger = CreateLogger(spySink, config => config.Enrich.WithProperty(ContextProperties.Correlation.OperationId, operationId));
logger.LogCritical(exception, exception.Message);
LogEvent logEvent = Assert.Single(spySink.CurrentLogEmits);
Assert.NotNull(logEvent);
var converter = ApplicationInsightsTelemetryConverter.Create();
// Act
IEnumerable <ITelemetry> telemetries = converter.Convert(logEvent, formatProvider: null);
// Assert
Assert.Collection(telemetries, telemetry =>
{
var exceptionTelemetryType = Assert.IsType <ExceptionTelemetry>(telemetry);
Assert.NotNull(exceptionTelemetryType);
Assert.NotNull(exceptionTelemetryType.Exception);
Assert.Equal(exception.Message, exceptionTelemetryType.Exception.Message);
AssertOperationContext(exceptionTelemetryType, operationId);
});
}
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");
});
}
/// <summary>
/// Adds a Serilog sink that writes <see cref="T:Serilog.Events.LogEvent">log events</see> to Azure Application Insights.
/// </summary>
/// <remarks>
/// Supported telemetry types are Traces, Dependencies, Events, Requests and Metrics for which we provide extensions on <see cref="ILogger" />.
/// </remarks>
/// <param name="loggerSinkConfiguration">The logger configuration.</param>
/// <param name="instrumentationKey">The required Application Insights key.</param>
/// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
/// <param name="configureOptions">The optional function to configure additional options to influence the behavior of how the telemetry is logged to Azure Application Insights.</param>
/// <exception cref="ArgumentNullException">Thrown when the <paramref name="loggerSinkConfiguration"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when the <paramref name="instrumentationKey"/> is blank.</exception>
public static LoggerConfiguration AzureApplicationInsights(
this LoggerSinkConfiguration loggerSinkConfiguration,
string instrumentationKey,
LogEventLevel restrictedToMinimumLevel,
Action <ApplicationInsightsSinkOptions> configureOptions)
{
Guard.NotNull(loggerSinkConfiguration, nameof(loggerSinkConfiguration), "Requires a logger configuration to add the Azure Application Insights sink to");
Guard.NotNullOrWhitespace(instrumentationKey, nameof(instrumentationKey), "Requires an instrumentation key to authenticate with Azure Application Insights while sinking telemetry");
var options = new ApplicationInsightsSinkOptions();
configureOptions?.Invoke(options);
return(loggerSinkConfiguration.ApplicationInsights(instrumentationKey, ApplicationInsightsTelemetryConverter.Create(options), restrictedToMinimumLevel));
}
public void LogRequestMessage_WithRequestAndResponse_CreatesRequestTelemetry()
{
// Arrange
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>
{
["Client"] = "https://localhost",
["ContentType"] = "application/json",
};
var request = new HttpRequestMessage(System.Net.Http.HttpMethod.Get, new Uri("https://" + "localhost" + "/api/v1/health"));
var statusCode = HttpStatusCode.OK;
var response = new HttpResponseMessage(statusCode);
TimeSpan duration = TimeSpan.FromSeconds(5);
logger.LogRequest(request, response, duration, 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, RequestTracking.RequestLogEntry);
Assert.Collection(telemetries, telemetry =>
{
var requestTelemetry = Assert.IsType <RequestTelemetry>(telemetry);
Assert.Equal("GET /api/v1/health", requestTelemetry.Name);
Assert.Equal(duration, requestTelemetry.Duration);
Assert.Equal(((int)statusCode).ToString(), requestTelemetry.ResponseCode);
Assert.True(requestTelemetry.Success);
Assert.Equal(operationId, requestTelemetry.Id);
Assert.Equal(new Uri("https://localhost/api/v1/health"), requestTelemetry.Url);
AssertOperationContext(requestTelemetry, operationId);
AssertContainsTelemetryProperty(requestTelemetry, "Client", "https://localhost");
AssertContainsTelemetryProperty(requestTelemetry, "ContentType", "application/json");
});
}
public void LogHttpDependency_WithHttpDependency_CreatesHttpDependencyTelemetry()
{
// Arrange
var spySink = new InMemoryLogSink();
string operationId = $"operation-id-{Guid.NewGuid()}";
ILogger logger = CreateLogger(spySink, config => config.Enrich.WithProperty(ContextProperties.Correlation.OperationId, operationId));
var request = new HttpRequestMessage(System.Net.Http.HttpMethod.Get, "https://localhost/api/v1/health");
var startTime = DateTimeOffset.UtcNow;
var duration = TimeSpan.FromSeconds(5);
var telemetryContext = new Dictionary <string, object>
{
["Port"] = "4000"
};
logger.LogHttpDependency(request, HttpStatusCode.OK, startTime, duration, 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, DependencyTracking.DependencyLogEntry);
Assert.Collection(telemetries, telemetry =>
{
var dependencyTelemetry = Assert.IsType <DependencyTelemetry>(telemetry);
Assert.Equal(DependencyType.Http.ToString(), dependencyTelemetry.Type);
Assert.Equal("localhost", dependencyTelemetry.Target);
Assert.Equal("GET /api/v1/health", dependencyTelemetry.Name);
Assert.Null(dependencyTelemetry.Data);
Assert.Equal(startTime, dependencyTelemetry.Timestamp);
Assert.Equal(duration, dependencyTelemetry.Duration);
Assert.Equal("200", dependencyTelemetry.ResultCode);
Assert.True(dependencyTelemetry.Success);
AssertOperationContext(dependencyTelemetry, operationId);
AssertContainsTelemetryProperty(dependencyTelemetry, "Port", "4000");
});
}
public void LogSqlDependency_WithSqlDependency_CreatesSqlDependencyTelemetry()
{
// Arrange
var spySink = new InMemoryLogSink();
string operationId = $"operation-id-{Guid.NewGuid()}";
ILogger logger = CreateLogger(spySink, config => config.Enrich.WithProperty(ContextProperties.Correlation.OperationId, operationId));
var startTime = DateTimeOffset.UtcNow;
var duration = TimeSpan.FromSeconds(5);
var telemetryContext = new Dictionary <string, object>
{
["Statement"] = "Query"
};
logger.LogSqlDependency("Server", "Database", "Users", "GET", isSuccessful: true, startTime: startTime, duration: duration, 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, DependencyTracking.DependencyLogEntry);
Assert.Collection(telemetries, telemetry =>
{
var dependencyTelemetry = Assert.IsType <DependencyTelemetry>(telemetry);
Assert.Equal(DependencyType.Sql.ToString(), dependencyTelemetry.Type);
Assert.Equal("Server", dependencyTelemetry.Target);
Assert.Equal("Database/Users", dependencyTelemetry.Name);
Assert.Equal("GET", dependencyTelemetry.Data);
Assert.Equal(startTime, dependencyTelemetry.Timestamp);
Assert.Equal(duration, dependencyTelemetry.Duration);
Assert.Null(dependencyTelemetry.ResultCode);
Assert.True(dependencyTelemetry.Success);
AssertOperationContext(dependencyTelemetry, operationId);
AssertContainsTelemetryProperty(dependencyTelemetry, "Statement", "Query");
});
}
public void LogCosmosSqlDependency_WithTableStorageDependency_CreatesDependencyTelemetry()
{
// Arrange
var spySink = new InMemoryLogSink();
string operationId = $"operation-id-{Guid.NewGuid()}";
ILogger logger = CreateLogger(spySink, config => config.Enrich.WithProperty(ContextProperties.Correlation.OperationId, operationId));
string container = _bogusGenerator.Commerce.ProductName();
string database = _bogusGenerator.Commerce.ProductName();
string accountName = _bogusGenerator.Finance.AccountName();
var startTime = DateTimeOffset.UtcNow;
var duration = TimeSpan.FromSeconds(5);
var telemetryContext = new Dictionary <string, object>
{
["Namespace"] = "azure.cosmos.namespace"
};
logger.LogCosmosSqlDependency(accountName, database, container, isSuccessful: true, startTime: startTime, duration: duration, context: 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, DependencyTracking.DependencyLogEntry);
Assert.Collection(telemetries, telemetry =>
{
var dependencyTelemetry = Assert.IsType <DependencyTelemetry>(telemetry);
Assert.Equal("Azure DocumentDB", dependencyTelemetry.Type);
Assert.Equal($"{database}/{container}", dependencyTelemetry.Data);
Assert.Equal(accountName, dependencyTelemetry.Target);
Assert.Equal(startTime, dependencyTelemetry.Timestamp);
Assert.Equal(duration, dependencyTelemetry.Duration);
Assert.True(dependencyTelemetry.Success);
AssertContainsTelemetryProperty(dependencyTelemetry, "Namespace", "azure.cosmos.namespace");
});
}
public void LogServiceBusDependency_WithServiceBusDependency_CreatesDependencyTelemetry()
{
// Arrange
var spySink = new InMemoryLogSink();
string operationId = $"operation-id-{Guid.NewGuid()}";
ILogger logger = CreateLogger(spySink, config => config.Enrich.WithProperty(ContextProperties.Correlation.OperationId, operationId));
string entityName = $"entity-name-{Guid.NewGuid()}";
const ServiceBusEntityType entityType = ServiceBusEntityType.Unknown;
var startTime = DateTimeOffset.UtcNow;
var duration = TimeSpan.FromSeconds(5);
var telemetryContext = new Dictionary <string, object>
{
["Namespace"] = "azure.servicebus.namespace"
};
logger.LogServiceBusDependency(entityName, entityType: entityType, isSuccessful: true, startTime: startTime, duration: duration, context: 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, DependencyTracking.DependencyLogEntry);
Assert.Collection(telemetries, telemetry =>
{
var dependencyTelemetry = Assert.IsType <DependencyTelemetry>(telemetry);
Assert.Equal("Azure Service Bus", dependencyTelemetry.Type);
Assert.Equal(entityName, dependencyTelemetry.Target);
Assert.Equal(startTime, dependencyTelemetry.Timestamp);
Assert.Equal(duration, dependencyTelemetry.Duration);
Assert.True(dependencyTelemetry.Success);
AssertContainsTelemetryProperty(dependencyTelemetry, "Namespace", "azure.servicebus.namespace");
AssertContainsTelemetryProperty(dependencyTelemetry, "EntityType", entityType.ToString());
});
}
public void LogDependency_WithDependency_CreatesDependencyTelemetry()
{
// Arrange
var spySink = new InMemoryLogSink();
string operationId = $"operation-id-{Guid.NewGuid()}";
ILogger logger = CreateLogger(spySink, config => config.Enrich.WithProperty(ContextProperties.Correlation.OperationId, operationId));
string dependencyType = $"dependency-{Guid.NewGuid()}";
const int dependencyData = 10;
var startTime = DateTimeOffset.UtcNow;
var duration = TimeSpan.FromSeconds(5);
var telemetryContext = new Dictionary <string, object>
{
["CustomSetting"] = "Approved"
};
logger.LogDependency(dependencyType, dependencyData, isSuccessful: true, startTime: startTime, duration: duration, context: 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, DependencyTracking.DependencyLogEntry);
Assert.Collection(telemetries, telemetry =>
{
var dependencyTelemetry = Assert.IsType <DependencyTelemetry>(telemetry);
Assert.Equal(dependencyType, dependencyTelemetry.Type);
Assert.Equal(dependencyData.ToString(), dependencyTelemetry.Data);
Assert.Equal(startTime, dependencyTelemetry.Timestamp);
Assert.Equal(duration, dependencyTelemetry.Duration);
Assert.True(dependencyTelemetry.Success);
AssertContainsTelemetryProperty(dependencyTelemetry, "CustomSetting", "Approved");
});
}
public void LogMetric_WithMetric_CreatesMetricTelemetry()
{
// Arrange
const string metricName = "Request stream";
const double metricValue = 0.13;
var timestamp = DateTimeOffset.UtcNow;
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>
{
["Capacity"] = "0.45"
};
logger.LogMetric(metricName, metricValue, timestamp, 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, MetricTracking.MetricLogEntry);
Assert.Collection(telemetries, telemetry =>
{
var metricTelemetry = Assert.IsType <MetricTelemetry>(telemetry);
Assert.Equal(metricName, metricTelemetry.Name);
Assert.Equal(metricValue, metricTelemetry.Sum);
Assert.Equal(timestamp, metricTelemetry.Timestamp);
AssertOperationContext(metricTelemetry, operationId);
AssertContainsTelemetryProperty(metricTelemetry, "Capacity", "0.45");
});
}
