public void Processor_UsesFilter(LogLevel defaultLevel, LogLevel categoryLevel, LogLevel telemetryLevel, bool isEnabled)
{
var filter = new LogCategoryFilter
{
DefaultLevel = defaultLevel
};
filter.CategoryLevels[LogCategories.Results] = categoryLevel;
var processor = new FilteringTelemetryProcessor(filter.Filter, _nextTelemetryProcessorMock.Object);
var telemetry = new TestTelemetry();
telemetry.Properties[LogConstants.CategoryNameKey] = LogCategories.Results;
telemetry.Properties[LogConstants.LogLevelKey] = telemetryLevel.ToString();
processor.Process(telemetry);
if (isEnabled)
{
_nextTelemetryProcessorMock.Verify(m => m.Process(telemetry), Times.Once);
}
else
{
_nextTelemetryProcessorMock.Verify(m => m.Process(It.IsAny <ITelemetry>()), Times.Never);
}
}
public DurableTaskEndToEndTests(ITestOutputHelper output)
{
this.output = output;
// Set to false to manually verify log entries in Application Insights but tests with TestHelpers.AssertLogMessageSequence will be skipped
this.useTestLogger = true;
loggerProvider = new TestLoggerProvider();
loggerFactory = new LoggerFactory();
if (useTestLogger)
{
loggerFactory.AddProvider(loggerProvider);
}
else
{
if (!string.IsNullOrEmpty(instrumentationKey))
{
var filter = new LogCategoryFilter
{
DefaultLevel = LogLevel.Debug
};
filter.CategoryLevels[TestHelpers.LogCategory] = LogLevel.Debug;
loggerFactory = new LoggerFactory()
.AddApplicationInsights(instrumentationKey, filter.Filter);
}
}
}
public void Processor_MissingCategory_FiltersAsDefault(LogLevel telemetryLevel, bool isEnabled)
{
var filter = new LogCategoryFilter
{
DefaultLevel = LogLevel.Information
};
var processor = new FilteringTelemetryProcessor(filter.Filter, _nextTelemetryProcessorMock.Object);
var telemetry = new TestTelemetry();
telemetry.Properties[LogConstants.LogLevelKey] = telemetryLevel.ToString();
// no category specified
processor.Process(telemetry);
if (isEnabled)
{
_nextTelemetryProcessorMock.Verify(m => m.Process(telemetry), Times.Once);
}
else
{
_nextTelemetryProcessorMock.Verify(m => m.Process(It.IsAny <ITelemetry>()), Times.Never);
}
}
public async Task ApplicationInsights_SuccessfulFunction()
{
string testName = nameof(TestApplicationInsightsInformation);
LogCategoryFilter filter = new LogCategoryFilter();
filter.DefaultLevel = LogLevel.Information;
var loggerFactory = new LoggerFactory()
.AddApplicationInsights(
new TestTelemetryClientFactory(filter.Filter, _channel));
JobHostConfiguration config = new JobHostConfiguration
{
LoggerFactory = loggerFactory,
TypeLocator = new FakeTypeLocator(GetType()),
};
config.Aggregator.IsEnabled = false;
config.AddService <IWebJobsExceptionHandler>(new TestExceptionHandler());
using (JobHost host = new JobHost(config))
{
await host.StartAsync();
var methodInfo = GetType().GetMethod(testName, BindingFlags.Public | BindingFlags.Static);
await host.CallAsync(methodInfo, new { input = "function input" });
await host.StopAsync();
}
Assert.Equal(7, _channel.Telemetries.Count);
// Validate the traces. Order by message string as the requests may come in
// slightly out-of-order or on different threads
TraceTelemetry[] telemetries = _channel.Telemetries
.OfType <TraceTelemetry>()
.OrderBy(t => t.Message)
.ToArray();
ValidateTrace(telemetries[0], "Found the following functions:\r\n", LogCategories.Startup);
ValidateTrace(telemetries[1], "Job host started", LogCategories.Startup);
ValidateTrace(telemetries[2], "Job host stopped", LogCategories.Startup);
ValidateTrace(telemetries[3], "Logger", LogCategories.Function, testName, hasCustomScope: true);
ValidateTrace(telemetries[4], "Trace", LogCategories.Function, testName);
// We should have 1 custom metric.
MetricTelemetry metric = _channel.Telemetries
.OfType <MetricTelemetry>()
.Single();
ValidateMetric(metric, testName);
// Finally, validate the request
RequestTelemetry request = _channel.Telemetries
.OfType <RequestTelemetry>()
.Single();
ValidateRequest(request, testName, true);
}
public SingletonManagerTests()
{
_mockAccountProvider = new Mock <IStorageAccountProvider>(MockBehavior.Strict);
_mockBlobDirectory = new Mock <IStorageBlobDirectory>(MockBehavior.Strict);
_mockSecondaryBlobDirectory = new Mock <IStorageBlobDirectory>(MockBehavior.Strict);
_mockStorageAccount = new Mock <IStorageAccount>(MockBehavior.Strict);
_mockStorageAccount.SetupGet(a => a.Type).Returns(StorageAccountType.GeneralPurpose);
_mockSecondaryStorageAccount = new Mock <IStorageAccount>(MockBehavior.Strict);
_mockSecondaryStorageAccount.SetupGet(a => a.Type).Returns(StorageAccountType.GeneralPurpose);
Mock <IStorageBlobClient> mockBlobClient = new Mock <IStorageBlobClient>(MockBehavior.Strict);
Mock <IStorageBlobClient> mockSecondaryBlobClient = new Mock <IStorageBlobClient>(MockBehavior.Strict);
Mock <IStorageBlobContainer> mockBlobContainer = new Mock <IStorageBlobContainer>(MockBehavior.Strict);
mockBlobContainer.Setup(p => p.GetDirectoryReference(HostDirectoryNames.SingletonLocks)).Returns(_mockBlobDirectory.Object);
mockBlobClient.Setup(p => p.GetContainerReference(HostContainerNames.Hosts)).Returns(mockBlobContainer.Object);
Mock <IStorageBlobContainer> mockSecondaryBlobContainer = new Mock <IStorageBlobContainer>(MockBehavior.Strict);
mockSecondaryBlobContainer.Setup(p => p.GetDirectoryReference(HostDirectoryNames.SingletonLocks)).Returns(_mockSecondaryBlobDirectory.Object);
mockSecondaryBlobClient.Setup(p => p.GetContainerReference(HostContainerNames.Hosts)).Returns(mockSecondaryBlobContainer.Object);
_mockStorageAccount.Setup(p => p.CreateBlobClient(null)).Returns(mockBlobClient.Object);
_mockSecondaryStorageAccount.Setup(p => p.CreateBlobClient(null)).Returns(mockSecondaryBlobClient.Object);
_mockAccountProvider.Setup(p => p.TryGetAccountAsync(ConnectionStringNames.Storage, It.IsAny <CancellationToken>()))
.ReturnsAsync(_mockStorageAccount.Object);
_mockAccountProvider.Setup(p => p.TryGetAccountAsync(Secondary, It.IsAny <CancellationToken>()))
.ReturnsAsync(_mockSecondaryStorageAccount.Object);
_mockExceptionDispatcher = new Mock <IWebJobsExceptionHandler>(MockBehavior.Strict);
_mockStorageBlob = new Mock <IStorageBlockBlob>(MockBehavior.Strict);
_mockBlobMetadata = new Dictionary <string, string>();
_mockBlobDirectory.Setup(p => p.GetBlockBlobReference(TestLockId)).Returns(_mockStorageBlob.Object);
_singletonConfig = new SingletonConfiguration();
// use reflection to bypass the normal validations (so tests can run fast)
TestHelpers.SetField(_singletonConfig, "_lockAcquisitionPollingInterval", TimeSpan.FromMilliseconds(25));
TestHelpers.SetField(_singletonConfig, "_lockPeriod", TimeSpan.FromMilliseconds(500));
_singletonConfig.LockAcquisitionTimeout = TimeSpan.FromMilliseconds(200);
_nameResolver = new TestNameResolver();
ILoggerFactory loggerFactory = new LoggerFactory();
// We want to see all logs, so set the default level to Trace.
LogCategoryFilter filter = new LogCategoryFilter {
DefaultLevel = Extensions.Logging.LogLevel.Trace
};
_loggerProvider = new TestLoggerProvider(filter.Filter);
loggerFactory.AddProvider(_loggerProvider);
var logger = loggerFactory?.CreateLogger(LogCategories.Singleton);
_core = new BlobLeaseDistributedLockManager.DedicatedStorage(_mockAccountProvider.Object, logger);
_singletonManager = new SingletonManager(_core, _singletonConfig, _mockExceptionDispatcher.Object, loggerFactory, new FixedHostIdProvider(TestHostId), _nameResolver);
_singletonManager.MinimumLeaseRenewalInterval = TimeSpan.FromMilliseconds(250);
}
public ScriptHostConfiguration()
{
HostConfig = new JobHostConfiguration();
FileWatchingEnabled = true;
FileLoggingMode = FileLoggingMode.Never;
RootScriptPath = Environment.CurrentDirectory;
RootLogPath = Path.Combine(Path.GetTempPath(), "Functions");
LogFilter = new LogCategoryFilter();
}
public EventHubConfigurationTests()
{
_loggerFactory = new LoggerFactory();
var filter = new LogCategoryFilter();
filter.DefaultLevel = LogLevel.Debug;
_loggerProvider = new TestLoggerProvider(filter.Filter);
_loggerFactory.AddProvider(_loggerProvider);
}
public ScriptHostConfiguration()
{
HostConfig = new JobHostConfiguration();
FileWatchingEnabled = true;
FileLoggingMode = FileLoggingMode.Never;
RootScriptPath = Environment.CurrentDirectory;
RootLogPath = Path.Combine(Path.GetTempPath(), "Functions");
LogFilter = new LogCategoryFilter();
RootExtensionsPath = ConfigurationManager.AppSettings[EnvironmentSettingNames.AzureWebJobsExtensionsPath];
}
public void Processor_No_ISupportProperties_DoesNotFilter()
{
var filter = new LogCategoryFilter();
var processor = new FilteringTelemetryProcessor(filter.Filter, _nextTelemetryProcessorMock.Object);
var telemetry = new Mock <ITelemetry>(MockBehavior.Strict);
processor.Process(telemetry.Object);
_nextTelemetryProcessorMock.Verify(m => m.Process(telemetry.Object), Times.Once);
}
private static void CheckAndEnableAppInsights(JobHostConfiguration config)
{
// If AppInsights is enabled, build up a LoggerFactory
string instrumentationKey = Environment.GetEnvironmentVariable("APPINSIGHTS_INSTRUMENTATIONKEY");
if (!string.IsNullOrEmpty(instrumentationKey))
{
var filter = new LogCategoryFilter();
filter.DefaultLevel = LogLevel.Debug;
filter.CategoryLevels[LogCategories.Function] = LogLevel.Debug;
filter.CategoryLevels[LogCategories.Results] = LogLevel.Debug;
filter.CategoryLevels[LogCategories.Aggregator] = LogLevel.Debug;
config.LoggerFactory = new LoggerFactory()
.AddApplicationInsights(instrumentationKey, filter.Filter)
.AddConsole(filter.Filter);
}
}
public void Processor_InvalidLogLevel_DoesNotFilter()
{
// If no valid loglevel, we're not sure what to do, so just let it through
var filter = new LogCategoryFilter
{
DefaultLevel = LogLevel.Information
};
var processor = new FilteringTelemetryProcessor(filter.Filter, _nextTelemetryProcessorMock.Object);
var telemetry = new TestTelemetry();
telemetry.Properties[LogConstants.CategoryNameKey] = LogCategories.Results;
telemetry.Properties[LogConstants.LogLevelKey] = "InvalidLevel";
processor.Process(telemetry);
_nextTelemetryProcessorMock.Verify(m => m.Process(telemetry), Times.Once);
}
public void Filter_MatchesLongestCategory()
{
var filter = new LogCategoryFilter();
filter.DefaultLevel = LogLevel.Error;
filter.CategoryLevels.Add("Microsoft", LogLevel.Critical);
filter.CategoryLevels.Add("Microsoft.Azure", LogLevel.Error);
filter.CategoryLevels.Add("Microsoft.Azure.WebJobs", LogLevel.Information);
filter.CategoryLevels.Add("Microsoft.Azure.WebJobs.Host", LogLevel.Trace);
Assert.False(filter.Filter("Microsoft", LogLevel.Information));
Assert.False(filter.Filter("Microsoft.Azure", LogLevel.Information));
Assert.False(filter.Filter("Microsoft.Azure.WebJob", LogLevel.Information));
Assert.False(filter.Filter("NoMatch", LogLevel.Information));
Assert.True(filter.Filter("Microsoft", LogLevel.Critical));
Assert.True(filter.Filter("Microsoft.Azure", LogLevel.Critical));
Assert.True(filter.Filter("Microsoft.Azure.WebJobs.Extensions", LogLevel.Information));
Assert.True(filter.Filter("Microsoft.Azure.WebJobs.Host", LogLevel.Debug));
Assert.True(filter.Filter("NoMatch", LogLevel.Error));
}
// Please set the following connection strings in app.config for this WebJob to run:
// AzureWebJobsDashboard and AzureWebJobsStorage
static void Main()
{
// Add telemetry initializers.
TelemetryConfiguration.Active.TelemetryInitializers
.Add(new CorrelationTelemetryInitializer());
TelemetryConfiguration.Active.TelemetryInitializers
.Add(new CloudRoleNameInitializer(ConfigurationManager.AppSettings["ComponentName"]));
// Set up logging.
using (var loggerFactory = new LoggerFactory())
{
var config = new JobHostConfiguration();
// If this variable exists, build up a LoggerFactory with requested loggers.
string instrumentationKey = ConfigurationManager.AppSettings["AppInsightsInstrumentationKey"];
if (!string.IsNullOrEmpty(instrumentationKey))
{
// Set default LogCategoryFilter.
var filter = new LogCategoryFilter
{
DefaultLevel = LogLevel.Trace
};
// Wire up LoggerFactory with default filter.
config.LoggerFactory = loggerFactory
//.AddApplicationInsights(instrumentationKey, filter.Filter)
.AddConsole(filter.Filter);
config.Tracing.ConsoleLevel = TraceLevel.Verbose;
// Add custom TraceLogger for Application Insights.
var traceLoggerProvider = new TraceLoggerProvider(instrumentationKey);
config.LoggerFactory.AddProvider(traceLoggerProvider);
}
// Add function filters.
var extensions = config.GetService <IExtensionRegistry>();
extensions.RegisterExtension <IFunctionInvocationFilter>(new OperationIdFilter());
// Add servicebus configuration.
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.Https;
var serviceBusConfiguration = new ServiceBusConfiguration
{
MessageOptions = new OnMessageOptions
{
MaxConcurrentCalls = 12,
AutoComplete = true
}
};
config.UseServiceBus(serviceBusConfiguration);
// Add function trigger services.
config.UseTimers();
config.UseHttp();
if (config.IsDevelopment)
{
config.UseDevelopmentSettings();
}
// Initialize WebJob host.
var host = new JobHost(config);
// Run WebJob.
host.RunAndBlock();
}
}
public async Task QuickPulse_Works_EvenIfFiltered(LogLevel defaultLevel, int expectedTelemetryItems)
{
LogCategoryFilter filter = new LogCategoryFilter();
filter.DefaultLevel = defaultLevel;
var loggerFactory = new LoggerFactory()
.AddApplicationInsights(
new TestTelemetryClientFactory(filter.Filter, _channel));
JobHostConfiguration config = new JobHostConfiguration
{
LoggerFactory = loggerFactory,
TypeLocator = new FakeTypeLocator(GetType()),
};
config.Aggregator.IsEnabled = false;
var listener = new ApplicationInsightsTestListener();
int requests = 5;
try
{
listener.StartListening();
using (JobHost host = new JobHost(config))
{
await host.StartAsync();
var methodInfo = GetType().GetMethod(nameof(TestApplicationInsightsWarning), BindingFlags.Public | BindingFlags.Static);
for (int i = 0; i < requests; i++)
{
await host.CallAsync(methodInfo);
}
await host.StopAsync();
}
}
finally
{
listener.StopListening();
}
// wait for everything to flush
await Task.Delay(2000);
// Sum up all req/sec calls that we've received.
var reqPerSec = listener
.QuickPulseItems.Select(p => p.Metrics.Where(q => q.Name == @"\ApplicationInsights\Requests/Sec").Single());
double sum = reqPerSec.Sum(p => p.Value);
// All requests will go to QuickPulse.
// The calculated RPS may off, so give some wiggle room. The important thing is that it's generating
// RequestTelemetry and not being filtered.
double max = requests + 3;
double min = requests - 2;
Assert.True(sum > min && sum < max, $"Expected sum to be greater than {min} and less than {max}. DefaultLevel: {defaultLevel}. Actual: {sum}");
// These will be filtered based on the default filter.
var infos = _channel.Telemetries.OfType <TraceTelemetry>().Where(t => t.SeverityLevel == SeverityLevel.Information);
var warns = _channel.Telemetries.OfType <TraceTelemetry>().Where(t => t.SeverityLevel == SeverityLevel.Warning);
var errs = _channel.Telemetries.OfType <TraceTelemetry>().Where(t => t.SeverityLevel == SeverityLevel.Error);
Assert.Equal(expectedTelemetryItems, _channel.Telemetries.Count());
}
public async Task ApplicationInsights_FailedFunction()
{
string testName = nameof(TestApplicationInsightsFailure);
LogCategoryFilter filter = new LogCategoryFilter();
filter.DefaultLevel = LogLevel.Information;
var loggerFactory = new LoggerFactory()
.AddApplicationInsights(
new TestTelemetryClientFactory(filter.Filter, _channel));
JobHostConfiguration config = new JobHostConfiguration
{
LoggerFactory = loggerFactory,
TypeLocator = new FakeTypeLocator(GetType()),
};
config.Aggregator.IsEnabled = false;
config.AddService <IWebJobsExceptionHandler>(new TestExceptionHandler());
using (JobHost host = new JobHost(config))
{
await host.StartAsync();
var methodInfo = GetType().GetMethod(testName, BindingFlags.Public | BindingFlags.Static);
await Assert.ThrowsAsync <FunctionInvocationException>(() => host.CallAsync(methodInfo, new { input = "function input" }));
await host.StopAsync();
}
Assert.Equal(12, _channel.Telemetries.Count);
// Validate the traces. Order by message string as the requests may come in
// slightly out-of-order or on different threads
TraceTelemetry[] telemetries = _channel.Telemetries
.OfType <TraceTelemetry>()
.OrderBy(t => t.Message)
.ToArray();
string expectedFunctionCategory = LogCategories.CreateFunctionCategory(testName);
string expectedFunctionUserCategory = LogCategories.CreateFunctionUserCategory(testName);
ValidateTrace(telemetries[0], "Error", expectedFunctionUserCategory, testName, expectedLogLevel: LogLevel.Error);
ValidateTrace(telemetries[1], "Executed", expectedFunctionCategory, testName, expectedLogLevel: LogLevel.Error);
ValidateTrace(telemetries[2], "Executing", expectedFunctionCategory, testName);
ValidateTrace(telemetries[3], "Found the following functions:\r\n", LogCategories.Startup);
ValidateTrace(telemetries[4], "Job host started", LogCategories.Startup);
ValidateTrace(telemetries[5], "Job host stopped", LogCategories.Startup);
ValidateTrace(telemetries[6], "Logger", expectedFunctionUserCategory, testName, hasCustomScope: true);
ValidateTrace(telemetries[7], "Trace", expectedFunctionUserCategory, testName);
// Validate the exception
ExceptionTelemetry[] exceptions = _channel.Telemetries
.OfType <ExceptionTelemetry>()
.OrderBy(t => t.Timestamp)
.ToArray();
Assert.Equal(3, exceptions.Length);
ValidateException(exceptions[0], expectedFunctionUserCategory, testName);
ValidateException(exceptions[1], LogCategories.Results, testName);
ValidateException(exceptions[2], expectedFunctionCategory, testName);
// Finally, validate the request
RequestTelemetry request = _channel.Telemetries
.OfType <RequestTelemetry>()
.Single();
ValidateRequest(request, testName, false);
}
