static void Main(string[] args)
{
var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
var configurationBuilder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("Serilog.json", optional: false, reloadOnChange: true);
var configuration = configurationBuilder.Build();
var configClient = new RabbitMQClientConfiguration
{
Username = "******",
Password = "******",
Exchange = "LogEvent",
ExchangeType = "fanout",
DeliveryMode = RabbitMQDeliveryMode.NonDurable,
RouteKey = "Logs",
Port = 5672,
VHost = "/"
};
configClient.Hostnames.Add("localhost");
RabbitMQSinkConfiguration sinkConfiguration = new RabbitMQSinkConfiguration
{
BatchPostingLimit = 0,
Period = default,
/// <summary>
/// Adds a sink that lets you push log messages to RabbitMQ
/// Will be used when configuring via configuration file
/// Is for backward-compatibility with previous version but gives possibility to use multiple hosts
/// </summary>
public static LoggerConfiguration RabbitMQ(
this LoggerSinkConfiguration loggerConfiguration,
string[] hostnames, string username, string password, string exchange = null, string exchangeType = null,
RabbitMQDeliveryMode deliveryMode = RabbitMQDeliveryMode.NonDurable, string routeKey = null, int port = 0,
string vHost = null, ushort heartbeat = 0, IProtocol protocol = null, int batchPostingLimit = 0,
TimeSpan period = default, ITextFormatter formatter = null
)
{
RabbitMQClientConfiguration clientConfiguration = new RabbitMQClientConfiguration
{
Username = username,
Password = password,
Exchange = exchange,
ExchangeType = exchangeType,
DeliveryMode = deliveryMode,
RouteKey = routeKey,
Port = port,
VHost = vHost,
Heartbeat = heartbeat,
Protocol = protocol
};
foreach (string hostname in hostnames)
{
clientConfiguration.Hostnames.Add(hostname);
}
RabbitMQSinkConfiguration sinkConfiguration = new RabbitMQSinkConfiguration
{
BatchPostingLimit = batchPostingLimit, Period = period, TextFormatter = formatter
};
return(RegisterSink(loggerConfiguration, clientConfiguration, sinkConfiguration));
}
public static void Main(string[] args)
{
// Wait for RabbitMQ
Thread.Sleep(10000);
var config = new RabbitMQClientConfiguration
{
Port = 5672,
DeliveryMode = RabbitMQ.RabbitMQDeliveryMode.Durable,
Exchange = "serilog-sink-exchange",
Username = "******",
Password = "******",
ExchangeType = "fanout"
};
config.Hostnames.Add("rabbitmq");
var logger = new LoggerConfiguration()
.WriteTo.RabbitMQ((clientConfiguration, sinkConfiguration) => {
clientConfiguration.From(config);
sinkConfiguration.TextFormatter = new JsonFormatter();
})
.MinimumLevel.Verbose()
.CreateLogger();
logger.Verbose("Verbose log entry");
logger.Debug("Debug log entry");
logger.Information("Information log entry");
logger.Warning("Warning log entry");
logger.Error("Error log entry");
logger.Fatal("Fatal log entry");
}
private static void ConfigureSerilog(IServiceCollection services)
{
var serilogConfiguration = _configuration.GetSection("Serilog");
var rabbitConfig = new RabbitMQClientConfiguration
{
Username = serilogConfiguration["RabbitMqUser"],
Password = serilogConfiguration["RabbitMqPassword"],
Exchange = "",
RouteKey = serilogConfiguration["RabbitMqRoutingKey"],
Port = Convert.ToInt32(serilogConfiguration["RabbitMqPort"]),
DeliveryMode = RabbitMQDeliveryMode.Durable,
};
rabbitConfig.Hostnames.Add(serilogConfiguration["RabbitMqHost"]);
Log.Logger = new LoggerConfiguration()
.Enrich.FromLogContext()
.MinimumLevel.Information()
.MinimumLevel.Override("Microsoft", new LoggingLevelSwitch(LogEventLevel.Error))
.Enrich.FromLogContext()
//.WriteTo.Console() If you want to view the log on the console
.WriteTo.RabbitMQ((clientConfiguration, sinkConfiguration) =>
{
clientConfiguration.From(rabbitConfig);
sinkConfiguration.TextFormatter = new JsonFormatter();
})
.CreateLogger();
var loggerFactory = new LoggerFactory();
loggerFactory.AddSerilog();
services.AddSingleton <ILoggerFactory>(loggerFactory);
}
/// <summary>
/// Constructor for RabbitMqClient
/// </summary>
/// <param name="configuration">mandatory</param>
public RabbitMQClient(RabbitMQClientConfiguration configuration)
{
// load configuration
_config = configuration;
_publicationAddress = new PublicationAddress(_config.ExchangeType, _config.Exchange, _config.RouteKey);
// initialize
_connectionFactory = GetConnectionFactory();
}
/// <summary>
/// Constructor for RabbitMqClient
/// </summary>
/// <param name="configuration">mandatory</param>
public RabbitMQClient(RabbitMQClientConfiguration configuration)
{
// load configuration
_config = configuration;
_publicationAddress = new PublicationAddress(_config.ExchangeType, _config.Exchange, _config.RouteKey);
// initialize
InitializeEndpoint();
}
/// <summary>
/// Adds a sink that lets you push log messages to RabbitMQ
/// Will be used when configuring via configuration file
/// If you need to overrule the text formatter, you will need to supply it here as a separate parameter instead of supplying it via the RabbitMQSinkConfiguration instance
/// which will not work when configuring via configuration file
/// </summary>
public static LoggerConfiguration RabbitMQ(
this LoggerSinkConfiguration loggerConfiguration,
RabbitMQClientConfiguration clientConfiguration, RabbitMQSinkConfiguration sinkConfiguration, ITextFormatter textFormatter = null)
{
if (textFormatter != null)
{
sinkConfiguration.TextFormatter = textFormatter;
}
return(RegisterSink(loggerConfiguration, clientConfiguration, sinkConfiguration));
}
/// <summary>
/// Adds a sink that lets you push log messages to RabbitMQ
/// </summary>
public static LoggerConfiguration RabbitMQ(
this LoggerSinkConfiguration loggerConfiguration,
Action <RabbitMQClientConfiguration, RabbitMQSinkConfiguration> configure)
{
RabbitMQClientConfiguration clientConfiguration = new RabbitMQClientConfiguration();
RabbitMQSinkConfiguration sinkConfiguration = new RabbitMQSinkConfiguration();
configure(clientConfiguration, sinkConfiguration);
return(RegisterSink(loggerConfiguration, clientConfiguration, sinkConfiguration));
}
public RabbitMQPublisher(RabbitMQClientConfiguration configuration)
{
factory = new ConnectionFactory
{
HostName = configuration.Hostname,
VirtualHost = configuration.VirtualHost,
Port = configuration.Port,
Password = configuration.Password,
UserName = configuration.Username
};
this.configuration = configuration;
}
public static void Main(string[] args)
{
//var config = new RabbitMQClientConfiguration
//{
// Hostnames = { "127.0.0.1" },
// Username = "******",
// Password = "******",
// Exchange = "app-logging",
// ExchangeType = "direct",
// DeliveryMode = RabbitMQDeliveryMode.NonDurable,
// RouteKey = "Logs",
// Port = 5672
//};
var config = new RabbitMQClientConfiguration
{
Port = 5672,
DeliveryMode = RabbitMQDeliveryMode.Durable,
Exchange = "logging",
Username = "******",
Password = "******",
ExchangeType = "direct"
};
config.Hostnames.Add("localhost");
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.WriteTo.RabbitMQ((clientConfiguration, sinkConfiguration) =>
{
clientConfiguration.From(config);
sinkConfiguration.TextFormatter = new JsonFormatter();
})
.WriteTo.Console()
.CreateLogger();
try
{
CreateHostBuilder(args).Build().Run();
}
catch (Exception ex)
{
Log.Fatal(ex, "Host terminated unexpectedly");
}
finally
{
Log.CloseAndFlush();
}
}
/// <summary>
/// Constructor for RabbitMqClient
/// </summary>
/// <param name="configuration">mandatory</param>
public RabbitMQClient(RabbitMQClientConfiguration configuration)
{
_closeToken = _closeTokenSource.Token;
// RabbitMQ channels are not thread-safe.
// https://www.rabbitmq.com/dotnet-api-guide.html#model-sharing
// Create a pool of channels and give each call to Publish one channel.
for (var i = 0; i < MaxChannelCount; i++)
{
_modelLocks[i] = new SemaphoreSlim(1, 1);
}
// load configuration
_config = configuration;
_publicationAddress = new PublicationAddress(_config.ExchangeType, _config.Exchange, _config.RouteKey);
// initialize
_connectionFactory = GetConnectionFactory();
}
private static RabbitMQClientConfiguration RabbitMqClientConfiguration()
{
var uri = new Uri(BusConfigurator.Uri);
var rabbitConfiguration = new RabbitMQClientConfiguration
{
Username = BusConfigurator.UserName,
Password = BusConfigurator.Password,
VHost = uri.AbsolutePath.Replace("/", ""), // Remove the / at the begging and the end
Exchange = "CMI.Logging",
ExchangeType = ExchangeType.Fanout,
DeliveryMode = RabbitMQDeliveryMode.Durable,
Port = uri.IsDefaultPort ? 5672 : uri.Port,
Heartbeat = 60
};
rabbitConfiguration.Hostnames.Add(uri.Host);
return(rabbitConfiguration);
}
public static Serilog.ILogger AddCustomLogging(IServiceCollection services, IConfiguration configuration, string serviceName)
{
var logFormatter = new ElasticsearchJsonFormatter();
var rabbitCliente = new RabbitMQClientConfiguration();
configuration.Bind("rabbitLog", rabbitCliente);
rabbitCliente.SslOption = new RabbitMQ.Client.SslOption
{
Enabled = false,
};
rabbitCliente.DeliveryMode = RabbitMQDeliveryMode.Durable;
var rabbitConfiguration = new RabbitMQSinkConfiguration
{
Period = TimeSpan.FromDays(1),
TextFormatter = logFormatter,
};
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.Enrich.WithProperty("App Name", serviceName)
.Enrich.FromLogContext()
.Enrich.WithEnvironmentName()
.WriteTo.Logger(lc => lc.Filter.ByExcluding(Matching.WithProperty("AuditLog"))
.WriteTo.Console(logFormatter)
.WriteTo.RabbitMQ(rabbitCliente, rabbitConfiguration, logFormatter)
)
.CreateLogger();
var loggerFactory = new LoggerFactory();
loggerFactory
.AddSerilog();
services.AddSingleton <ILoggerFactory>(loggerFactory);
return(Log.Logger);
}
/// <summary>
/// Adds a sink that lets you push log messages to RabbitMQ
/// </summary>
public static LoggerConfiguration RabbitMQ(
this LoggerSinkConfiguration loggerConfiguration,
Action <RabbitMQClientConfiguration, RabbitMQSinkConfiguration> configure)
{
RabbitMQClientConfiguration rabbitMQConfiguration = new RabbitMQClientConfiguration();
RabbitMQSinkConfiguration rabbitMQSinkConfiguration = new RabbitMQSinkConfiguration();
configure(rabbitMQConfiguration, rabbitMQSinkConfiguration);
// guards
if (loggerConfiguration == null)
{
throw new ArgumentNullException("loggerConfiguration");
}
if (rabbitMQConfiguration.Hostnames.Count == 0)
{
throw new ArgumentException("hostnames cannot be empty, specify at least one hostname", "hostnames");
}
if (string.IsNullOrEmpty(rabbitMQConfiguration.Username))
{
throw new ArgumentException("username cannot be 'null' or and empty string.");
}
if (rabbitMQConfiguration.Password == null)
{
throw new ArgumentException("password cannot be 'null'. Specify an empty string if password is empty.");
}
if (rabbitMQConfiguration.Port <= 0 || rabbitMQConfiguration.Port > 65535)
{
throw new ArgumentOutOfRangeException("port", "port must be in a valid range (1 and 65535)");
}
rabbitMQSinkConfiguration.BatchPostingLimit = (rabbitMQSinkConfiguration.BatchPostingLimit == default(int)) ? DefaultBatchPostingLimit : rabbitMQSinkConfiguration.BatchPostingLimit;
rabbitMQSinkConfiguration.Period = (rabbitMQSinkConfiguration.Period == default(TimeSpan)) ? DefaultPeriod : rabbitMQSinkConfiguration.Period;
return
(loggerConfiguration
.Sink(new RabbitMQSink(rabbitMQConfiguration, rabbitMQSinkConfiguration), rabbitMQSinkConfiguration.RestrictedToMinimumLevel));
}
public void RegisterSink(LoggerSinkConfiguration sinkConfiguration)
{
if (!Enum.TryParse(_options.DeliveryMode, true, out RabbitMQDeliveryMode deliveryMode))
{
throw new ConfigurationErrorsException($"{nameof(_options.DeliveryMode)} in RabbitMQ configuration is not valid");
}
var sslOptions = _options.Ssl ?? new RabbitMQSinkSslOptions();
var rabbitMqClientConfiguration = new RabbitMQClientConfiguration
{
DeliveryMode = deliveryMode,
Exchange = _options.Exchange,
ExchangeType = _options.ExchangeType,
Heartbeat = _options.Heartbeat,
Password = _options.Password,
Port = _options.Port,
Username = _options.Username,
VHost = _options.VHost,
SslOption = new SslOption(
string.IsNullOrEmpty(sslOptions.ServerName) ? _options.Hostname : sslOptions.ServerName,
sslOptions.CertPath,
sslOptions.IsEnabled
)
{
CertPassphrase = sslOptions.CertPassphrase
}
};
rabbitMqClientConfiguration.Hostnames.Add(_options.Hostname);
sinkConfiguration.RabbitMQ(rabbitMqClientConfiguration, new RabbitMQSinkConfiguration
{
BatchPostingLimit = _options.BatchPostingLimit,
Period = TimeSpan.FromSeconds(_options.PeriodInSeconds),
TextFormatter = new JsonFormatter()
});
}
public static void Main(string[] args)
{
var config = new RabbitMQClientConfiguration
{
Port = 5672,
DeliveryMode = RabbitMQDeliveryMode.Durable,
Username = "******",
Password = "******",
Hostnames = { "rabbitmq" },
RouteKey = "Elasticsearch_Queue"
};
Log.Logger = new LoggerConfiguration()
.Enrich.FromLogContext()
.Enrich.WithExceptionDetails()
.MinimumLevel.Verbose()
.Enrich.WithProperty("Application", "ServiceB")
.MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
.MinimumLevel.Override("System", LogEventLevel.Warning)
.WriteTo.RabbitMQ((clientConfiguration, sinkConfiguration) =>
{
clientConfiguration.From(config);
sinkConfiguration.TextFormatter = new JsonFormatter();
})
.CreateLogger();
try
{
CreateHostBuilder(args).Build().Run();
}
catch (Exception ex)
{
Log.Error(ex, ex.Message);
throw;
}
}
public RabbitMQSink(RabbitMQClientConfiguration configuration,
RabbitMQSinkConfiguration rabbitMQSinkConfiguration) : base(rabbitMQSinkConfiguration.BatchPostingLimit, rabbitMQSinkConfiguration.Period)
{
_formatter = rabbitMQSinkConfiguration.TextFormatter;
_client = new RabbitMQClient(configuration);
}
public static LoggerConfiguration RabbitMQ(
this LoggerSinkConfiguration loggerConfiguration,
RabbitMQClientConfiguration clientConfiguration, RabbitMQSinkConfiguration sinkConfiguration)
{
return(RegisterSink(loggerConfiguration, clientConfiguration, sinkConfiguration));
}
static LoggerConfiguration RegisterSink(LoggerSinkConfiguration loggerConfiguration, RabbitMQClientConfiguration clientConfiguration, RabbitMQSinkConfiguration sinkConfiguration)
{
// guards
if (loggerConfiguration == null)
{
throw new ArgumentNullException("loggerConfiguration");
}
if (clientConfiguration.Hostnames.Count == 0)
{
throw new ArgumentException("hostnames cannot be empty, specify at least one hostname", "hostnames");
}
if (string.IsNullOrEmpty(clientConfiguration.Username))
{
throw new ArgumentException("username cannot be 'null' or and empty string.");
}
if (clientConfiguration.Password == null)
{
throw new ArgumentException("password cannot be 'null'. Specify an empty string if password is empty.");
}
if (clientConfiguration.Port <= 0 || clientConfiguration.Port > 65535)
{
throw new ArgumentOutOfRangeException("port", "port must be in a valid range (1 and 65535)");
}
sinkConfiguration.BatchPostingLimit = (sinkConfiguration.BatchPostingLimit == default(int)) ? DefaultBatchPostingLimit : sinkConfiguration.BatchPostingLimit;
sinkConfiguration.Period = (sinkConfiguration.Period == default(TimeSpan)) ? DefaultPeriod : sinkConfiguration.Period;
return
(loggerConfiguration
.Sink(new RabbitMQSink(clientConfiguration, sinkConfiguration), sinkConfiguration.RestrictedToMinimumLevel, sinkConfiguration.LevelSwitch));
}
