/// <summary>
/// Creates instance of the <see cref="AzureQueuePublisher{TModel}"/>
/// </summary>
/// <param name="logFactory">Log factory</param>
/// <param name="serializer">Serializer</param>
/// <param name="publisherName">Name of the publisher</param>
/// <param name="settings">Queue settings</param>
/// <param name="bufferLifetime">Time interval, which indicates how often buffered messages will be published to the queue</param>
/// <param name="disableTelemetry">Disables Application Insight telemetry</param>
/// <param name="fireNForgetQueueExistenceCheck">Speed up azure queue existence check</param>
public AzureQueuePublisher(
[NotNull] ILogFactory logFactory,
[NotNull] IAzureQueueSerializer <TModel> serializer,
[NotNull] string publisherName,
[NotNull] AzureQueueSettings settings,
TimeSpan?bufferLifetime = null,
bool disableTelemetry = true,
bool fireNForgetQueueExistenceCheck = false)
: base(bufferLifetime ?? TimeSpan.FromMilliseconds(100), logFactory, publisherName)
{
_serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
if (string.IsNullOrWhiteSpace(settings.QueueName))
{
throw new InvalidOperationException("Queue name should be not empty");
}
_log = logFactory.CreateLog(this, publisherName);
_settings = new AzureQueueSettings
{
QueueName = _settings.QueueName.ToLower(),
ConnectionString = _settings.ConnectionString
};
_cloudQueue = _settings.GetQueueAsync(fireNForgetQueueExistenceCheck).GetAwaiter().GetResult();
if (disableTelemetry)
{
DisableTelemetry();
}
}
private static void SetupLoggers(IServiceCollection services, IReloadingManager <MtBackendSettings> mtSettings,
IReloadingManager <MarginSettings> settings)
{
var consoleLogger = new LogToConsole();
var azureQueue = new AzureQueueSettings
{
ConnectionString = mtSettings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = mtSettings.CurrentValue.SlackNotifications.AzureQueue.QueueName
};
var commonSlackService =
services.UseSlackNotificationsSenderViaAzureQueue(azureQueue, consoleLogger);
var slackService =
new MtSlackNotificationsSender(commonSlackService, "MT Backend", settings.CurrentValue.Env);
services.AddSingleton <ISlackNotificationsSender>(slackService);
services.AddSingleton <IMtSlackNotificationsSender>(slackService);
// Order of logs registration is important - UseLogToAzureStorage() registers ILog in container.
// Last registration wins.
LogLocator.RequestsLog = services.UseLogToAzureStorage(settings.Nested(s => s.Db.LogsConnString),
slackService, "MarginTradingBackendRequestsLog", consoleLogger);
LogLocator.CommonLog = services.UseLogToAzureStorage(settings.Nested(s => s.Db.LogsConnString),
slackService, "MarginTradingBackendLog", consoleLogger);
}
private static void Init()
{
//Configuration initialisation des différents objets
var configurationBuilder = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", true)
.AddJsonFile("appsettings.Development.json", true, false);
var configuration = configurationBuilder.Build();
//initialisation du système de log
var loggerFactory = new LoggerFactory().AddConsole(configuration);
//initialisation des files d'attente
var settings = new AzureQueueSettings();
configuration.GetSection("InputQueue").Bind(settings);
_inputQueueService = new AzureQueueService(settings);
_outputQueueSettings = new AzureQueueSettings();
configuration.GetSection("OutputQueue").Bind(_outputQueueSettings);
_outputQueueService = new AzureQueueService(_outputQueueSettings);
//initialisation du repository
_dataMapper = new DataMapper();
var productRepositorySettings = new RepositorySettings();
configuration.GetSection("Repositories:Product").Bind(productRepositorySettings);
var modelRepositorySettings = new RepositorySettings();
configuration.GetSection("Repositories:Model").Bind(modelRepositorySettings);
var diagnosticSource = new MyDiagnosticSource();
var productRepository = new RepositoryStoreFactory <ProductModel>(productRepositorySettings.Provider, new ConnectionOptions
{
Provider = productRepositorySettings.ProviderType,
ConnectionString = JsonConvert.SerializeObject(productRepositorySettings.ConnectionString)
}, loggerFactory, diagnosticSource);
var modelRepository = new RepositoryStoreFactory <ProductModel>(modelRepositorySettings.Provider, new ConnectionOptions
{
Provider = productRepositorySettings.ProviderType,
ConnectionString = JsonConvert.SerializeObject(modelRepositorySettings.ConnectionString)
}, loggerFactory, diagnosticSource);
_dataRepo = new DataRepository(productRepository, modelRepository, diagnosticSource, loggerFactory.CreateLogger <DataRepository>());
//initialisation du partage Azure
var azureBlobSettings = new AzureBlobSettings();
configuration.Bind(azureBlobSettings);
new AzureStorageAccess(azureBlobSettings);
}
private void Init()
{
var settings = new AzureQueueSettings(
connectionString: _appsettings.ServiceBus.ConnectionString,
queueName: _appsettings.ServiceBus.QueueName);
_azureQueueSender = new AzureQueueSender <Message>(settings);
_azureQueueReceiver = new AzureQueueReceiver <Message>(settings);
}
public AzureQueuePublisher(string applicationName, AzureQueueSettings settings)
: base(applicationName, 1000)
{
_settings = settings;
_settings.QueueName = _settings.QueueName.ToLower();
_cloudQueue = _settings.GetQueueAsync().GetAwaiter().GetResult();
DisableTelemetry();
}
public AzureQueueSubscriber(
string applicationName,
AzureQueueSettings settings,
bool disableTelemetry)
: base(applicationName, 1000)
{
_settings = settings;
if (disableTelemetry)
{
DisableTelemetry();
}
}
private static async Task Queue_Send()
{
var config = GetConfig();
var settings = new AzureQueueSettings(
connectionString: config["ServiceBus_ConnectionString"],
queueName: config["ServiceBus_QueueName"]);
var message = new Message {
Text = $"Hello Queue at {DateTime.Now.ToString()}"
};
IAzureQueueSender <Message> sender = new AzureQueueSender <Message>(settings);
await sender.SendAsync(message);
Console.WriteLine("Sent");
}
private static void SetupLoggers(IServiceCollection services, IReloadingManager <AppSettings> settings, IReloadingManager <BoxOptionsApiSettings> boxOptionsSettings)
{
var consoleLogger = new LogToConsole();
var azureQueue = new AzureQueueSettings
{
ConnectionString = settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.CurrentValue.SlackNotifications.AzureQueue.QueueName
};
var commonSlackService =
services.UseSlackNotificationsSenderViaAzureQueue(azureQueue, consoleLogger);
var log = services.UseLogToAzureStorage(boxOptionsSettings.Nested(s => s.ConnectionStrings.LogsConnString), commonSlackService,
"BoxOptionsPublicLogs", consoleLogger);
LogLocator.CommonLog = log;
}
public static ISlackNotificationsSender UseSlackNotificationsSenderViaAzureQueue(
this IServiceCollection serviceCollection,
AzureQueueSettings settings,
ILog log = null)
{
var applicationName = PlatformServices.Default.Application.ApplicationName;
var azureQueuePublisher =
new AzureQueuePublisher <SlackMessageQueueEntity>(applicationName, settings)
.SetLogger(log)
.SetSerializer(new SlackNotificationsSerializer())
.Start();
var result = new SlackNotificationsSender(azureQueuePublisher, ownQueue: true);
serviceCollection.AddSingleton <ISlackNotificationsSender>(result);
return(result);
}
public static ISlackNotificationsSender UseSlackNotificationsSenderViaAzureQueue(
this ContainerBuilder containerBuilder,
AzureQueueSettings settings,
ILog log = null)
{
var applicationName = PlatformServices.Default.Application.ApplicationName;
var azureQueuePublisher =
new AzureQueuePublisher <SlackMessageQueueEntity>(applicationName, settings)
.SetLogger(log)
.SetSerializer(new SlackNotificationsSerializer())
.Start();
var result = new SlackNotificationsSender(azureQueuePublisher);
containerBuilder.RegisterInstance(result).As <ISlackNotificationsSender>().SingleInstance();
return(result);
}
private static void Queue_Receive()
{
var config = GetConfig();
var settings = new AzureQueueSettings(
connectionString: config["ServiceBus_ConnectionString"],
queueName: config["ServiceBus_QueueName"]);
IAzureQueueReceiver <Message> receiver = new AzureQueueReceiver <Message>(settings);
receiver.Receive(
message =>
{
//throw new ApplicationException("Oops!");
Console.WriteLine(message.Text);
return(MessageProcessResponse.Complete);
},
ex => Console.WriteLine(ex.Message),
() => Console.WriteLine("Waiting..."));
}
private static async Task Queue_Send()
{
var config = GetConfig();
//var connName = "Endpoint=sb://az532testbusmsm.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=H3/Z/4jxtfGqToxT14cOPRjk0bBGR+G7aFU8b7Ej1sE=";
//var queueName = "az532testqueue";
var settings = new AzureQueueSettings(
connectionString: config["ServiceBus_ConnectionString"],
queueName: config["ServiceBus_QueueName"]);
var message = new Message {
Text = $"Hello Queue at {DateTime.Now.ToString()}"
};
IAzureQueueSender <Message> sender = new AzureQueueSender <Message>(settings);
await sender.SendAsync(message);
Console.WriteLine("Queue_Send --> Sent message : " + message.Text);
}
public static void Main(string[] args)
{
var settings = new AzureQueueSettings
{
ConnectionString = "",
QueueName = ""
};
var log = new LogToConsole();
var serviceCollection = new ServiceCollection();
var sender = serviceCollection.UseSlackNotificationsSenderViaAzureQueue(settings, log);
sender.SendErrorAsync("Test message").Wait();
Console.WriteLine("Done");
Console.ReadLine();
}
public AzureQueueReceiver(AzureQueueSettings settings)
{
_settings = settings;
Init();
}
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);
}
public AzureQueueService(IOptions <AzureQueueSettings> settingsOptions)
{
_settings = settingsOptions.Value;
}
public AzureQueueService(AzureQueueSettings settings)
{
_settings = settings;
}
public QueueManager(AzureQueueSettings settings)
{
this.settings = settings;
Init();
}
private static void SetupLoggers(IConfiguration configuration, IServiceCollection services,
IReloadingManager <MtBackendSettings> mtSettings, CorrelationContextAccessor correlationContextAccessor)
{
var settings = mtSettings.Nested(x => x.MtBackend);
const string requestsLogName = "MarginTradingBackendRequestsLog";
const string logName = "MarginTradingBackendLog";
var consoleLogger = new LogToConsole();
#region Logs settings validation
if (!settings.CurrentValue.UseSerilog && string.IsNullOrWhiteSpace(settings.CurrentValue.Db.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 (mtSettings.CurrentValue.SlackNotifications != null)
{
var azureQueue = new AzureQueueSettings
{
ConnectionString = mtSettings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = mtSettings.CurrentValue.SlackNotifications.AzureQueue.QueueName
};
var commonSlackService =
services.UseSlackNotificationsSenderViaAzureQueue(azureQueue, consoleLogger);
slackService =
new MtSlackNotificationsSender(commonSlackService, "MT Backend", settings.CurrentValue.Env);
}
#endregion Slack registration
if (settings.CurrentValue.UseSerilog)
{
LogLocator.RequestsLog = LogLocator.CommonLog = new SerilogLogger(typeof(Startup).Assembly, configuration,
new List <Func <(string Name, object Value)> >
{
() => ("BrokerId", settings.CurrentValue.BrokerId)
},
new List <ILogEventEnricher>
{
new CorrelationLogEventEnricher("CorrelationId", correlationContextAccessor)
});
}
else if (settings.CurrentValue.Db.StorageMode == StorageMode.SqlServer)
{
LogLocator.RequestsLog = new AggregateLogger(
new LogToSql(new SqlLogRepository(requestsLogName,
settings.CurrentValue.Db.LogsConnString)),
new LogToConsole());
LogLocator.CommonLog = new AggregateLogger(
new LogToSql(new SqlLogRepository(logName,
settings.CurrentValue.Db.LogsConnString)),
new LogToConsole());
}
else if (settings.CurrentValue.Db.StorageMode == StorageMode.Azure)
{
if (slackService == null)
{
slackService =
new MtSlackNotificationsSenderLogStub("MT Backend", settings.CurrentValue.Env, consoleLogger);
}
LogLocator.RequestsLog = services.UseLogToAzureStorage(settings.Nested(s => s.Db.LogsConnString),
slackService, requestsLogName, consoleLogger);
LogLocator.CommonLog = services.UseLogToAzureStorage(settings.Nested(s => s.Db.LogsConnString),
slackService, logName, consoleLogger);
}
if (slackService == null)
{
slackService =
new MtSlackNotificationsSenderLogStub("MT Backend", settings.CurrentValue.Env, LogLocator.CommonLog);
}
services.AddSingleton <ISlackNotificationsSender>(slackService);
services.AddSingleton <IMtSlackNotificationsSender>(slackService);
services.AddSingleton <ILoggerFactory>(x => new WebHostLoggerFactory(LogLocator.CommonLog));
}
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 AzureQueueSender(AzureQueueSettings settings)
{
_settings = settings;
Init();
}
