public BrokerCallbackInvoker(
IServiceProvider serviceProvider,
ISilverbackLogger <BrokerCallbackInvoker> logger)
{
_logger = logger;
_serviceProvider = Check.NotNull(serviceProvider, nameof(serviceProvider));
}
public void LogProduced(
ISilverbackLogger logger,
IProducerEndpoint endpoint,
string actualEndpoint,
IReadOnlyCollection <MessageHeader>?headers,
IBrokerMessageIdentifier?brokerMessageIdentifier)
{
if (!logger.IsEnabled(IntegrationLogEvents.MessageProduced))
{
return;
}
(string?value1, string?value2) = _logEnricher.GetAdditionalValues(
endpoint,
headers,
brokerMessageIdentifier);
_messageProduced.Invoke(
logger.InnerLogger,
actualEndpoint,
headers?.GetValue(DefaultMessageHeaders.MessageType),
headers?.GetValue(DefaultMessageHeaders.MessageId),
value1,
value2,
null);
}
/// <summary>
/// Initializes a new instance of the <see cref="RecurringDistributedBackgroundService" /> class using
/// the default settings for the lock mechanism.
/// </summary>
/// <param name="interval">
/// The interval between each execution.
/// </param>
/// <param name="distributedLockManager">
/// The <see cref="IDistributedLockManager" />.
/// </param>
/// <param name="logger">
/// The <see cref="ISilverbackLogger" />.
/// </param>
protected RecurringDistributedBackgroundService(
TimeSpan interval,
IDistributedLockManager distributedLockManager,
ISilverbackLogger<RecurringDistributedBackgroundService> logger)
: this(interval, null, distributedLockManager, logger)
{
}
public void LogMoved(
ISilverbackLogger logger,
IRawInboundEnvelope envelope,
IProducerEndpoint targetEndpoint)
{
if (!logger.IsEnabled(IntegrationLogEvents.MessageMoved))
{
return;
}
(string?value1, string?value2) = _logEnricher.GetAdditionalValues(
envelope.Endpoint,
envelope.Headers,
envelope.BrokerMessageIdentifier);
_messageMoved.Invoke(
logger.InnerLogger,
targetEndpoint.DisplayName,
envelope.ActualEndpointDisplayName,
envelope.Headers.GetValue(DefaultMessageHeaders.MessageType),
envelope.Headers.GetValue(DefaultMessageHeaders.MessageId),
value1,
value2,
null);
}
private static void OnLog(
LogMessage logMessage,
KafkaConsumer consumer,
ISilverbackLogger logger)
{
switch (logMessage.Level)
{
case SyslogLevel.Emergency:
case SyslogLevel.Alert:
case SyslogLevel.Critical:
logger.LogConfluentConsumerLogCritical(logMessage, consumer);
break;
case SyslogLevel.Error:
logger.LogConfluentConsumerLogError(logMessage, consumer);
break;
case SyslogLevel.Warning:
logger.LogConfluentConsumerLogWarning(logMessage, consumer);
break;
case SyslogLevel.Notice:
case SyslogLevel.Info:
logger.LogConfluentConsumerLogInformation(logMessage, consumer);
break;
default:
logger.LogConfluentConsumerLogDebug(logMessage, consumer);
break;
}
}
public void LogCannotMoveSequences(
ISilverbackLogger logger,
IRawInboundEnvelope envelope,
ISequence sequence)
{
if (!logger.IsEnabled(IntegrationLogEvents.CannotMoveSequences))
{
return;
}
(string?value1, string?value2) = _logEnricher.GetAdditionalValues(
envelope.Endpoint,
envelope.Headers,
envelope.BrokerMessageIdentifier);
_cannotMoveSequences.Invoke(
logger.InnerLogger,
sequence.GetType().Name,
envelope.ActualEndpointDisplayName,
envelope.Headers.GetValue(DefaultMessageHeaders.MessageType),
envelope.Headers.GetValue(DefaultMessageHeaders.MessageId),
value1,
value2,
null);
}
private static void OnOffsetsCommitted(
CommittedOffsets offsets,
KafkaConsumer consumer,
IBrokerCallbacksInvoker callbacksInvoker,
ISilverbackLogger logger)
{
foreach (var topicPartitionOffsetError in offsets.Offsets)
{
if (topicPartitionOffsetError.Offset == Offset.Unset)
{
continue;
}
if (topicPartitionOffsetError.Error != null &&
topicPartitionOffsetError.Error.Code != ErrorCode.NoError)
{
logger.LogOffsetCommitError(topicPartitionOffsetError, consumer);
}
else
{
logger.LogOffsetCommitted(topicPartitionOffsetError.TopicPartitionOffset, consumer);
}
}
callbacksInvoker.Invoke <IKafkaOffsetCommittedCallback>(
handler => handler.OnOffsetsCommitted(offsets, consumer));
}
public static void LogSkippingIncompleteSequence(
this ISilverbackLogger logger,
IncompleteSequence sequence) =>
SkippingIncompleteSequence(
logger.InnerLogger,
sequence.SequenceId,
null);
public void LogInboundTrace(
ISilverbackLogger logger,
LogLevel logLevel,
EventId eventId,
string message,
IRawInboundEnvelope envelope,
Exception?exception,
Func <object?[]>?argumentsProvider = null)
{
if (!logger.IsEnabled(IntegrationLogEvents.LowLevelTracing))
{
return;
}
(string?value1, string?value2) = _logEnricher.GetAdditionalValues(
envelope.Endpoint,
envelope.Headers,
envelope.BrokerMessageIdentifier);
var args = new List <object?>(argumentsProvider?.Invoke() ?? Array.Empty <object?>());
args.Add(envelope.ActualEndpointDisplayName);
args.Add(envelope.Headers.GetValue(DefaultMessageHeaders.MessageType));
args.Add(envelope.Headers.GetValue(DefaultMessageHeaders.MessageId));
args.Add(value1);
args.Add(value2);
logger.InnerLogger.Log(
logLevel,
eventId,
exception,
EnrichMessage(message),
args.ToArray());
}
/// <summary>
/// Initializes a new instance of the <see cref="DbDistributedLockManager" /> class.
/// </summary>
/// <param name="serviceScopeFactory">
/// The <see cref="IServiceScopeFactory" /> used to resolve the scoped types.
/// </param>
/// <param name="logger">
/// The <see cref="ISilverbackLogger" />.
/// </param>
public DbDistributedLockManager(
IServiceScopeFactory serviceScopeFactory,
ISilverbackLogger <DbDistributedLockManager> logger)
{
_serviceScopeFactory = Check.NotNull(serviceScopeFactory, nameof(serviceScopeFactory));
_logger = Check.NotNull(logger, nameof(logger));
}
public static void LogConnectionLost(
this ISilverbackLogger logger,
MqttClientWrapper client) =>
ConnectionLost(
logger.InnerLogger,
client.ClientConfig.ClientId,
null);
public void LogProduceError(
ISilverbackLogger logger,
IProducerEndpoint endpoint,
string actualEndpoint,
IReadOnlyCollection <MessageHeader>?headers,
Exception exception)
{
if (!logger.IsEnabled(IntegrationLogEvents.MessageProduced))
{
return;
}
(string?value1, string?value2) = _logEnricher.GetAdditionalValues(
endpoint,
headers,
null);
_errorProducingMessage.Invoke(
logger.InnerLogger,
actualEndpoint,
headers?.GetValue(DefaultMessageHeaders.MessageType),
headers?.GetValue(DefaultMessageHeaders.MessageId),
value1,
value2,
exception);
}
public static void LogConnectRetryError(
this ISilverbackLogger logger,
MqttClientWrapper client,
Exception exception) =>
ConnectRetryError(
logger.InnerLogger,
client.ClientConfig.ClientId,
exception);
public SilverbackIntegrationLogger(ISilverbackLogger logger, ILogTemplates logTemplates)
{
Check.NotNull(logger, nameof(logger));
Check.NotNull(logTemplates, nameof(logTemplates));
_logger = logger;
LogTemplates = logTemplates;
}
public static void LogProducerQueueProcessingCanceled(
this ISilverbackLogger logger,
RabbitProducer producer) =>
ProducerQueueProcessingCanceled(
logger.InnerLogger,
producer.Id,
producer.Endpoint.DisplayName,
null);
public static void LogCreatingConfluentProducer(
this ISilverbackLogger logger,
KafkaProducer producer) =>
CreatingConfluentProducer(
logger.InnerLogger,
producer.Id,
producer.Endpoint.Name,
null);
/// <summary>
/// Initializes a new instance of the <see cref="SequencerConsumerBehaviorBase" /> class.
/// </summary>
/// <param name="sequenceReaders">
/// The <see cref="ISequenceReader" /> implementations to be used.
/// </param>
/// <param name="logger">
/// The <see cref="ISilverbackLogger" />.
/// </param>
protected SequencerConsumerBehaviorBase(
IEnumerable <ISequenceReader> sequenceReaders,
ISilverbackLogger <SequencerConsumerBehaviorBase> logger)
{
_sequenceReaders = Check.NotNull(sequenceReaders, nameof(sequenceReaders)).SortBySortIndex()
.ToList();
_logger = Check.NotNull(logger, nameof(logger));
}
public static void LogProduceNotAcknowledged(
this ISilverbackLogger logger,
KafkaProducer producer) =>
ProduceNotAcknowledged(
logger.InnerLogger,
producer.Id,
producer.Endpoint.Name,
null);
public static void LogConsumingCanceled(
this ISilverbackLogger logger,
KafkaConsumer consumer) =>
ConsumingCanceled(
logger.InnerLogger,
consumer.Id,
consumer.Endpoint.Name,
null);
public static void LogRecurringBackgroundServiceSleeping(
this ISilverbackLogger logger,
DistributedBackgroundService service,
TimeSpan delay) =>
RecurringBackgroundServiceSleeping(
logger.InnerLogger,
service.GetType().FullName,
delay.TotalMilliseconds,
null);
public static void LogConfluentConsumerDisconnectError(
this ISilverbackLogger logger,
KafkaConsumer consumer,
Exception exception) =>
ConfluentConsumerDisconnectError(
logger.InnerLogger,
consumer.Id,
consumer.Endpoint.Name,
exception);
public static void LogKafkaErrorHandlerError(
this ISilverbackLogger logger,
KafkaConsumer consumer,
Exception exception) =>
KafkaErrorHandlerError(
logger.InnerLogger,
consumer.Id,
consumer.Endpoint.Name,
exception);
public static void LogKafkaExceptionNoAutoRecovery(
this ISilverbackLogger logger,
KafkaConsumer consumer,
Exception exception) =>
KafkaExceptionNoAutoRecovery(
logger.InnerLogger,
consumer.Id,
consumer.Endpoint.Name,
exception);
public static void LogFailedToReleaseLock(
this ISilverbackLogger logger,
DistributedLockSettings lockSettings,
Exception exception) =>
FailedToReleaseLock(
logger.InnerLogger,
lockSettings.ResourceName,
lockSettings.UniqueId,
exception);
public static void LogConsumerFatalError(
this ISilverbackLogger logger,
IConsumer?consumer,
Exception exception) =>
ConsumerFatalError(
logger.InnerLogger,
consumer?.Id ?? "?",
consumer?.Endpoint.DisplayName ?? "?",
exception);
public static void SetEventsHandlers(
this IConfluentProducerBuilder producerBuilder,
KafkaProducer producer,
IBrokerCallbacksInvoker callbacksInvoker,
ISilverbackLogger logger) =>
producerBuilder
.SetStatisticsHandler(
(_, statistics) => OnStatistics(statistics, producer, callbacksInvoker, logger))
.SetLogHandler((_, logMessage) => OnLog(logMessage, producer, logger));
public static void LogConsumingCanceled(
this ISilverbackLogger logger,
KafkaConsumer consumer,
Exception exception) =>
ConsumingCanceled(
logger.InnerLogger,
consumer.Id,
consumer.Endpoint.DisplayName,
exception);
public static void LogKafkaLogHandlerError(
this ISilverbackLogger logger,
KafkaProducer producer,
Exception exception) =>
KafkaProducerLogHandlerError(
logger.InnerLogger,
producer.Id,
producer.Endpoint.Name,
exception);
/// <summary>
/// Initializes a new instance of the <see cref="Publisher" /> class.
/// </summary>
/// <param name="behaviorsProvider">
/// The <see cref="IBehaviorsProvider" />.
/// </param>
/// <param name="serviceProvider">
/// The <see cref="IServiceProvider" /> instance to be used to resolve the subscribers.
/// </param>
/// <param name="logger">
/// The <see cref="ISilverbackLogger" />.
/// </param>
public Publisher(
IBehaviorsProvider behaviorsProvider,
IServiceProvider serviceProvider,
ISilverbackLogger <Publisher> logger)
{
_behaviorsProvider = Check.NotNull(behaviorsProvider, nameof(behaviorsProvider));
_serviceProvider = Check.NotNull(serviceProvider, nameof(serviceProvider));
_logger = Check.NotNull(logger, nameof(logger));
}
/// <summary>
/// Initializes a new instance of the <see cref="OutboxWorkerService" /> class.
/// </summary>
/// <param name="interval">
/// The interval between each execution.
/// </param>
/// <param name="outboxWorker">
/// The <see cref="IOutboxWorker" /> implementation.
/// </param>
/// <param name="distributedLockSettings">
/// Customizes the lock mechanism settings.
/// </param>
/// <param name="distributedLockManager">
/// The <see cref="IDistributedLockManager" />.
/// </param>
/// <param name="logger">
/// The <see cref="ISilverbackLogger" />.
/// </param>
public OutboxWorkerService(
TimeSpan interval,
IOutboxWorker outboxWorker,
DistributedLockSettings distributedLockSettings,
IDistributedLockManager distributedLockManager,
ISilverbackLogger <OutboxWorkerService> logger)
: base(interval, distributedLockSettings, distributedLockManager, logger)
{
_outboxWorker = outboxWorker;
}
