private ILogger SetContextFromLogEvent(ILogger logger, LogEvent logEvent)
{
logger.ForContext("Timestamp", logEvent.Timestamp);
logger.ForContext("LogSource", logEvent.LogSource);
logger.ForContext("Thread", logEvent.Thread);
return logger;
}
public Product GetProduct(ILogger log)
{
var idx = _random.Next() % _products.Count;
var result = _products[idx];
log.ForContext<Catalog>().Debug("Loaded {ProductId} from database in {TimeMS} ms", result.Id, (idx + 1) * 7);
return result;
}
public RequestLoggingMiddleware(RequestDelegate next, ILogger logger, RequestLoggingOptions options)
{
_next = next ?? throw new ArgumentNullException(nameof(next));
_logger = logger?.ForContext <RequestLoggingMiddleware>() ?? throw new ArgumentNullException(nameof(logger));
_options = options ?? throw new ArgumentNullException(nameof(options));
_recyclableMemoryStreamManager = new RecyclableMemoryStreamManager();
}
public void Setup()
{
_log = new LoggerConfiguration()
.WriteTo.Sink(new NullSink())
.CreateLogger();
_nested = _log.ForContext<NestedLoggerLatencyBenchmark>();
}
public ServerListCommand(ILogger logger, IServerApi serversApi, IRepository <Server> serversRepository, IRepository <Credentials> credentialsRepository, IServerPresenter serversPresenter)
{
this.logger = logger?.ForContext <ServerListCommand>() ?? throw new ArgumentNullException(nameof(logger));
this.serversApi = serversApi ?? throw new ArgumentNullException(nameof(serversApi));
this.serversRepository = serversRepository ?? throw new ArgumentNullException(nameof(serversRepository));
this.credentialsRepository = credentialsRepository ?? throw new ArgumentNullException(nameof(credentialsRepository));
this.serversPresenter = serversPresenter ?? throw new ArgumentNullException(nameof(serversPresenter));
}
public ILogger EnrichLoggerForStatelessServiceContext(StatelessService service)
{
if (Interlocked.Exchange(ref _hasBeenEnriched, 1) == 0)
{
_logger = _logger?.ForContext(new[] { new ServiceEnricher <StatelessServiceContext>(service.Context) });
}
return(_logger);
}
public EfPairRepository(
SharedContext sharedContext,
ILogger log
)
{
this.sharedContext = sharedContext ?? throw new ArgumentNullException("sharedContext");
this.log = log?.ForContext(GetType());
}
private ILogger SetContextFromLogEvent(ILogger logger, LogEvent logEvent)
{
logger = logger
.ForContext("Timestamp", logEvent.Timestamp)
.ForContext("LogSource", logEvent.LogSource)
.ForContext("Thread", logEvent.Thread.ManagedThreadId.ToString().PadLeft(4, '0'));
return logger;
}
public EmailBackedKeyValueStore(ILogger?logger, MimeMessage mimeMessage)
{
MessageAndId = new MimeMessageWithUniqueId
{
Message = mimeMessage,
UniqueId = UniqueId.Invalid
};
this.logger = logger?.ForContext <EmailBackedKeyValueStore>();
}
private void TryLogRequest(IRestRequest restRequest, IRequest request, IRestClient restClient, string configurationKey)
{
try
{
var restClientLogProperty = new
{
RequestContent = request.GetRequestContentForLogging(JsonConvert.SerializeObject(request)),
HttpRequestUrl = restClient.BuildUri(restRequest).ToString(),
HttpRequestType = restRequest.Method
};
_logger?.ForContext("RestClient", restClientLogProperty, destructureObjects: true)
?.Information("Rest request sent to {ConfigurationKey}", configurationKey);
}
catch (Exception e)
{
_logger?.Warning(e, "There was a problem logging the rest request");
}
}
public RestSharpClientWrapper(
IDictionary <string, Uri> baseUrlMappings,
IDictionary <string, IAuthorizationHeaderFactory> authorizationHeaderFactories,
IDictionary <string, TimeSpan> timeouts,
ILogger logger)
{
_baseUrlMappings = baseUrlMappings;
_authorizationHeaderFactories = authorizationHeaderFactories;
_timeouts = timeouts;
_logger = logger?.ForContext(GetType());
}
public ConfigController(
ILogger logger,
IHostingEnvironment hostingEnvironment,
IOptions <OktaWebClientOptions> options,
IOptions <CheckoutApiOptions> apiOptions
)
{
_logger = logger?.ForContext <ConfigController>() ?? throw new ArgumentNullException(nameof(logger));
_hostingEnvironment = hostingEnvironment ?? throw new ArgumentNullException(nameof(hostingEnvironment));
_options = options?.Value ?? throw new ArgumentNullException(nameof(options));
_apiOptions = apiOptions?.Value ?? throw new ArgumentNullException(nameof(apiOptions));
}
public WebPairRepository(
string DailyRatesEndpoint,
string YearlyRatesEndpoint,
IHttpClientFactory clientFactory,
ILogger log
)
{
this.DailyRatesEndpoint = DailyRatesEndpoint ?? throw new ArgumentNullException("DailyRatesEndpoint");
this.YearlyRatesEndpoint = YearlyRatesEndpoint ?? throw new ArgumentNullException("YearlyRatesEndpoint");
this.clientFactory = clientFactory ?? throw new ArgumentNullException("clientFactory");
this.log = log?.ForContext(GetType());
}
public Application(
IEnumerable <int> requestedYears,
WebPairRepository remotePairRepository,
IPairRepository persistancePairRepository,
ILogger log
)
{
this.requestedYears = requestedYears ?? throw new ArgumentNullException(nameof(requestedYears));
this.remotePairRepository = remotePairRepository ?? throw new ArgumentNullException(nameof(remotePairRepository));
this.persistancePairRepository = persistancePairRepository ?? throw new ArgumentNullException(nameof(persistancePairRepository));
this.log = log?.ForContext(GetType());
}
public ApiController(
IOptions <ApiControlerOptions> options,
IPairRepository pairRepo,
MonthlyReportBuilder monthlyReportBuilder,
ILogger log
)
{
this.RequiredSymbols = options?.Value?.RequiredSymbols ?? throw new ArgumentNullException(nameof(RequiredSymbols));
this.pairRepo = pairRepo ?? throw new ArgumentNullException(nameof(pairRepo));
this.monthlyReportBuilder = monthlyReportBuilder ?? throw new ArgumentNullException(nameof(monthlyReportBuilder));
this.log = log?.ForContext(GetType());
}
public Server(
ServerProtocolType serverProtocolType,
IIndex<ServerProtocolType, Func<IProtocol>> protocolFactory,
ConnectionManager connectionManager,
ILogger logger)
{
ConnectionManager = connectionManager;
_serverProtocolType = serverProtocolType;
Logger = logger.ForContext("ServerProtocolType", _serverProtocolType);
ProtocolFactory = protocolFactory[_serverProtocolType];
}
/// <summary>
/// Sets the logger for the handler. Will not overwrite an existing logger instance.
/// </summary>
/// <param name="logger"></param>
/// <exception cref="ArgumentNullException"><paramref name="logger"/> is null</exception>
public void SetLogger(ILogger logger)
{
if (this._loggerInitialized && this.Logger is not null)
{
return;
}
// ReSharper disable once ConstantConditionalAccessQualifier
this.Logger =
logger?.ForContext("Repository", this._repository, true) ??
throw new ArgumentNullException(nameof(logger));
this._loggerInitialized = true;
}
/// <summary>
/// Subscription wrapper
/// </summary>
/// <param name="outer"></param>
/// <param name="subscription"></param>
/// <param name="logger"></param>
public SubscriptionWrapper(SubscriptionServices outer,
SubscriptionModel subscription, ILogger logger)
{
_subscription = subscription.Clone() ??
throw new ArgumentNullException(nameof(subscription));
_outer = outer ??
throw new ArgumentNullException(nameof(outer));
_logger = logger?.ForContext <SubscriptionWrapper>() ??
throw new ArgumentNullException(nameof(logger));
_timer = new Timer(_ => OnCheckAsync().Wait());
_lock = new SemaphoreSlim(1, 1);
}
/// <summary>
/// Create processor
/// </summary>
/// <param name="outer"></param>
/// <param name="logger"></param>
public DefaultProcessor(EventProcessorFactory outer, ILogger logger)
{
_outer = outer ?? throw new ArgumentNullException(nameof(outer));
_processorId = Guid.NewGuid().ToString();
_logger = logger?.ForContext("ProcessorId", _processorId)
?? throw new ArgumentNullException(nameof(logger));
_handler = outer._context.Resolve <IEventProcessingHandler>();
_interval = (long?)_outer._config.CheckpointInterval?.TotalMilliseconds
?? long.MaxValue;
_sw = Stopwatch.StartNew();
logger.Information("EventProcessor {id} created", _processorId);
}
public Connection(int id, Socket client, IProtocol protocol, ILogger logger)
{
// Initialize members
Id = id;
Client = client;
Protocol = protocol;
Logger = logger;
Logger.ForContext("ConnectionId", id);
Connected = true;
LastActivity = DateTime.Now;
BeginReceive();
Protocol.Begin(this);
}
public SerilogLogger(
SerilogLoggerProvider provider,
ILogger logger = null,
string name = null)
{
if (provider == null) throw new ArgumentNullException(nameof(provider));
_provider = provider;
_name = name;
_logger = logger;
// If a logger was passed, the provider has already added itself as an enricher
_logger = _logger ?? Serilog.Log.Logger.ForContext(new[] { provider });
if (_name != null)
{
_logger = _logger.ForContext(Constants.SourceContextPropertyName, name);
}
}
/// <summary>
/// Create processor
/// </summary>
/// <param name="outer"></param>
/// <param name="partitionContext"></param>
/// <param name="logger"></param>
public DefaultProcessor(EventProcessorFactory outer, PartitionContext partitionContext,
ILogger logger)
{
_outer = outer ?? throw new ArgumentNullException(nameof(outer));
_partitionContext = partitionContext ?? throw new ArgumentNullException(nameof(partitionContext));
_processorId = Guid.NewGuid().ToString();
_logger = logger?.ForContext("ProcessorId", _processorId)
?? throw new ArgumentNullException(nameof(logger));
_handler = outer._context.Resolve <IEventProcessingHandler>();
_interval = (long?)_outer._config.CheckpointInterval?.TotalMilliseconds
?? long.MaxValue;
_sw = Stopwatch.StartNew();
_logger.Information("EventProcessor {id} for partition {partitionId} created",
_processorId, _partitionContext.PartitionId);
kEventProcessorDetails.WithLabels(_processorId, _partitionContext.EventHubPath, _partitionContext.ConsumerGroupName,
_partitionContext.PartitionId, "created").Inc();
}
public RelayTunnelFactory(ILogger logger, TunnelMetrics metrics, ServiceNamespaceOptions serviceNamespace, PortMappingOptions portMappings)
{
_log = logger?.ForContext(GetType());
_poolLocker = new object();
_serviceNamespace = serviceNamespace;
_portMappings = portMappings;
_replacedTunnels = new ConcurrentDictionary <object, RelayTunnel>();
_tunnels = new RelayTunnel[portMappings.RelayChannelCount];
_metrics = metrics;
for (var i = 0; i < portMappings.RelayChannelCount; i++)
{
_tunnels[i] = new RelayTunnel(logger, _metrics, serviceNamespace, portMappings.EntityPath, portMappings.RemoteConfigurationKey, portMappings.RelayConnectionTtlSeconds);
}
}
public AspTaskScheduler(
IEnumerable <IScheduledTask> scheduledTasks,
IServiceScopeFactory serviceScopeFactory,
ILogger log
)
{
this.log = log?.ForContext(GetType());
this._serviceScopeFactory = serviceScopeFactory ?? throw new ArgumentNullException(nameof(serviceScopeFactory));
var referenceTime = DateTime.UtcNow;
foreach (var scheduledTask in scheduledTasks)
{
_scheduledTasks.Add(new SchedulerTaskWrapper
{
Schedule = CrontabSchedule.Parse(scheduledTask.Schedule),
Task = scheduledTask,
NextRunTime = referenceTime
});
}
}
public void Check(IRelayServerConnection connection)
{
if (connection == null)
{
throw new ArgumentNullException(nameof(connection));
}
var logger = _logger?
.ForContext("RelayServerUri", connection.Uri)
.ForContext("RelayServerConnectionInstanceId", connection.RelayServerConnectionInstanceId);
var lastHeartbeat = connection.LastHeartbeat;
if (lastHeartbeat != DateTime.MinValue && lastHeartbeat != DateTime.MaxValue)
{
if (lastHeartbeat <= DateTime.UtcNow.Subtract(connection.HeartbeatInterval.Add(TimeSpan.FromSeconds(2))))
{
logger?.Warning("Did not receive expected heartbeat. last-heartbeat={LastHeartbeat}, heartbeat-interval={HeartbeatInterval}, relay-server={RelayServerUri}, relay-server-connection-instance-id={RelayServerConnectionInstanceId}", lastHeartbeat, connection.HeartbeatInterval);
connection.Reconnect();
}
}
}
static void Log(ILogger logger)
{
const int elapsedMs = 34;
var position = new { Latitude = 25, Longitude = 134 };
logger.ForContext<Program>().Debug("Processed {@Position} in {Elapsed:000} ms.", position, elapsedMs);
logger.ForContext<Program>().Verbose("Processed {@Position} in {Elapsed:000} ms.", position, elapsedMs);
logger.ForContext<Program>().Fatal("Processed {@Position} in {Elapsed:000} ms.", position, elapsedMs);
logger.ForContext<Program>().Information("Processed {@Position} in {Elapsed:000} ms.", position, elapsedMs);
logger.ForContext<Program>().Warning("Processed {@Position} in {Elapsed:000} ms.", position, elapsedMs);
try
{
throw new NotImplementedException();
}
catch (Exception ex)
{
logger.ForContext<Program>().Error(ex, "Processed {@Position} in {Elapsed:000} ms.", position, elapsedMs);
}
}
public SerilogLoggerProvider(ILogger logger = null)
{
if (logger != null)
_logger = logger.ForContext(new[] { this });
}
public ExceptionHandlingMiddleware(ILogger logger, RequestDelegate next)
{
_logger = logger?.ForContext <ExceptionHandlingMiddleware>() ?? throw new ArgumentNullException(nameof(logger));
_next = next ?? throw new ArgumentNullException(nameof(next));
}
public NancyBootstrapper(ILifetimeScope lifeTimeScope, ILogger logger)
{
StaticConfiguration.DisableErrorTraces = false;
_lifeTimeScope = lifeTimeScope;
_logger = logger.ForContext<NancyBootstrapper>();
}
public DatabaseAuthenticationService(ISession session, ILogger logger)
{
_session = session ?? throw new ArgumentNullException(nameof(session));
_logger = logger?.ForContext <DatabaseAuthenticationService>() ?? throw new ArgumentNullException(nameof(logger));
}
/// <summary>
/// Creates a SerilogTraceListener that uses the specified logger
/// </summary>
public SerilogTraceListener(ILogger logger)
{
this.logger = logger.ForContext<SerilogTraceListener>();
}
public UserLoggedInEventHandler(ILogger logger)
{
_logger = logger?.ForContext <UserLoggedInEvent>() ?? throw new ArgumentNullException(nameof(logger));
}
public PhotosRepository(ILogger logger, HttpClient httpClient, IOptions <JsonPlaceholderOptions> jsonPlaceholderOptions)
{
_logger = (logger?.ForContext <AlbumsRepository>()).ThrowIfNull(nameof(logger));
_httpClient = httpClient.ThrowIfNull(nameof(httpClient));
_jsonPlaceholderOptions = jsonPlaceholderOptions?.Value.ThrowIfNull(nameof(jsonPlaceholderOptions));
}
public MarkAllUserNotificationsReadCommandHandler(ISession session, ILogger logger)
{
_session = session ?? throw new ArgumentNullException(nameof(session));
_logger = logger?.ForContext <MarkAllUserNotificationsReadCommand>() ?? throw new ArgumentNullException(nameof(logger));
}
public SerilogActorCoreEvents(ILogger logger)
{
_logger = logger.ForContext<IActorCoreEvents>();
}
public Service(IConfig config, IOwinStartup owinStartup, ILogger logger)
{
_logger = logger.ForContext<Service>();
_config = config;
_owinStartup = owinStartup;
}
public PublishCommentCommandHandler(ISession session, ILogger logger)
{
_session = session ?? throw new ArgumentNullException(nameof(session));
_logger = logger?.ForContext <PublishCommentCommand>() ?? throw new ArgumentNullException(nameof(logger));
}
public ServerPresenter(ILogger logger)
{
this.logger = logger?.ForContext <ServerPresenter>() ?? throw new ArgumentNullException(nameof(logger));
}
public EditUserDetailsCommandHandler(ISession session, ILogger logger)
{
_session = session ?? throw new ArgumentNullException(nameof(session));
this._logger = logger?.ForContext <EditUserDetailsCommand>() ?? throw new ArgumentNullException(nameof(logger));
}
public LoggingBehaviour(ILogger logger)
{
this.logger = logger?.ForContext <ExceptionFilter>();
}
public AppResourceLocator(ILogger logger)
{
_logger = logger.ForContext<AppResourceLocator>();
_appExecutableName =
Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().Location);
}
/// <summary>
/// Creates a new <see cref="AppSettings"/> instance.
/// </summary>
/// <param name="logger"></param>
/// <param name="consumerManager"></param>
public AppService(ILogger logger, IConsumerManager consumerManager)
{
_logger = logger?.ForContext <AppService>() ?? throw new System.ArgumentNullException(nameof(logger));
_consumerManager = consumerManager ?? throw new System.ArgumentNullException(nameof(consumerManager));
}
public SerilogAzureEventHubActorSystemEvents(ILogger logger)
{
_logger = logger.ForContext<IAzureEventHubActorSystemEvents>();
}
public RequestTimingMeter(ILogger logger)
{
_logger = logger?.ForContext <TRequest>() ?? throw new ArgumentNullException(nameof(logger));
}
public MimeMessageLoader(MessageRepository messageRepository, ILogger logger)
{
_messageRepository = messageRepository;
_logger = logger.ForContext<MimeMessageLoader>();
}
public FollowingQueryHandler(ISession session, ILogger logger)
{
_session = session ?? throw new ArgumentNullException(nameof(session));
_logger = logger?.ForContext <FollowingQuery>() ?? throw new ArgumentNullException(nameof(logger));
}
SerilogLogWriterFactory(ILogger logger)
{
_loggerFactory = name => logger.ForContext("SourceContext", name);
}
