private void ServiceProviderNullRaisesArgumentNullException()
{
IServiceProvider nullProvider = null;
var options = new LogstashOptions();
var ex = Assert.Throws <ArgumentNullException>(() => new LogstashHttpLoggerProvider(nullProvider, options));
Assert.Equal("serviceProvider", ex.ParamName);
}
private void ServiceProviderIsSet()
{
var serviceProvider = Mock.Of <IServiceProvider>();
var options = new LogstashOptions();
var provider = new LogstashHttpLoggerProvider(serviceProvider, options);
Assert.Same(serviceProvider, provider.ServiceProvider);
}
private void LogLevelConverterNullRaisesArgumentNullException()
{
var serviceProvider = Mock.Of <IServiceProvider>();
var options = new LogstashOptions();
var ex = Assert.Throws <ArgumentNullException>(() => new LogMessageBuilder(serviceProvider, null, options));
Assert.Equal("logLevelConverter", ex.ParamName);
}
private void OptionsNullRaisesArgumentNullException()
{
var serviceProvider = Mock.Of <IServiceProvider>();
LogstashOptions nullOptions = null;
var ex = Assert.Throws <ArgumentNullException>(() => new LogstashHttpLoggerProvider(serviceProvider, nullOptions));
Assert.Equal("options", ex.ParamName);
}
private void StateAndExceptionNullReturnsNull()
{
var serviceProvider = Mock.Of <IServiceProvider>();
var converter = new LogLevelConverter();
var options = new LogstashOptions();
var builder = new LogMessageBuilder(serviceProvider, converter, options);
var message = builder.Build("myLogger", LogLevel.Information, null, null);
}
private void LogLevelConverterIsSet()
{
var serviceProvider = Mock.Of <IServiceProvider>();
var converter = new LogLevelConverter();
var options = new LogstashOptions();
var builder = new LogMessageBuilder(serviceProvider, converter, options);
Assert.Same(converter, builder.LogLevelConverter);
}
private void CurrentProcessIsSet()
{
var serviceProvider = Mock.Of <IServiceProvider>();
var converter = new LogLevelConverter();
var options = new LogstashOptions();
var builder = new LogMessageBuilder(serviceProvider, converter, options);
Assert.NotNull(builder.CurrentProcess);
}
private void FormatterIsCalled()
{
var serviceProvider = Mock.Of <IServiceProvider>();
var converter = new LogLevelConverter();
var options = new LogstashOptions();
var isCalled = false;
var builder = new LogMessageBuilder(serviceProvider, converter, options);
var message = builder.Build("myLogger", LogLevel.Information, "state", null, (state, ex) => { isCalled = true; return("called"); });
Assert.True(isCalled);
}
public static LogstashOptions Read(Action <LogstashOptions> setupAction)
{
if (setupAction == null)
{
throw new ArgumentNullException(nameof(setupAction), $"{nameof(setupAction)} cannot be null.");
}
var options = new LogstashOptions();
setupAction.Invoke(options);
Validate(options);
return(options);
}
private void IPAddressIsSet()
{
var serviceProvider = Mock.Of <IServiceProvider>();
var converter = new LogLevelConverter();
var options = new LogstashOptions()
{
AppId = "myApp", Index = "myIndex", Url = "http://localhost"
};
var builder = new LogMessageBuilder(serviceProvider, converter, options);
var message = builder.Build("myLogger", LogLevel.Information, "state", null);
Assert.Equal(builder.LocalIPAddress, message.Header.IPAddress);
}
private void MessageVersionIsSet()
{
var serviceProvider = Mock.Of <IServiceProvider>();
var converter = new LogLevelConverter();
var options = new LogstashOptions()
{
AppId = "myApp", Index = "myIndex", Url = "http://localhost"
};
var builder = new LogMessageBuilder(serviceProvider, converter, options);
var message = builder.Build("myLogger", LogLevel.Information, "state", null);
Assert.Equal(options.MessageVersion, message.Body.VersionNumber);
}
private void CorrelationIdIsSetWithoutRegisteredCorrelationContext()
{
var serviceProvider = Mock.Of <IServiceProvider>();
var converter = new LogLevelConverter();
var options = new LogstashOptions()
{
AppId = "myApp", Index = "myIndex", Url = "http://localhost"
};
var builder = new LogMessageBuilder(serviceProvider, converter, options);
var message = builder.Build("myLogger", LogLevel.Information, "state", null);
Assert.NotNull(message.Header.Correlation.CorrelationId);
}
private void LevelIsConverted()
{
var serviceProvider = Mock.Of <IServiceProvider>();
var converter = new Mock <ILogLevelConverter>();
var options = new LogstashOptions();
var level = LogLevel.Information;
converter.Setup((c) => c.ToLogStashLevel(level)).Returns(LogstashLevel.Information).Verifiable();
var builder = new LogMessageBuilder(serviceProvider, converter.Object, options);
var message = builder.Build("myLogger", LogLevel.Information, "state", null);
converter.Verify();
}
private void TimestampIsSet()
{
var serviceProvider = Mock.Of <IServiceProvider>();
var converter = new LogLevelConverter();
var options = new LogstashOptions()
{
AppId = "myApp", Index = "myIndex", Url = "http://localhost"
};
var builder = new LogMessageBuilder(serviceProvider, converter, options);
var message = builder.Build("myLogger", LogLevel.Information, "state", null);
var now = DateTime.Now;
Assert.InRange(message.Header.TimeStamp, now.AddMinutes(-1), now.AddMinutes(1));
}
public static LogstashOptions Read(IConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config), $"{nameof(config)} cannot be null.");
}
var options = new LogstashOptions()
{
AppId = config.Get <string>(Defaults.ConfigKeys.AppId),
Url = config.Get <string>(Defaults.ConfigKeys.Url),
Index = config.Get <string>(Defaults.ConfigKeys.Index),
MinimumLevel = config.Get <LogLevel>(Defaults.ConfigKeys.MinimumLevel)
};
Validate(options);
return(options);
}
private void CorrelationIdIsSetFromRegisteredCorrelationContext()
{
var correlationContext = new Mock <ICorrelationContext>();
var serviceProvider = new Mock <IServiceProvider>();
var converter = new LogLevelConverter();
var options = new LogstashOptions()
{
AppId = "myApp", Index = "myIndex", Url = "http://localhost"
};
correlationContext.SetupGet(p => p.CorrelationId).Returns("correlation-id");
serviceProvider.Setup(sp => sp.GetService(typeof(ICorrelationContext))).Returns(correlationContext.Object);
var builder = new LogMessageBuilder(serviceProvider.Object, converter, options);
var message = builder.Build("myLogger", LogLevel.Information, "state", null);
Assert.Equal("correlation-id", message.Header.Correlation.CorrelationId);
}
public LogMessageBuilder(IServiceProvider serviceProvider, ILogLevelConverter logLevelConverter, LogstashOptions options)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider), $"{nameof(serviceProvider)} cannot be null.");
}
if (logLevelConverter == null)
{
throw new ArgumentNullException(nameof(logLevelConverter), $"{nameof(logLevelConverter)} cannot be null.");
}
if (options == null)
{
throw new ArgumentNullException(nameof(options), $"{nameof(options)} cannot be null.");
}
ServiceProvider = serviceProvider;
LogLevelConverter = logLevelConverter;
Options = options;
LocalIPAddress = GetLocalIPAddress();
CurrentProcess = GetCurrentProcessId();
}
private static void Validate(LogstashOptions options)
{
if (String.IsNullOrWhiteSpace(options.AppId))
{
throw new InvalidOptionException(Defaults.ConfigKeys.AppId, options.AppId, "Logging AppId is mandatory.");
}
if (String.IsNullOrWhiteSpace(options.Url))
{
throw new InvalidOptionException(Defaults.ConfigKeys.Url, options.Url, "Logging Url is mandatory.");
}
if (String.IsNullOrWhiteSpace(options.Index))
{
throw new InvalidOptionException(Defaults.ConfigKeys.Index, options.Index, "Logging Index is mandatory.");
}
try
{
var uri = new Uri(options.Url);
}
catch (UriFormatException)
{
throw new InvalidOptionException(Defaults.ConfigKeys.Url, options.Url, "Logging Url is not a valid uri.");
}
}
