public void Fatal_MessageWithException()
{
// Prepare
const string message = "Exception occurred";
var ex = new Exception(message);
logger.Setup(l => l.Write(
LogEventLevel.Fatal, ex, message, null))
.Verifiable();
log = new SerilogLogger(logger.Object);
// Act
log.Fatal(message, ex);
// Assert
logger.VerifyAll();
}
public async Task <PackageOperationResult> UpdatePackage(string id, Uri source = null)
{
using (await Lock.WriteLockAsync())
{
var logger = new SerilogLogger(Logger, _progressService);
var choco = Lets.GetChocolatey().SetCustomLogging(logger);
choco.Set(
config =>
{
config.CommandName = CommandNameType.upgrade.ToString();
config.PackageNames = id;
config.Features.UsePackageExitCodes = false;
});
return(await RunCommand(choco, logger));
}
}
static void Main(string[] args)
{
// Log configuration should be setup on client app side, so I left this here.
// I don't like an idea to add Serilog packages to this project, but I see no other way at the moment.
// Every so called sink (ColoredConsole, File, etc) is a standalone package, so configuration must be done here.
// There is another aproach - a congig file. If we go with config file, then probably we can avoid issue above.
/* we cannot configure Serilog inside client app cuz we are going to hide log provider from end users behind our wrapper
* var cfg = new LoggerConfiguration()
* .Enrich.FromLogContext()
* .MinimumLevel.Debug()
* .WriteTo.ColoredConsole(
* LogEventLevel.Verbose,
* "{NewLine}{Timestamp:HH:mm:ss} [{Level}] ({CorrelationToken}) {Message}{NewLine}{Exception}");
*/
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
using (ILogger logger = new SerilogLogger(configuration))
{
//Simple log entry
logger.Debug("Hello World!");
//Parameterized log entry
var quota = 100;
var user = new { FirstName = "John", LastName = "Walter" };
logger.Write(LogLevel.Warning, "Disk quota {Quota} MB exceeded by {User}", quota, user);
//Exception handling
var myDataObject = new { Property1 = "Value1", Property2 = "Value2", Property3 = "Value3" };
try
{
int x = 0;
int y = 10 / x;
}
catch (Exception ex)
{
logger.Fatal("Got an exception for {MyDataObject}", ex, myDataObject);
}
}
Console.ReadKey();
}
public static void Main(string[] args)
{
Log.Logger = SerilogLogger.Initialize();
try
{
Log.Information("Starting up");
CreateHostBuilder(args).Build().Run();
}
catch (Exception ex)
{
Log.Fatal(ex, "Application start-up failed");
}
finally
{
Log.CloseAndFlush();
}
}
public override void OnFrameworkInitializationCompleted()
{
#if DEBUG
SerilogLogger.Initialize(new LoggerConfiguration()
.MinimumLevel.Warning()
.WriteTo.Trace(outputTemplate: "{Area}: {Message}")
.CreateLogger());
#endif
var view = new FeedbackView();
var context = new FeedbackViewModel(
new AvaloniaSender(view),
new Clock());
view.DataContext = context;
view.Show();
base.OnFrameworkInitializationCompleted();
}
public void SingleThread_RollingSizeLogFile_Test()
{
SingleThreadTestsCaseRunner.ReportStartedTest(ThreadingType.SingleThreaded, LogFileType.RollingSizeFile);
#region Log4net
Log4NetLogger.ConfigureRollingSizeFileLogger(ThreadingType.SingleThreaded);
SingleThreadTestsCaseRunner.Run(
LoggingLib.Log4Net,
LogFileType.RollingSizeFile,
(runNr, logNr) => Log4NetLog.Info($"Run #{runNr} - Log #{logNr}"));
Log4NetLogger.DisableLogger();
#endregion
SleepBeforeNextTestCaseRun();
#region NLog
NLogLogger.ConfigureRollingSizeFileLogger(ThreadingType.SingleThreaded);
SingleThreadTestsCaseRunner.Run(
LoggingLib.NLog,
LogFileType.RollingSizeFile,
(runNr, logNr) => NLogLog.Info($"Run #{runNr} - Log #{logNr}"));
#endregion
SleepBeforeNextTestCaseRun();
#region Serilog
Serilog.Core.Logger serilogLog = SerilogLogger.ConfigureRollingSizeFileLogger(ThreadingType.SingleThreaded);
SingleThreadTestsCaseRunner.Run(
LoggingLib.Serilog,
LogFileType.RollingSizeFile,
(runNr, logNr) => serilogLog.Information($"Run #{runNr} - Log #{logNr}"));
#endregion
SingleThreadTestsCaseRunner.ReportTestResults(ThreadingType.SingleThreaded, LogFileType.RollingSizeFile);
}
public void ForContextAddingPropertiesTests()
{
var dummySink = new DummySink();
var log = new SerilogLogger(new LoggerConfiguration().WriteTo.Sink(dummySink).CreateLogger());
var messageTemplate = "Testing adding {prop2} props";
log.ForContext("prop", "value").InfoFormat(messageTemplate, "awesome");
Log.CloseAndFlush();
var result = dummySink.Events.SingleOrDefault();
Assert.NotNull(result);
Assert.AreEqual(LogEventLevel.Information, result.Level);
Assert.AreEqual(messageTemplate, result.MessageTemplate.Text);
Assert.True(result.Properties.ContainsKey("prop"));
Assert.AreEqual("\"value\"", result.Properties["prop"].ToString());
Assert.True(result.Properties.ContainsKey("prop2"));
Assert.AreEqual("\"awesome\"", result.Properties["prop2"].ToString());
}
/// <summary>
/// Create and configure the logger
/// </summary>
public static IServiceCollection AddLogger(
this IServiceCollection services,
IHostingEnvironment hostingEnvironment,
ILoggingConfiguration loggingConfiguration,
IConfiguration configuration)
{
// Create a serilog logger
var logger = SerilogLogger.CreateWithDefaultConfiguration(hostingEnvironment, loggingConfiguration, configuration, out var umbracoFileConfig);
services.AddSingleton(umbracoFileConfig);
// This is nessasary to pick up all the loggins to MS ILogger.
Log.Logger = logger.SerilogLog;
// Wire up all the bits that serilog needs. We need to use our own code since the Serilog ext methods don't cater to our needs since
// we don't want to use the global serilog `Log` object and we don't have our own ILogger implementation before the HostBuilder runs which
// is the only other option that these ext methods allow.
// I have created a PR to make this nicer https://github.com/serilog/serilog-extensions-hosting/pull/19 but we'll need to wait for that.
// Also see : https://github.com/serilog/serilog-extensions-hosting/blob/dev/src/Serilog.Extensions.Hosting/SerilogHostBuilderExtensions.cs
services.AddLogging(configure =>
{
configure.AddSerilog(logger.SerilogLog, false);
});
// This won't (and shouldn't) take ownership of the logger.
services.AddSingleton(logger.SerilogLog);
// Registered to provide two services...
var diagnosticContext = new DiagnosticContext(logger.SerilogLog);
// Consumed by e.g. middleware
services.AddSingleton(diagnosticContext);
// Consumed by user code
services.AddSingleton <IDiagnosticContext>(diagnosticContext);
services.AddSingleton(loggingConfiguration);
return(services);
}
public async Task <PackageOperationResult> UninstallPackage(string id, string version, bool force = false)
{
using (await Lock.WriteLockAsync())
{
var logger = new SerilogLogger(Logger, _progressService);
var choco = Lets.GetChocolatey().SetCustomLogging(logger);
choco.Set(
config =>
{
config.CommandName = CommandNameType.uninstall.ToString();
config.PackageNames = id;
config.Features.UsePackageExitCodes = false;
if (version != null)
{
config.Version = version.ToString();
}
});
return(await RunCommand(choco, logger));
}
}
private static ILogger CreateLogger()
{
var log = new LoggerConfiguration()
.Enrich.WithProcessId()
.Enrich.WithThreadId()
.Enrich.With <TestIdEnricher>()
.Enrich.With <TestNameEnricher>()
.Enrich.With <NimbusMessageEnricher>()
.Enrich.WithExceptionDetails()
.WriteTo.Seq("http://localhost:5341")
.Chain(l => { if (Debugger.IsAttached)
{
l.WriteTo.Trace();
}
})
.MinimumLevel.Verbose()
.CreateLogger();
Log.Logger = log;
var logger = new SerilogLogger(log);
return(logger);
}
public void Instantiation()
{
var log = new SerilogLogger(GetType());
Assert.IsNotNull(log);
}
public static void LogInfo(string ex)
{
SerilogLogger.LogInfoAsync(ex);
}
public TileCompilerTests()
{
CompilerDriver.SetLogger(() => SerilogLogger.CreateDefaultLogger("Adrien.Tests.log"));
}
static void Main()
{
var settings = new Settings();
ILifetimeScope container = null;
Log.Logger = new LoggerConfiguration()
.ReadFrom.AppSettings()
.Enrich.WithExceptionDetails()
.WriteTo.Console()
.CreateLogger();
var builder = new ContainerBuilder();
var easyNetQLogger = new SerilogLogger(Log.Logger);
builder.Register(t => settings).AsSelf();
builder.Register(c => RabbitHutch.CreateBus(register => register.Register <IEasyNetQLogger>(l => easyNetQLogger)).Advanced).As <IAdvancedBus>();
builder.Register(c =>
new HttpMessageHandlerClient(
() => new HttpClientHandler(),
settings.SubscriptionServiceEndpoint,
null,
new DelegatedDeserializer(JsonConvert.DeserializeObject),
new DelegatedSerializer(JsonConvert.SerializeObject),
string.Empty)
).As <IRestClient>();
builder.Register(c =>
{
var client = new HttpClient
{
BaseAddress = new Uri(settings.MetainfoServiceEndpoint)
};
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
return(client);
})
.As <HttpClient>();
builder.RegisterType <CheckSubscriptionService>().AsImplementedInterfaces();
builder.RegisterType <SubscriptionService>().AsImplementedInterfaces();
builder.RegisterType <ImportService>().AsImplementedInterfaces();
builder.RegisterType <Service>().AsSelf();
container = builder.Build();
HostFactory.Run(c =>
{
c.Service <Service>((s) =>
{
s.ConstructUsing(name => container.Resolve <Service>());
s.WhenStarted(service => service.Start());
s.WhenStopped(service => service.Stop());
});
c.RunAsLocalSystem();
c.SetServiceName(settings.ServiceName);
c.SetDisplayName(settings.ServiceName);
c.SetDescription("Сервис отправки готовой продукции");
c.DependsOnEventLog();
c.StartAutomatically();
c.UseSerilog();
c.EnableServiceRecovery(configurator =>
{
configurator.RestartService(1);
});
});
}
protected virtual ILogger GetLogger() => Logger ?? SerilogLogger.CreateWithDefaultConfiguration(); // TODO: Remove this in netcore, this purely just backwards compat ugliness
public PlaidMLCompilerApiTests()
{
CompilerDriver.SetLogger(() => SerilogLogger.CreateDefaultLogger("Adrien.Tests.log"));
testContext = new Context();
}
/// <summary> /// Gets a logger. /// </summary> protected virtual ILogger GetLogger() => SerilogLogger.CreateWithDefaultConfiguration();
static void Main(string[] args)
{
if (args.Contains("--wait-for-attach"))
{
Console.WriteLine("Attach debugger and press any key to continue execution...");
Console.ReadKey(true);
if (!Debugger.IsAttached)
{
Console.WriteLine("No debugger detected! Exiting.");
return;
}
else
{
Debugger.Break();
}
}
List <string> enabledLogOptions = new List <string>();
if (args.Contains("--with-log-file"))
{
WithLogFile = true;
enabledLogOptions.Add("WithLogFile");
}
if (args.Contains("--debug"))
{
WithDebugOutput = true;
enabledLogOptions.Add("WithDebugOutput");
}
if (args.Contains("--without-console"))
{
WithoutConsole = true;
enabledLogOptions.Add("WithoutConsole");
}
CO.Write(FiggleFonts.Rectangles.Render("O.L.A.F"));
CO.WriteLine("v{0}", AssemblyVersion.ToString(3));
Global.SetupLogger(() => SerilogLogger.CreateLogger(enabledLogOptions));
Global.SetupMessageQueue();
Profile = new UserBrowserActivity();
//Profile = new UserDownloads();
if (Profile.Init() != ApiResult.Success)
{
Error("Could not initialize profile {0}.", Profile.Name);
Exit(ExitCode.InitError);
}
if (Profile.Start() != ApiResult.Success)
{
Error("Could not start profile {0}.", Profile.Name);
Exit(ExitCode.StartError);
}
Info("Profile {0} started. Press any key to exit.", Profile.Name);
ConsoleKeyInfo key = Console.ReadKey();
var s = Profile.Shutdown();
Exit(s == ApiResult.Success ? ExitCode.Success : ExitCode.ShutdownError);
}
public TensorExpressionTests()
{
CompilerDriver.SetLogger(() => SerilogLogger.CreateDefaultLogger("Adrien.Tests.log"));
}
/// <summary>
/// Simple helper to initialize Serilog within Splat with the Wrapping Full Logger.
/// </summary>
/// <remarks>
/// You should configure Serilog prior to calling this method.
/// </remarks>
/// <param name="instance">An instance of Mutable Dependency Resolver.</param>
/// <param name="actualLogger">The serilog logger to register.</param>
/// <example>
/// <code>
/// Locator.CurrentMutable.UseSerilogWithWrappingFullLogger();
/// </code>
/// </example>
public static void UseSerilogWithWrappingFullLogger(this IMutableDependencyResolver instance, global::Serilog.ILogger actualLogger)
{
var miniLoggingWrapper = new SerilogLogger(actualLogger);
instance.RegisterConstant(new WrappingFullLogger(miniLoggingWrapper), typeof(ILogManager));
}
public TensorOperatorsTests()
{
CompilerDriver.SetLogger(() => SerilogLogger.CreateDefaultLogger("Adrien.Tests.log"));
}
protected override IRuntime GetRuntime()
{
var logger = SerilogLogger.CreateWithDefaultConfiguration();
return(new WebRuntime(this, logger, new MainDom(logger)));
}
static void Main()
{
var settings = new Settings();
ILifetimeScope container = null;
Log.Logger = new LoggerConfiguration()
.ReadFrom.AppSettings()
.Enrich.WithExceptionDetails()
.WriteTo.Console()
.CreateLogger();
var builder = new ContainerBuilder();
var easyNetQLogger = new SerilogLogger(Log.Logger);
builder.Register(t => settings).AsSelf();
builder.Register(c => RabbitHutch.CreateBus(register => register.Register <IEasyNetQLogger>(l => easyNetQLogger)).Advanced).As <IAdvancedBus>();
builder.Register(t =>
{
var client = new OAuth2Client(
new Uri(settings.TokenEndpoint),
settings.Client,
settings.Clientsecret);
var tokenResult = client.RequestClientCredentialsAsync(settings.RequestedScopes).Result;
return(tokenResult);
});
builder.RegisterType <Authenticator>().AsImplementedInterfaces();
builder.Register(c =>
new HttpMessageHandlerClient(
() => new HttpClientHandler(),
settings.MetainfoServiceEndpoint,
container.Resolve <IAuthenticator>(),
new DelegatedDeserializer(JsonConvert.DeserializeObject),
new DelegatedSerializer(JsonConvert.SerializeObject),
string.Empty)
).As <IRestClient>();
builder.RegisterType <StubFinishedProductService>().AsImplementedInterfaces();
builder.RegisterType <CheckProductReadyService>().AsSelf();
container = builder.Build();
HostFactory.Run(c =>
{
c.Service <CheckProductReadyService>((s) =>
{
s.ConstructUsing(name => container.Resolve <CheckProductReadyService>());
s.WhenStarted(service => service.Start());
s.WhenStopped(service => service.Stop());
});
c.RunAsLocalSystem();
c.SetServiceName(settings.ServiceName);
c.SetDisplayName(settings.ServiceName);
c.SetDescription("Сервис проверки готовности продукта");
c.DependsOnEventLog();
c.StartAutomatically();
c.UseSerilog();
c.EnableServiceRecovery(configurator =>
{
configurator.RestartService(1);
});
});
}
public async Task <PackageOperationResult> InstallPackage(
string id,
string version = null,
Uri source = null,
bool force = false,
AdvancedInstall advancedInstallOptions = null)
{
using (await Lock.WriteLockAsync())
{
var logger = new SerilogLogger(Logger, _progressService);
var choco = Lets.GetChocolatey(initializeLogging: false).SetCustomLogging(logger, logExistingMessages: false, addToExistingLoggers: true);
choco.Set(
config =>
{
config.CommandName = CommandNameType.install.ToString();
config.PackageNames = id;
config.Features.UsePackageExitCodes = false;
if (version != null)
{
config.Version = version.ToString();
}
if (source != null)
{
config.Sources = source.ToString();
}
if (force)
{
config.Force = true;
}
if (advancedInstallOptions != null)
{
config.InstallArguments = advancedInstallOptions.InstallArguments;
config.PackageParameters = advancedInstallOptions.PackageParameters;
config.CommandExecutionTimeoutSeconds = advancedInstallOptions.ExecutionTimeoutInSeconds;
if (!string.IsNullOrEmpty(advancedInstallOptions.LogFile))
{
config.AdditionalLogFileLocation = advancedInstallOptions.LogFile;
}
config.Prerelease = advancedInstallOptions.PreRelease;
config.ForceX86 = advancedInstallOptions.Forcex86;
config.OverrideArguments = advancedInstallOptions.OverrideArguments;
config.NotSilent = advancedInstallOptions.NotSilent;
config.ApplyInstallArgumentsToDependencies = advancedInstallOptions.ApplyInstallArgumentsToDependencies;
config.ApplyPackageParametersToDependencies = advancedInstallOptions.ApplyPackageParametersToDependencies;
config.AllowDowngrade = advancedInstallOptions.AllowDowngrade;
config.AllowMultipleVersions = advancedInstallOptions.AllowMultipleVersions;
config.IgnoreDependencies = advancedInstallOptions.IgnoreDependencies;
config.ForceDependencies = advancedInstallOptions.ForceDependencies;
config.SkipPackageInstallProvider = advancedInstallOptions.SkipPowerShell;
config.Features.ChecksumFiles = !advancedInstallOptions.IgnoreChecksums;
config.Features.AllowEmptyChecksums = advancedInstallOptions.AllowEmptyChecksums;
config.Features.AllowEmptyChecksumsSecure = advancedInstallOptions.AllowEmptyChecksumsSecure;
if (advancedInstallOptions.RequireChecksums)
{
config.Features.AllowEmptyChecksums = false;
config.Features.AllowEmptyChecksumsSecure = false;
}
if (!string.IsNullOrEmpty(advancedInstallOptions.CacheLocation))
{
config.CacheLocation = advancedInstallOptions.CacheLocation;
}
config.DownloadChecksum = advancedInstallOptions.DownloadChecksum;
config.DownloadChecksum64 = advancedInstallOptions.DownloadChecksum64bit;
config.DownloadChecksumType = advancedInstallOptions.DownloadChecksumType;
config.DownloadChecksumType64 = advancedInstallOptions.DownloadChecksumType64bit;
}
});
Action <LogMessage> grabErrors;
var errors = GetErrors(out grabErrors);
using (logger.Intercept(grabErrors))
{
await choco.RunAsync();
if (Environment.ExitCode != 0)
{
Environment.ExitCode = 0;
return(new PackageOperationResult {
Successful = false, Messages = errors.ToArray()
});
}
return(PackageOperationResult.SuccessfulCached);
}
}
}
private void PerformLog(LogEntry logEntry)
{
if (DiagnosticContext == null || SerilogLogger == null)
{
throw new InvalidOperationException($"Configure asp.net core & serilog using https://github.com/serilog/serilog-aspnetcore");
}
bool isRequestLogEntry = false;
if (logEntry.LogData.Any(ld => ld.Key == nameof(IRequestInformationProvider.DisplayUrl)) && HttpContextAccessor.HttpContext != null)
{
isRequestLogEntry = true;
HttpContext httpContext = HttpContextAccessor.HttpContext;
IUserInformationProvider userInformationProvider = httpContext.RequestServices.GetRequiredService <IUserInformationProvider>();
}
var keyValues = logEntry.LogData.Select(ld =>
{
string k = ld.Key;
if (k == nameof(IRequestInformationProvider.HttpMethod) ||
k == nameof(IRequestInformationProvider.DisplayUrl) ||
k == "ResponseStatusCode" ||
ld.Value == null)
{
return(Key: null, Value: null); // Already being logged by serilog!
}
string v = null;
if (ld.Value is string valueAsStr)
{
v = valueAsStr;
}
if (k == "ClientLogs" || k == "OperationArgs")
{
v = Formatter.Serialize(ld.Value);
}
else
{
v = ld.Value.ToString();
}
return(Key: k, Value: v);
})
.Where(d => d.Key != null)
.ToList();
keyValues.Add((Key: nameof(LogEntry.MemoryUsage), Value: logEntry.MemoryUsage.ToString()));
if (logEntry.AppServerDateTime.HasValue)
{
keyValues.Add((Key: nameof(LogEntry.AppServerDateTime), Value: logEntry.AppServerDateTime.ToString()));
}
keyValues.Add((Key: nameof(LogEntry.Severity), Value: logEntry.Severity));
keyValues.Add((Key: nameof(LogEntry.Message), Value: logEntry.Message));
if (logEntry.Id.HasValue)
{
keyValues.Add((Key: nameof(LogEntry.Id), Value: logEntry.Id.ToString()));
}
if (logEntry.AppServerThreadId.HasValue)
{
keyValues.Add((Key: nameof(LogEntry.AppServerThreadId), Value: logEntry.AppServerThreadId.ToString()));
}
foreach (var(Key, Value) in keyValues.OrderBy(kv => kv.Key))
{
DiagnosticContext.Set(Key, Value);
}
if (isRequestLogEntry == true)
{
LogData userAgent = logEntry.LogData.FirstOrDefault(ld => ld.Key == nameof(IRequestInformationProvider.UserAgent));
if (userAgent != null)
{
DiagnosticContext.Set("UserAgent", userAgent.Value);
}
}
else
{
Exception ex = null;
try
{
var(Key, Value) = keyValues.ExtendedSingleOrDefault("Finding ExceptionTypeAssemblyQualifiedName...", kv => kv.Key == "ExceptionTypeAssemblyQualifiedName");
if (!string.IsNullOrEmpty(Value))
{
ex = (Exception)Activator.CreateInstance(Type.GetType(Value) ?? throw new InvalidOperationException($"{Value} could not be found"), args: new object[] { logEntry.Message });
}
}
catch { }
LogEventLevel level = logEntry.Severity switch
{
"Information" => LogEventLevel.Information,
"Warning" => LogEventLevel.Warning,
"Error" => LogEventLevel.Error,
"Fatal" => LogEventLevel.Fatal,
_ => LogEventLevel.Debug,
};
SerilogLogger.Write(level, ex?.Message ?? logEntry.Message);
}
}
public void TearDown()
{
logger = null;
log = null;
}
private static ILog CreateLogWithSlack(IConfiguration configuration, IServiceCollection services,
IReloadingManager <AppSettings> settings)
{
const string requestsLogName = "SettingsServiceRequestsLog";
const string logName = "SettingsServiceLog";
var consoleLogger = new LogToConsole();
#region Logs settings validation
if (!settings.CurrentValue.MarginTradingSettingsService.UseSerilog &&
string.IsNullOrWhiteSpace(settings.CurrentValue.MarginTradingSettingsService.Db.LogsConnString))
{
throw new Exception("Either UseSerilog must be true or LogsConnString must be set");
}
#endregion Logs settings validation
#region Slack registration
ISlackNotificationsSender slackService = null;
if (settings.CurrentValue.SlackNotifications != null)
{
var azureQueue = new AzureQueueSettings
{
ConnectionString = settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.CurrentValue.SlackNotifications.AzureQueue.QueueName
};
slackService =
services.UseSlackNotificationsSenderViaAzureQueue(azureQueue, consoleLogger);
}
#endregion Slack registration
if (settings.CurrentValue.MarginTradingSettingsService.UseSerilog)
{
var serilogLogger = new SerilogLogger(typeof(Startup).Assembly, configuration);
LogLocator.RequestsLog = LogLocator.CommonLog = serilogLogger;
return(serilogLogger);
}
if (settings.CurrentValue.MarginTradingSettingsService.Db.StorageMode == StorageMode.SqlServer)
{
LogLocator.CommonLog = new AggregateLogger(
new LogToSql(new SqlLogRepository(logName,
settings.CurrentValue.MarginTradingSettingsService.Db.LogsConnString)),
new LogToConsole());
LogLocator.RequestsLog = new AggregateLogger(
new LogToSql(new SqlLogRepository(requestsLogName,
settings.CurrentValue.MarginTradingSettingsService.Db.LogsConnString)),
new LogToConsole());
return(LogLocator.CommonLog);
}
if (settings.CurrentValue.MarginTradingSettingsService.Db.StorageMode != StorageMode.Azure)
{
throw new Exception("Wrong config! Logging must be set either to Serilog, SqlServer or Azure.");
}
#region Azure logging
LogLocator.RequestsLog = services.UseLogToAzureStorage(settings.Nested(s =>
s.MarginTradingSettingsService.Db.LogsConnString),
slackService, requestsLogName, consoleLogger);
LogLocator.CommonLog = services.UseLogToAzureStorage(settings.Nested(s =>
s.MarginTradingSettingsService.Db.LogsConnString),
slackService, logName, consoleLogger);
return(LogLocator.CommonLog);
#endregion Azure logging
}
public void InitializeFixture()
{
var logger = new SerilogLogger(new FileInfo(TestHelper.MapPathForTest("~/unit-test.config")));
_profilingLogger = new ProfilingLogger(logger, new LogProfiler(logger));
}
