private static ILog CreateLog(IServiceCollection services, ApplicationSettings settings)
{
var appSettings = settings.MarketProfileService;
LykkeLogToAzureStorage logToAzureStorage = null;
var logToConsole = new LogToConsole();
var logAggregate = new LogAggregate();
logAggregate.AddLogger(logToConsole);
if (!string.IsNullOrEmpty(appSettings.Db.LogsConnectionString) &&
!(appSettings.Db.LogsConnectionString.StartsWith("${") && appSettings.Db.LogsConnectionString.EndsWith("}")))
{
logToAzureStorage = new LykkeLogToAzureStorage("Lykke.Service.MarketProfile", new AzureTableStorage <LogEntity>(
appSettings.Db.LogsConnectionString, "MarketProfileService", logToConsole));
logAggregate.AddLogger(logToAzureStorage);
}
var log = logAggregate.CreateLogger();
var slackService = services.UseSlackNotificationsSenderViaAzureQueue(new AzureQueueSettings
{
ConnectionString = settings.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.SlackNotifications.AzureQueue.QueueName
}, log);
logToAzureStorage?.SetSlackNotification(slackService);
return(log);
}
public static void RegisterWebExtensions <TSettings, TISettings>(this ContainerBuilder builder, IServiceCollection services, IConfigurationRoot configuration, string settingsUrlPath, ILog lastResortLog)
where TSettings : class, ILogSettings, TISettings
{
var settings = configuration.LoadSettings <TSettings>(settingsUrlPath);
builder.RegisterInstance(settings.Nested(x => (ILogSettings)x))
.As <IReloadingManager <ILogSettings> >()
.SingleInstance();
builder.RegisterInstance(settings.Nested(x => (TISettings)x))
.As <IReloadingManager <TISettings> >()
.SingleInstance();
builder.Register(ctx =>
{
var logToSlack = new LykkeLogToAzureSlackNotificationsManager(settings.CurrentValue.ServiceName,
services.UseSlackNotificationsSenderViaAzureQueue(settings.CurrentValue.LogToSlack.AzureQueue, lastResortLog),
lastResortLog);
var logToAzure = new LykkeLogToAzureStoragePersistenceManager(settings.CurrentValue.ServiceName,
AzureTableStorage <LogEntity> .Create(settings.ConnectionString(x => x.LogToAzure.ConnectionString), settings.CurrentValue.LogToAzure.TableName, lastResortLog),
lastResortLog);
var logToTable = new LykkeLogToAzureStorage(settings.CurrentValue.ServiceName, logToAzure, logToSlack, lastResortLog);
return(logToTable);
}).As <ILog>().SingleInstance();
builder.Register(ctx => new GlobalErrorHandlerMiddleware(ctx.Resolve <ILog>(), settings.CurrentValue.ServiceName)).AsSelf().SingleInstance();
}
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 CreateLogWithSlack(IServiceCollection services, AppSettings settings)
{
LykkeLogToAzureStorage logToAzureStorage = null;
var logToConsole = new LogToConsole();
var logAggregate = new LogAggregate();
logAggregate.AddLogger(logToConsole);
var dbLogConnectionString = settings.LykkeServiceService.Db.LogsConnString;
// Creating azure storage logger, which logs own messages to concole log
if (!string.IsNullOrEmpty(dbLogConnectionString) && !(dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}")))
{
logToAzureStorage = new LykkeLogToAzureStorage("Lykke.Service.LykkeService", new AzureTableStorage <LogEntity>(
dbLogConnectionString, "LykkeServiceLog", logToConsole));
logAggregate.AddLogger(logToAzureStorage);
}
// Creating aggregate log, which logs to console and to azure storage, if last one specified
var log = logAggregate.CreateLogger();
// 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
}, log);
// Finally, setting slack notification for azure storage log, which will forward necessary message to slack service
logToAzureStorage?.SetSlackNotification(slackService);
return(log);
}
public void Test_that_batch_is_saved_when_lifetime_is_exceeded_and_then_when_size_is_exceeded()
{
// Arrange
var log = new LykkeLogToAzureStorage("Tests", _persistenceManagerMock, maxBatchLifetime: TimeSpan.FromSeconds(1), batchSizeThreshold: 10);
log.Start();
// Act
for (var i = 0; i < 5; ++i)
{
log.WriteInfoAsync("Test", "", "", "");
}
Task.Delay(TimeSpan.FromSeconds(1.5)).Wait();
for (var i = 0; i < 18; ++i)
{
log.WriteInfoAsync("Test", "", "", "");
}
Task.Delay(TimeSpan.FromMilliseconds(50)).Wait();
// Assert
_persistenceManagerMock.Received().Persist(Arg.Is <IReadOnlyCollection <LogEntity> >(e => e.Count == 5));
_persistenceManagerMock.Received().Persist(Arg.Is <IReadOnlyCollection <LogEntity> >(e => e.Count >= 10));
_persistenceManagerMock.DidNotReceive().Persist(Arg.Is <IReadOnlyCollection <LogEntity> >(e => e.Count != 5 && e.Count < 10));
log.Dispose();
}
public TraceService(ISystem system, LykkeLogToAzureStorage logToAzureStorage,
ISlackNotificationsSender slackNotificationsSender, ISettingsService settingsService)
{
_system = system;
_logToAzureStorage = logToAzureStorage;
_slackNotificationsSender = slackNotificationsSender;
_settingsService = settingsService;
}
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);
}
public static void ConfigureAzureLogger(this LogAggregate logAggregate, IServiceCollection services, string appName, AppSettings appSettings)
{
var log = logAggregate.CreateLogger();
var slackSender = services.UseSlackNotificationsSenderViaAzureQueue(appSettings.SlackNotifications.AzureQueue, log);
var azureLog = new LykkeLogToAzureStorage(appName,
new AzureTableStorage <LogEntity>(appSettings.BrokerQuoteFeed.ConnectionStrings.LogsConnectionString, appName + "Logs", log),
slackSender);
logAggregate.AddLogger(azureLog);
}
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 static ILog GetLog(IReloadingManager <string> connectionString, string tableName)
{
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <LogEntity> .Create(connectionString, tableName, LogToConsole),
LogToConsole);
var log = new LykkeLogToAzureStorage(persistenceManager, null, LogToConsole);
log.Start();
return(new AggregateLogger(LogToConsole, log));
}
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);
}
public void Test_that_batch_is_not_saved_when_lifetime_and_size_is_not_exceeded()
{
// Arrange
var log = new LykkeLogToAzureStorage("Tests", _persistenceManagerMock, maxBatchLifetime: TimeSpan.FromSeconds(100), batchSizeThreshold: 100);
log.Start();
// Act
for (var i = 0; i < 15; ++i)
{
log.WriteInfoAsync("Test", "", "", "");
}
Task.Delay(TimeSpan.FromSeconds(1)).Wait();
// Assert
_persistenceManagerMock.DidNotReceiveWithAnyArgs().Persist(null);
log.Dispose();
}
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);
}
public void Test_that_slack_notifications_is_sent_despite_of_batch_size_and_lifetime()
{
// Arrange
var log = new LykkeLogToAzureStorage("Tests",
_persistenceManagerMock, _slackNotificationsManagerMock,
maxBatchLifetime: TimeSpan.FromSeconds(100), batchSizeThreshold: 100);
log.Start();
// Act
for (var i = 0; i < 15; ++i)
{
log.WriteMonitorAsync("Test", "", "", "");
}
Task.Delay(TimeSpan.FromSeconds(1.5)).Wait();
// Assert
_slackNotificationsManagerMock.Received(15).SendNotification(Arg.Any <LogEntity>());
log.Dispose();
}
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);
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
ILog log = new LogToConsole();
var appName = nameof(TradingBot);
// Register dependencies, populate the services from
// the collection, and build the container. If you want
// to dispose of the container at the end of the app,
// be sure to keep a reference to it as a property or field.
var builder = new ContainerBuilder();
try
{
// Add framework services.
services.AddMvc()
.AddJsonOptions(options =>
{
options.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
});
services.AddSwaggerGen(options =>
{
options.DefaultLykkeConfiguration("v1", "ExchangeConnectorAPI");
options.AddSecurityDefinition("CustomScheme", new ApiKeyScheme {
In = "header", Description = "Please insert API key into field", Name = ApiKeyAuthAttribute.HeaderName, Type = "apiKey"
});
});
var settingsManager = Configuration.LoadSettings <TradingBotSettings>("SettingsUrl");
builder.RegisterInstance(settingsManager)
.As <IReloadingManager <TradingBotSettings> >();
var topSettings = settingsManager.CurrentValue;
var settings = topSettings.TradingBot;
builder.RegisterInstance(settings)
.As <AppSettings>()
.SingleInstance();
if (settings.AzureStorage.Enabled)
{
var slackService = services.UseSlackNotificationsSenderViaAzureQueue(topSettings.SlackNotifications.AzureQueue, log);
var tableStorage = AzureTableStorage <LogEntity> .Create(
settingsManager.ConnectionString(i => i.TradingBot.AzureStorage.LogsConnString), settings.AzureStorage.LogTableName, log);
builder.RegisterInstance(tableStorage).As <INoSQLTableStorage <LogEntity> >().SingleInstance();
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(appName, tableStorage, log);
var slackNotificationsManager = new LykkeLogToAzureSlackNotificationsManager(appName, slackService, log);
var logToTable = new LykkeLogToAzureStorage(
appName,
persistenceManager,
slackNotificationsManager,
log);
logToTable.Start();
log = new LogAggregate()
.AddLogger(log)
.AddLogger(logToTable)
.CreateLogger();
}
ApiKeyAuthAttribute.ApiKey = settings.AspNet.ApiKey;
// SignedModelAuthAttribute.ApiKey = settings.AspNet.ApiKey; //TODO use it somewhere
builder.RegisterInstance(log).As <ILog>().SingleInstance();
var signalsStorage = AzureTableStorage <TranslatedSignalTableEntity> .Create(
settingsManager.ConnectionString(i => i.TradingBot.AzureStorage.EntitiesConnString), settings.AzureStorage.TranslatedSignalsTableName, log);
builder.RegisterInstance(signalsStorage).As <INoSQLTableStorage <TranslatedSignalTableEntity> >().SingleInstance();
builder.RegisterModule(new ServiceModule(settings, log));
builder.Populate(services);
ApplicationContainer = builder.Build();
_log = log;
// Create the IServiceProvider based on the container.
return(new AutofacServiceProvider(ApplicationContainer));
}
catch (Exception exc)
{
log.WriteErrorAsync(
appName,
nameof(Startup),
nameof(ConfigureServices),
exc,
DateTime.UtcNow)
.Wait();
throw;
}
}
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);
}
