protected virtual ILog CreateLogWithSlack(IServiceCollection services, IReloadingManager <TApplicationSettings> settings, bool isLive)
{
var logToConsole = new LogToConsole();
var aggregateLogger = new AggregateLogger();
aggregateLogger.AddLog(logToConsole);
var commonSlackService =
services.UseSlackNotificationsSenderViaAzureQueue(settings.CurrentValue.SlackNotifications.AzureQueue,
aggregateLogger);
var slackService =
new MtSlackNotificationsSender(commonSlackService, ApplicationName, Configuration.ServerType());
services.AddSingleton <ISlackNotificationsSender>(slackService);
// Creating azure storage logger, which logs own messages to concole log
var dbLogConnectionString = settings.CurrentValue.MtBrokersLogs?.DbConnString;
if (!string.IsNullOrEmpty(dbLogConnectionString) &&
!(dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}")))
{
var logToAzureStorage = services.UseLogToAzureStorage(
settings.Nested(s => s.MtBrokersLogs.DbConnString), slackService,
ApplicationName + Configuration.ServerType() + "Log",
aggregateLogger);
aggregateLogger.AddLog(logToAzureStorage);
}
return(aggregateLogger);
}
private static ILog CreateLogWithSlack(IServiceCollection services, IReloadingManager <AppSettings> settings)
{
var consoleLogger = new LogToConsole();
var aggregateLogger = new AggregateLogger();
aggregateLogger.AddLog(consoleLogger);
// Creating slack notification service, which logs own azure queue processing messages to aggregate log
var slackService = services.UseSlackNotificationsSenderViaAzureQueue(new AzureQueueIntegration.AzureQueueSettings
{
ConnectionString = settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.CurrentValue.SlackNotifications.AzureQueue.QueueName
}, aggregateLogger);
var dbLogConnectionStringManager = settings.Nested(x => x.SlackNotificationsJobSettings.LogsConnectionString);
var dbLogConnectionString = dbLogConnectionStringManager.CurrentValue;
// Creating azure storage logger, which logs own messages to concole log
if (!string.IsNullOrEmpty(dbLogConnectionString) && !(dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}")))
{
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <LogEntity> .Create(dbLogConnectionStringManager, "SlackNotificationsJobLogs", consoleLogger),
consoleLogger);
var slackNotificationsManager = new LykkeLogToAzureSlackNotificationsManager(slackService, consoleLogger);
var azureStorageLogger = new LykkeLogToAzureStorage(persistenceManager, slackNotificationsManager, consoleLogger);
azureStorageLogger.Start();
aggregateLogger.AddLog(azureStorageLogger);
}
return(aggregateLogger);
}
private static ILog CreateLog(IConfiguration configuration, IServiceCollection services,
IReloadingManager <AppSettings> settings)
{
var logName = $"{nameof(OrderBookService)}Log";
var consoleLogger = new LogToConsole();
var aggregateLogger = new AggregateLogger();
aggregateLogger.AddLog(consoleLogger);
if (settings.CurrentValue.OrderBookService.UseSerilog)
{
aggregateLogger.AddLog(new SerilogLogger(typeof(Startup).Assembly, configuration));
}
else if (settings.CurrentValue.OrderBookService.Db.StorageMode == StorageMode.SqlServer)
{
aggregateLogger.AddLog(new LogToSql(new SqlLogRepository(logName,
settings.CurrentValue.OrderBookService.Db.LogsConnString)));
}
else if (settings.CurrentValue.OrderBookService.Db.StorageMode == StorageMode.Azure)
{
aggregateLogger.AddLog(services.UseLogToAzureStorage(settings.Nested(s => s.OrderBookService.Db.LogsConnString),
null, logName, consoleLogger));
}
LogLocator.Log = aggregateLogger;
return(aggregateLogger);
}
private static ILog CreateLogWithSlack(IServiceCollection services, IReloadingManager <AppSettings> settings)
{
var consoleLogger = new LogToConsole();
var aggregateLogger = new AggregateLogger();
aggregateLogger.AddLog(consoleLogger);
var dbLogConnectionStringManager = settings.Nested(x => x.DynamicJob.Db.LogsConnString);
var dbLogConnectionString = dbLogConnectionStringManager.CurrentValue;
if (string.IsNullOrEmpty(dbLogConnectionString))
{
consoleLogger.WriteWarningAsync(nameof(Startup), nameof(CreateLogWithSlack), "Table loggger is not inited").Wait();
return(aggregateLogger);
}
if (dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}"))
{
throw new InvalidOperationException($"LogsConnString {dbLogConnectionString} is not filled in settings");
}
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <LogEntity> .Create(dbLogConnectionStringManager, "DynamicJobLog", consoleLogger),
consoleLogger);
// Creating slack notification service, which logs own azure queue processing messages to aggregate log
var slackService = services.UseSlackNotificationsSenderViaAzureQueue(new AzureQueueIntegration.AzureQueueSettings
{
ConnectionString = settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.CurrentValue.SlackNotifications.AzureQueue.QueueName
}, aggregateLogger);
var slackNotificationsManager = new LykkeLogToAzureSlackNotificationsManager(slackService, consoleLogger);
// Creating azure storage logger, which logs own messages to concole log
var azureStorageLogger = new LykkeLogToAzureStorage(
persistenceManager,
slackNotificationsManager,
consoleLogger);
azureStorageLogger.Start();
aggregateLogger.AddLog(azureStorageLogger);
aggregateLogger.AddLog(LykkeLogToSlack.Create
(
slackService,
"BlockChainIntegration",
LogLevel.All
));
aggregateLogger.AddLog(LykkeLogToSlack.Create
(
slackService,
"BlockChainIntegrationImportantMessages",
LogLevel.All ^ LogLevel.Info
));
return(aggregateLogger);
}
private static ILog CreateLog(
IConfiguration configuration,
IReloadingManager <AppSettings> settings,
IServiceCollection services,
CorrelationContextAccessor correlationContextAccessor)
{
var aggregateLogger = new AggregateLogger();
var consoleLogger = new LogToConsole();
aggregateLogger.AddLog(consoleLogger);
if (settings.CurrentValue.MarginTradingAccountManagement.UseSerilog)
{
aggregateLogger.AddLog(new SerilogLogger(typeof(Startup).Assembly, configuration, new List <ILogEventEnricher>
{
new CorrelationLogEventEnricher("CorrelationId", correlationContextAccessor)
}));
}
else if (settings.CurrentValue.MarginTradingAccountManagement.Db.StorageMode == StorageMode.SqlServer.ToString())
{
var sqlLogger = new LogToSql(new SqlLogRepository("AccountManagementLog",
settings.CurrentValue.MarginTradingAccountManagement.Db.LogsConnString));
aggregateLogger.AddLog(sqlLogger);
}
else if (settings.CurrentValue.MarginTradingAccountManagement.Db.StorageMode == StorageMode.Azure.ToString())
{
var dbLogConnectionStringManager = settings.Nested(x => x.MarginTradingAccountManagement.Db.LogsConnString);
var dbLogConnectionString = dbLogConnectionStringManager.CurrentValue;
if (string.IsNullOrEmpty(dbLogConnectionString))
{
consoleLogger.WriteWarningAsync(nameof(Startup), nameof(CreateLog), "Table logger is not initialized").Wait();
return(aggregateLogger);
}
if (dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}"))
{
throw new InvalidOperationException($"LogsConnString {dbLogConnectionString} is not filled in settings");
}
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <Lykke.Logs.LogEntity> .Create(dbLogConnectionStringManager, "AccountManagementLog", consoleLogger),
consoleLogger);
// Creating azure storage logger, which logs own messages to console log
var azureStorageLogger = new LykkeLogToAzureStorage(persistenceManager, null, consoleLogger);
azureStorageLogger.Start();
aggregateLogger.AddLog(azureStorageLogger);
}
LogLocator.Log = aggregateLogger;
return(aggregateLogger);
}
private static ILog CreateLogWithSlack(IServiceCollection services, IReloadingManager <AppSettings> settings)
{
var consoleLogger = new LogToConsole();
var aggregateLogger = new AggregateLogger();
aggregateLogger.AddLog(consoleLogger);
//It is possible to run only with console logger
if (!string.IsNullOrEmpty(settings.CurrentValue.EthereumIndexer.DB.LogsConnectionString) &&
!string.IsNullOrEmpty(settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString))
{
var dbLogConnectionStringManager = settings.Nested(x => x.EthereumIndexer.DB.LogsConnectionString);
var dbLogConnectionString = dbLogConnectionStringManager.CurrentValue;
if (string.IsNullOrEmpty(dbLogConnectionString))
{
consoleLogger.WriteWarningAsync(nameof(Startup), nameof(CreateLogWithSlack), "Table loggger is not inited").Wait();
return(aggregateLogger);
}
if (dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}"))
{
throw new InvalidOperationException($"LogsConnString {dbLogConnectionString} is not filled in settings");
}
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <LogEntity> .Create(dbLogConnectionStringManager, "EthereumSamuraiApiLog", consoleLogger),
consoleLogger);
if (settings.CurrentValue.SlackNotifications != null)
{
}
// Creating slack notification service, which logs own azure queue processing messages to aggregate log
var slackService = services.UseSlackNotificationsSenderViaAzureQueue(new AzureQueueIntegration.AzureQueueSettings
{
ConnectionString = settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.CurrentValue.SlackNotifications.AzureQueue.QueueName
}, aggregateLogger);
var slackNotificationsManager = new LykkeLogToAzureSlackNotificationsManager(slackService, consoleLogger);
// Creating azure storage logger, which logs own messages to concole log
var azureStorageLogger = new LykkeLogToAzureStorage(
persistenceManager,
slackNotificationsManager,
consoleLogger);
azureStorageLogger.Start();
aggregateLogger.AddLog(azureStorageLogger);
}
return(aggregateLogger);
}
private ILog CreateLogWithSlack(IServiceCollection services, IReloadingManager <AppSettings> settings)
{
var aggregateLogger = new AggregateLogger();
var consoleLog = new LogToConsole();
aggregateLogger.AddLog(consoleLog);
var dbLogConnectionStringManager = settings.Nested(x => x.TradesConverterJob.Db.LogsConnString);
var dbLogConnectionString = dbLogConnectionStringManager.CurrentValue;
if (string.IsNullOrEmpty(dbLogConnectionString))
{
consoleLog.WriteWarning(nameof(Startup), nameof(CreateLogWithSlack), "Table loggger is not inited");
return(aggregateLogger);
}
if (dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}"))
{
throw new InvalidOperationException($"LogsConnString {dbLogConnectionString} is not filled in settings");
}
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <LogEntity> .Create(dbLogConnectionStringManager, "TradesConverterLog", consoleLog),
consoleLog);
// Creating slack notification service, which logs own azure queue processing messages to aggregate log
var slackService = services.UseSlackNotificationsSenderViaAzureQueue(new AzureQueueIntegration.AzureQueueSettings
{
ConnectionString = settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.CurrentValue.SlackNotifications.AzureQueue.QueueName
}, aggregateLogger);
var slackNotificationsManager = new LykkeLogToAzureSlackNotificationsManager(
slackService,
new HashSet <string> {
LykkeLogToAzureStorage.ErrorType, LykkeLogToAzureStorage.FatalErrorType, LykkeLogToAzureStorage.MonitorType
},
consoleLog);
var azureStorageLogger = new LykkeLogToAzureStorage(
persistenceManager,
slackNotificationsManager,
consoleLog);
azureStorageLogger.Start();
aggregateLogger.AddLog(azureStorageLogger);
var logToSlack = LykkeLogToSlack.Create(slackService, "Bridges", LogLevel.Error | LogLevel.FatalError | LogLevel.Warning);
aggregateLogger.AddLog(logToSlack);
return(aggregateLogger);
}
private static ILog CreateLogWithSlack(IServiceCollection services, IReloadingManager <AppSettings> settings)
{
var consoleLogger = new LogToConsole();
var aggregateLogger = new AggregateLogger();
aggregateLogger.AddLog(consoleLogger);
// Creating slack notification service, which logs own azure queue processing messages to aggregate log
var slackService = services.UseSlackNotificationsSenderViaAzureQueue(new AzureQueueIntegration.AzureQueueSettings
{
ConnectionString = settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.CurrentValue.SlackNotifications.AzureQueue.QueueName
}, aggregateLogger);
var dbLogConnectionStringManager = settings.Nested(x => x.BitcoinCashApi.Db.LogsConnString);
var dbLogConnectionString = dbLogConnectionStringManager.CurrentValue;
// Creating azure storage logger, which logs own messages to concole log
if (!string.IsNullOrEmpty(dbLogConnectionString) && !(dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}")))
{
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <LogEntity> .Create(dbLogConnectionStringManager, "BitcoinCashApiLog", consoleLogger),
consoleLogger);
var slackNotificationsManager = new LykkeLogToAzureSlackNotificationsManager(slackService, consoleLogger);
var azureStorageLogger = new LykkeLogToAzureStorage(
persistenceManager,
slackNotificationsManager,
consoleLogger);
azureStorageLogger.Start();
aggregateLogger.AddLog(azureStorageLogger);
var allMessagesSlackLogger = LykkeLogToSlack.Create
(
slackService,
"BlockChainIntegration",
// ReSharper disable once RedundantArgumentDefaultValue
LogLevel.All
);
aggregateLogger.AddLog(allMessagesSlackLogger);
var importantMessagesSlackLogger = LykkeLogToSlack.Create
(
slackService,
"BlockChainIntegrationImportantMessages",
LogLevel.All ^ LogLevel.Info
);
aggregateLogger.AddLog(importantMessagesSlackLogger);
}
return(aggregateLogger);
}
private ILog CreateLogWithSlack(IServiceCollection services, IReloadingManager <AppSettings> settings)
{
_console = new LogToConsole();
var aggregateLogger = new AggregateLogger();
aggregateLogger.AddLog(_console);
var dbLogConnectionStringManager = settings.Nested(x => x.TradeVolumesService.LogsConnString);
var dbLogConnectionString = dbLogConnectionStringManager.CurrentValue;
if (string.IsNullOrEmpty(dbLogConnectionString))
{
_console.WriteWarning(nameof(Startup), nameof(CreateLogWithSlack), "Table loggger is not inited");
return(aggregateLogger);
}
if (dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}"))
{
throw new InvalidOperationException($"LogsConnString {dbLogConnectionString} is not filled in settings");
}
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <LogEntity> .Create(dbLogConnectionStringManager, "TradeVolumesLog", _console),
_console);
// Creating slack notification service, which logs own azure queue processing messages to aggregate log
var slackService = services.UseSlackNotificationsSenderViaAzureQueue(new AzureQueueIntegration.AzureQueueSettings
{
ConnectionString = settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.CurrentValue.SlackNotifications.AzureQueue.QueueName
}, aggregateLogger);
var slackNotificationsManager = new LykkeLogToAzureSlackNotificationsManager(slackService, _console);
// Creating azure storage logger, which logs own messages to concole log
var azureStorageLogger = new LykkeLogToAzureStorage(
persistenceManager,
slackNotificationsManager,
_console);
azureStorageLogger.Start();
aggregateLogger.AddLog(azureStorageLogger);
return(aggregateLogger);
}
private ILog CreateLogWithSlack(IServiceCollection services, IReloadingManager <AppSettings> settings)
{
_consoleLog = new LogToConsole();
var aggregateLogger = new AggregateLogger();
aggregateLogger.AddLog(_consoleLog);
// Creating slack notification service, which logs own azure queue processing messages to aggregate log
var slackService = services.UseSlackNotificationsSenderViaAzureQueue(new AzureQueueIntegration.AzureQueueSettings
{
ConnectionString = settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.CurrentValue.SlackNotifications.AzureQueue.QueueName
}, aggregateLogger);
var dbLogConnectionStringManager = settings.Nested(x => x.OrderbookToBlobBridgeJob.LogsConnectionString);
var dbLogConnectionString = dbLogConnectionStringManager.CurrentValue;
// Creating azure storage logger, which logs own messages to concole log
if (!string.IsNullOrEmpty(dbLogConnectionString) && !(dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}")))
{
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <LogEntity> .Create(dbLogConnectionStringManager, "OrderbookToBlobBridgeLogs", _consoleLog),
_consoleLog);
var slackNotificationsManager = new LykkeLogToAzureSlackNotificationsManager(
slackService,
new HashSet <string> {
LykkeLogToAzureStorage.ErrorType, LykkeLogToAzureStorage.FatalErrorType, LykkeLogToAzureStorage.MonitorType
},
_consoleLog);
var azureStorageLogger = new LykkeLogToAzureStorage(
persistenceManager,
slackNotificationsManager,
_consoleLog);
azureStorageLogger.Start();
aggregateLogger.AddLog(azureStorageLogger);
var logToSlack = LykkeLogToSlack.Create(slackService, "Bridges", LogLevel.Error | LogLevel.FatalError | LogLevel.Warning);
aggregateLogger.AddLog(logToSlack);
}
return(aggregateLogger);
}
private static ILog CreateLogWithSlack(IServiceCollection services, IReloadingManager <AppSettings> settings)
{
var consoleLogger = new LogToConsole();
var aggregateLogger = new AggregateLogger();
aggregateLogger.AddLog(consoleLogger);
var dbLogConnectionStringManager = settings.Nested(x => x.MtConsistencyCheckerJob.Db.LogsConnString);
var dbLogConnectionString = dbLogConnectionStringManager.CurrentValue;
if (string.IsNullOrEmpty(dbLogConnectionString))
{
consoleLogger.WriteWarningAsync(nameof(Startup), nameof(CreateLogWithSlack), "Table loggger is not inited").Wait();
return(aggregateLogger);
}
if (dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}"))
{
throw new InvalidOperationException($"LogsConnString {dbLogConnectionString} is not filled in settings");
}
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <LogEntity> .Create(dbLogConnectionStringManager, "ConsistencyCheckerLog", consoleLogger),
consoleLogger);
// Creating slack notification service, which logs own azure queue processing messages to aggregate log
var slackService = CreateSlackService(services, settings, aggregateLogger);
services.AddSingleton <IMtSlackNotificationsSender>(slackService);
var slackNotificationsManager = new LykkeLogToAzureSlackNotificationsManager(slackService, consoleLogger);
// Creating azure storage logger, which logs own messages to concole log
var azureStorageLogger = new LykkeLogToAzureStorage(
persistenceManager,
slackNotificationsManager,
consoleLogger);
azureStorageLogger.Start();
aggregateLogger.AddLog(azureStorageLogger);
return(aggregateLogger);
}
/// <param name="serviceCollection">Service collection to which log instance will be added</param>
/// <param name="connectionString">Connection string's realoading manager</param>
/// <param name="slackNotificationsSender">Slack notification sender to which warnings and errors will be forwarded</param>
/// <param name="tableName">Log's table name. Default is "Logs"</param>
/// <param name="lastResortLog">Last resort log (e.g. Console), which will be used to log logging infrastructure's issues</param>
/// <param name="maxBatchLifetime">Log entries batch's lifetime, when exceeded, batch will be saved, and new batch will be started. Default is 5 seconds</param>
/// <param name="batchSizeThreshold">Log messages batch's max size, when exceeded, batch will be saved, and new batch will be started. Default is 100 entries</param>
/// <param name="disableSlackAntiSpam">Flag for slack antispam protection control</param>
public static LykkeLogToAzureStorage UseLogToAzureStorage(this IServiceCollection serviceCollection,
IReloadingManager <string> connectionString,
ISlackNotificationsSender slackNotificationsSender = null,
string tableName = "Logs",
ILog lastResortLog = null,
TimeSpan?maxBatchLifetime = null,
int batchSizeThreshold = 100,
bool disableSlackAntiSpam = false)
{
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <LogEntity> .Create(connectionString, tableName, lastResortLog),
lastResortLog);
var slackNotificationsManager = slackNotificationsSender != null
? new LykkeLogToAzureSlackNotificationsManager(slackNotificationsSender, disableSlackAntiSpam, lastResortLog)
: null;
var log = new LykkeLogToAzureStorage(
persistenceManager,
slackNotificationsManager,
lastResortLog,
maxBatchLifetime,
batchSizeThreshold,
ownPersistenceManager: true,
ownSlackNotificationsManager: true);
log.Start();
if (lastResortLog == null)
{
serviceCollection.AddSingleton <ILog>(log);
}
else
{
var aggregatedLog = new AggregateLogger();
aggregatedLog.AddLog(lastResortLog);
aggregatedLog.AddLog(log);
serviceCollection.AddSingleton <ILog>(aggregatedLog);
}
return(log);
}
private static ILog CreateLogWithSlack(IServiceCollection services, AppSettings settings)
{
var consoleLogger = new LogToConsole();
var aggregateLogger = new AggregateLogger();
aggregateLogger.AddLog(consoleLogger);
// Creating slack notification service, which logs own azure queue processing messages to aggregate log
var slackService = services.UseSlackNotificationsSenderViaAzureQueue(new AzureQueueIntegration.AzureQueueSettings
{
ConnectionString = settings.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.SlackNotifications.AzureQueue.QueueName
}, aggregateLogger);
var dbLogConnectionString = settings.GoogleDriveUploadService.Db.LogsConnString;
// Creating azure storage logger, which logs own messages to concole log
if (!string.IsNullOrEmpty(dbLogConnectionString) && !(dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}")))
{
const string appName = "Lykke.Service.GoogleDriveUpload";
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
appName,
AzureTableStorage <LogEntity> .Create(() => dbLogConnectionString, "GoogleDriveUploadLog", consoleLogger),
consoleLogger);
var slackNotificationsManager = new LykkeLogToAzureSlackNotificationsManager(appName, slackService, consoleLogger);
var azureStorageLogger = new LykkeLogToAzureStorage(
appName,
persistenceManager,
slackNotificationsManager,
consoleLogger);
azureStorageLogger.Start();
aggregateLogger.AddLog(azureStorageLogger);
}
return(aggregateLogger);
}
private static ILog CreateLogWithSlack(IServiceCollection services, IReloadingManager <AppSettings> settings)
{
var consoleLogger = new LogToConsole();
var aggregateLogger = new AggregateLogger();
aggregateLogger.AddLog(consoleLogger);
// Creating slack notification service, which logs own azure queue processing messages to aggregate log
var slackService = CreateSlackService(services, settings, aggregateLogger);
var dbLogConnectionStringManager = settings.Nested(x => x.MarginTradingOrderbookAggregator.Db.LogsConnString);
var dbLogConnectionString = dbLogConnectionStringManager.CurrentValue;
// Creating azure storage logger, which logs own messages to concole log
if (!string.IsNullOrEmpty(dbLogConnectionString) && !(dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}")))
{
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <LogEntity> .Create(dbLogConnectionStringManager, ServiceName + "Log", consoleLogger),
consoleLogger);
var slackNotificationsManager = new LykkeLogToAzureSlackNotificationsManager(slackService, consoleLogger);
var azureStorageLogger = new LykkeLogToAzureStorage(
persistenceManager,
slackNotificationsManager,
consoleLogger);
azureStorageLogger.Start();
services.AddSingleton(azureStorageLogger);
aggregateLogger.AddLog(azureStorageLogger);
}
return(aggregateLogger);
}
protected virtual ILog CreateLogWithSlack(IServiceCollection services,
IReloadingManager <TApplicationSettings> settings, CurrentApplicationInfo applicationInfo,
CorrelationContextAccessor correlationContextAccessor)
{
var logTableName = ApplicationName + applicationInfo.EnvInfo + "Log";
var aggregateLogger = new AggregateLogger();
var consoleLogger = new LogToConsole();
aggregateLogger.AddLog(consoleLogger);
#region Logs settings validation
if (!settings.CurrentValue.MtBrokersLogs.UseSerilog &&
string.IsNullOrWhiteSpace(settings.CurrentValue.MtBrokersLogs.LogsConnString))
{
throw new Exception("Either UseSerilog must be true or LogsConnString must be set");
}
#endregion Logs settings validation
#region Slack registration
IMtSlackNotificationsSender slackService = null;
if (settings.CurrentValue.SlackNotifications != null)
{
var azureQueue = new AzureQueueSettings
{
ConnectionString = settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.CurrentValue.SlackNotifications.AzureQueue.QueueName
};
var commonSlackService =
services.UseSlackNotificationsSenderViaAzureQueue(azureQueue, consoleLogger);
slackService =
new MtSlackNotificationsSender(commonSlackService, ApplicationName, Environment.EnvironmentName);
}
else
{
slackService =
new MtSlackNotificationsSenderLogStub(ApplicationName, Environment.EnvironmentName, consoleLogger);
}
services.AddSingleton <ISlackNotificationsSender>(slackService);
services.AddSingleton <IMtSlackNotificationsSender>(slackService);
#endregion Slack registration
if (settings.CurrentValue.MtBrokersLogs.UseSerilog)
{
aggregateLogger.AddLog(new SerilogLogger(applicationInfo.GetType().Assembly, Configuration, new List <ILogEventEnricher>
{
new CorrelationLogEventEnricher("CorrelationId", correlationContextAccessor)
}));
}
else if (settings.CurrentValue.MtBrokersLogs.StorageMode == StorageMode.SqlServer)
{
aggregateLogger.AddLog(new LogToSql(new SqlLogRepository(logTableName,
settings.CurrentValue.MtBrokersLogs.LogsConnString)));
}
else if (settings.CurrentValue.MtBrokersLogs.StorageMode == StorageMode.Azure)
{
var dbLogConnectionStringManager = settings.Nested(x => x.MtBrokersLogs.LogsConnString);
var dbLogConnectionString = dbLogConnectionStringManager.CurrentValue;
if (string.IsNullOrEmpty(dbLogConnectionString))
{
consoleLogger.WriteWarningAsync(ApplicationName,
nameof(CreateLogWithSlack), "Table logger is not initialized").Wait();
return(aggregateLogger);
}
if (dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}"))
{
throw new InvalidOperationException($"LogsConnString {dbLogConnectionString} is not filled in settings");
}
// Creating azure storage logger, which logs own messages to console log
var azureStorageLogger = services.UseLogToAzureStorage(settings.Nested(s => s.MtBrokersLogs.LogsConnString),
slackService, logTableName, consoleLogger);
azureStorageLogger.Start();
aggregateLogger.AddLog(azureStorageLogger);
}
return(aggregateLogger);
}
private static ILog CreateLogWithSlack(IConfiguration configuration, IServiceCollection services,
IReloadingManager <AppSettings> settings, CorrelationContextAccessor correlationContextAccessor)
{
var consoleLogger = new LogToConsole();
var aggregateLogger = new AggregateLogger();
aggregateLogger.AddLog(consoleLogger);
#region Logs settings validation
if (!settings.CurrentValue.TradingHistoryService.UseSerilog &&
string.IsNullOrWhiteSpace(settings.CurrentValue.TradingHistoryService.Db.LogsConnString))
{
throw new Exception("Either UseSerilog must be true or LogsConnString must be set");
}
#endregion Logs settings validation
// Creating slack notification service, which logs own azure queue processing messages to aggregate log
ILykkeLogToAzureSlackNotificationsManager slackNotificationsManager = null;
if (settings.CurrentValue.SlackNotifications != null)
{
var slackService = services.UseSlackNotificationsSenderViaAzureQueue(
new Lykke.AzureQueueIntegration.AzureQueueSettings
{
ConnectionString = settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.CurrentValue.SlackNotifications.AzureQueue.QueueName
}, aggregateLogger);
slackNotificationsManager = new LykkeLogToAzureSlackNotificationsManager(slackService, consoleLogger);
}
if (settings.CurrentValue.TradingHistoryService.UseSerilog)
{
aggregateLogger.AddLog(new SerilogLogger(typeof(Startup).Assembly, configuration, new List <ILogEventEnricher>()
{
new CorrelationLogEventEnricher("CorrelationId", correlationContextAccessor)
}));
}
else if (settings.CurrentValue.TradingHistoryService.Db.StorageMode == StorageMode.Azure)
{
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <LogEntity> .Create(settings.Nested(x => x.TradingHistoryService.Db.LogsConnString),
"TradingHistoryServiceLog", consoleLogger),
consoleLogger);
// Creating azure storage logger, which logs own messages to concole log
var azureStorageLogger = new LykkeLogToAzureStorage(
persistenceManager,
slackNotificationsManager,
consoleLogger);
azureStorageLogger.Start();
aggregateLogger.AddLog(azureStorageLogger);
}
else if (settings.CurrentValue.TradingHistoryService.Db.StorageMode == StorageMode.SqlServer)
{
var sqlLogger = new LogToSql(new SqlLogRepository("TradingHistoryAPIsLog",
settings.CurrentValue.TradingHistoryService.Db.LogsConnString));
aggregateLogger.AddLog(sqlLogger);
}
LogLocator.Log = aggregateLogger;
return(aggregateLogger);
}
private static ILog CreateLogWithSlack(IConfiguration configuration, IServiceCollection services,
IReloadingManager <AppSettings> settings)
{
var tableName = "CandlesProducerServiceLog";
var consoleLogger = new LogToConsole();
var aggregateLogger = new AggregateLogger();
aggregateLogger.AddLog(consoleLogger);
LykkeLogToAzureSlackNotificationsManager slackNotificationsManager = null;
if (settings.CurrentValue.SlackNotifications != null)
{
// Creating slack notification service, which logs own azure queue processing messages to aggregate log
var slackService = services.UseSlackNotificationsSenderViaAzureQueue(new AzureQueueIntegration.AzureQueueSettings
{
ConnectionString = settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.CurrentValue.SlackNotifications.AzureQueue.QueueName
}, aggregateLogger);
slackNotificationsManager = new LykkeLogToAzureSlackNotificationsManager(slackService, consoleLogger);
var logToSlack = LykkeLogToSlack.Create(slackService, "Prices");
aggregateLogger.AddLog(logToSlack);
}
if (settings.CurrentValue.MtCandlesProducerJob.UseSerilog)
{
aggregateLogger.AddLog(new SerilogLogger(typeof(Startup).Assembly, configuration));
}
else if (settings.CurrentValue.MtCandlesProducerJob.Db.StorageMode == StorageMode.SqlServer)
{
aggregateLogger.AddLog(
new LogToSql(new SqlLogRepository(tableName,
settings.CurrentValue.MtCandlesProducerJob.Db.LogsConnString)));
}
else if (settings.CurrentValue.MtCandlesProducerJob.Db.StorageMode == StorageMode.Azure)
{
var dbLogConnectionString = settings.CurrentValue.MtCandlesProducerJob.Db.LogsConnString;
// Creating azure storage logger, which logs own messages to console log
if (!string.IsNullOrEmpty(dbLogConnectionString) && !(dbLogConnectionString.StartsWith("${") &&
dbLogConnectionString.EndsWith("}")))
{
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <Logs.LogEntity> .Create(settings.Nested(x =>
x.MtCandlesProducerJob.Db.LogsConnString), tableName, consoleLogger),
consoleLogger);
var azureStorageLogger = new LykkeLogToAzureStorage(
persistenceManager,
slackNotificationsManager,
consoleLogger);
azureStorageLogger.Start();
aggregateLogger.AddLog(azureStorageLogger);
}
}
return(aggregateLogger);
}