/// <summary> /// Adds a sink that writes log events to the Windows event log. /// </summary> /// <param name="loggerConfiguration">The logger configuration.</param> /// <param name="source">The source name by which the application is registered on the local computer. </param> /// <param name="logName">The name of the log the source's entries are written to. Possible values include Application, System, or a custom event log. </param> /// <param name="machineName">The name of the machine hosting the event log written to. The local machine by default.</param> /// <param name="manageEventSource">If true, check/create event source as required. Defaults to false i.e. do not allow sink to manage event source creation.</param> /// <param name="outputTemplate">A message template describing the format used to write to the sink. The default is "{Timestamp} [{Level}] {Message}{NewLine}{Exception}".</param> /// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param> /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param> /// <param name="eventIdProvider">Supplies event ids for emitted log events.</param> /// <returns>Logger configuration, allowing configuration to continue.</returns> /// <exception cref="ArgumentNullException">A required parameter is null.</exception> public static LoggerConfiguration EventLog( this LoggerSinkConfiguration loggerConfiguration, string source, string logName = null, string machineName = ".", bool manageEventSource = false, string outputTemplate = DefaultOutputTemplate, IFormatProvider formatProvider = null, LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum, IEventIdProvider eventIdProvider = null) { if (loggerConfiguration == null) { throw new ArgumentNullException(nameof(loggerConfiguration)); } #if NETSTANDARD2_0 // Verify the code is running on Windows. if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { throw new PlatformNotSupportedException(RuntimeInformation.OSDescription); } #endif var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider); if (eventIdProvider == null) { return(loggerConfiguration.Sink(new EventLogSink(source, logName, formatter, machineName, manageEventSource), restrictedToMinimumLevel)); } return(loggerConfiguration.Sink(new EventLogSink(source, logName, formatter, machineName, manageEventSource, eventIdProvider), restrictedToMinimumLevel)); }
/// <summary> /// Adds a sink that writes log events to the Windows event log. /// </summary> /// <param name="loggerConfiguration">The logger configuration.</param> /// <param name="source">The source name by which the application is registered on the local computer.</param> /// <param name="logName">The name of the log the source's entries are written to. Possible values include Application, System, or a custom event log.</param> /// <param name="machineName">The name of the machine hosting the event log written to. The local machine by default.</param> /// <param name="manageEventSource">If false does not check/create event source. Defaults to true i.e. allow sink to manage event source creation</param> /// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param> /// <param name="formatter">Formatter to control how events are rendered into the file. To control /// plain text formatting, use the overload that accepts an output template instead.</param> /// <param name="eventIdProvider">Supplies event ids for emitted log events.</param> /// <returns> /// Logger configuration, allowing configuration to continue. /// </returns> /// <exception cref="System.ArgumentNullException">loggerConfiguration</exception> /// <exception cref="ArgumentNullException">A required parameter is null.</exception> public static LoggerConfiguration EventLog( this LoggerSinkConfiguration loggerConfiguration, ITextFormatter formatter, string source, string logName = null, string machineName = ".", bool manageEventSource = false, LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum, IEventIdProvider eventIdProvider = null) { if (loggerConfiguration == null) { throw new ArgumentNullException(nameof(loggerConfiguration)); } if (formatter == null) { throw new ArgumentNullException(nameof(formatter)); } if (eventIdProvider == null) { return(loggerConfiguration.Sink(new EventLogSink(source, logName, formatter, machineName, manageEventSource), restrictedToMinimumLevel)); } return(loggerConfiguration.Sink(new EventLogSink(source, logName, formatter, machineName, manageEventSource, eventIdProvider), restrictedToMinimumLevel)); }
/// <summary> /// Initializes a new instance of the <see cref="EventLogProvider"/> class. /// </summary> /// <param name="source">The source.</param> /// <param name="logName">Name of the log.</param> /// <param name="machineName">Name of the machine.</param> /// <param name="manageEventSource">if set to <c>true</c> [manage event source].</param> /// <param name="eventIdProvider">The event identifier provider.</param> public EventLogProvider(string source, string logName, string machineName, bool manageEventSource, IEventIdProvider eventIdProvider) { var provider = eventIdProvider ?? new EventIdProvider(); _adapter = new EventLogAdapter(source, logName, machineName, manageEventSource, provider); }
/// <summary> /// Initializes a new instance of the <see cref="EventLogAdapter"/> class. /// </summary> /// <param name="source">The source.</param> /// <param name="logName">Name of the log.</param> /// <param name="machineName">Name of the machine.</param> /// <param name="manageEventSource">if set to <c>true</c> [manage event source].</param> /// <param name="eventIdProvider">The event identifier provider.</param> /// <exception cref="ArgumentNullException">source</exception> /// <exception cref="ArgumentNullException">eventIdProvider</exception> public EventLogAdapter(string source, string logName, string machineName, bool manageEventSource, IEventIdProvider eventIdProvider) { if (source == null) { throw new ArgumentNullException(nameof(source)); } if (source.Length > MaximumSourceNameLengthChars) { source = source.Substring(0, MaximumSourceNameLengthChars); } source = source.Replace("<", "_"); source = source.Replace(">", "_"); _eventIdProvider = eventIdProvider ?? throw new ArgumentNullException(nameof(eventIdProvider)); _log = new EventLog(string.IsNullOrWhiteSpace(logName) ? ApplicationLogName : logName, machineName); if (manageEventSource) { ConfigureSource(_log, source); } else { _log.Source = source; } }
public EventBatchProducerTests() { dateTimeProvider = Substitute.For <IDateTimeProvider>(); nameProvider = Substitute.For <IEventNameProvider>(); eventIdProvider = Substitute.For <IEventIdProvider>(); expectedName = "event-name"; expectedTimestamp = DateTimeOffset.Now; metadata = new StreamMetadata( "id", "pk", "streamId", 1, StreamState.Active, expectedTimestamp.AddDays(-1)); options = new StreamWriteOptions { CausationId = "A", CorrelationId = "B", }; @event = new Fixture().Create <TestEvent>(); expectedEventId = new Fixture().Create <string>(); dateTimeProvider .GetDateTime() .Returns(expectedTimestamp); nameProvider .GetName(default)
public EventBatchProducer( IDateTimeProvider dateTimeProvider, IEventIdProvider eventIdProvider, IEventNameProvider nameProvider) { this.dateTimeProvider = dateTimeProvider; this.eventIdProvider = eventIdProvider; this.nameProvider = nameProvider; }
public CommunicationListener( ICommunicationModel communicationModel, ICommunicationModelConfiguration communicationModelConfiguration, IEventSubscriber eventSubscriber, IEventIdProvider eventIdProvider, IServiceResolver serviceResolver, IEnumerable <IMessageListeningMethod> listeningMethods) { _communicationModel = communicationModel; _communicationModelConfiguration = communicationModelConfiguration; _eventSubscriber = eventSubscriber; _eventIdProvider = eventIdProvider; _serviceResolver = serviceResolver; _listeningMethods = listeningMethods.ToDictionary(m => m.Type, m => m, StringComparer.OrdinalIgnoreCase); }
public ProxyMethodExecutor( ITransitionScope transitionScope, IRoutineMethodIdProvider routineMethodIdProvider, IEventIdProvider eventIdProvider, INumericIdGenerator numericIdGenerator, ITransitionCommitter transitionCommitter, IRoutineCompletionNotifier routineCompletionNotifier, IEventSubscriber eventSubscriber) { _transitionScope = transitionScope; _routineMethodIdProvider = routineMethodIdProvider; _eventIdProvider = eventIdProvider; _numericIdGenerator = numericIdGenerator; _transitionCommitter = transitionCommitter; _routineCompletionNotifier = routineCompletionNotifier; _eventSubscriber = eventSubscriber; }
public RabbitMQMessageListiningMethod( IConnectionManager connectionManager, IMessageHandler messageHandler, IEventSubscriber eventSubscriber, IEventIdProvider eventIdProvider, IServiceResolver serviceResolver, IMethodResolver methodResolver, ICommunicationModelConfiguration communicationModelConfiguration) { _connectionManager = connectionManager; _messageHandler = messageHandler; _eventSubscriber = eventSubscriber; _eventIdProvider = eventIdProvider; _serviceResolver = serviceResolver; _methodResolver = methodResolver; _communicationModelConfiguration = communicationModelConfiguration; }
/// <summary> /// Construct a sink posting to the Windows event log, creating the specified <paramref name="source"/> if it does not exist. /// </summary> /// <param name="source">The source name by which the application is registered on the local computer. </param> /// <param name="logName">The name of the log the source's entries are written to. Possible values include Application, System, or a custom event log.</param> /// <param name="textFormatter">Supplies culture-specific formatting information, or null.</param> /// <param name="machineName">The name of the machine hosting the event log written to.</param> /// <param name="manageEventSource">If false does not check/create event source. Defaults to true i.e. allow sink to manage event source creation</param> /// <param name="eventIdProvider">Supplies event ids for emitted log events.</param> public EventLogSink(string source, string logName, ITextFormatter textFormatter, string machineName, bool manageEventSource, IEventIdProvider eventIdProvider) { if (source == null) { throw new ArgumentNullException(nameof(source)); } if (textFormatter == null) { throw new ArgumentNullException(nameof(textFormatter)); } if (eventIdProvider == null) { throw new ArgumentNullException(nameof(eventIdProvider)); } // The source is limitted in length and allowed chars, see: https://msdn.microsoft.com/en-us/library/e29k5ebc%28v=vs.110%29.aspx if (source.Length > MaximumSourceNameLengthChars) { SelfLog.WriteLine("Trimming long event log source name to {0} characters", MaximumSourceNameLengthChars); source = source.Substring(0, MaximumSourceNameLengthChars); } source = source.Replace("<", "_"); source = source.Replace(">", "_"); _eventIdProvider = eventIdProvider; _textFormatter = textFormatter; _log = new System.Diagnostics.EventLog(string.IsNullOrWhiteSpace(logName) ? ApplicationLogName : logName, machineName); if (manageEventSource) { ConfigureSource(_log, source); } else { _log.Source = source; } }
public ProxyMethodExecutor( ITransitionScope transitionScope, IMethodIdProvider routineMethodIdProvider, IEventIdProvider eventIdProvider, IUniqueIdGenerator numericIdGenerator, IRoutineCompletionNotifier routineCompletionNotifier, IEventSubscriber eventSubscriber, ICommunicationSettingsProvider communicationSettingsProvider, IMethodInvokerFactory methodInvokerFactory, ISingleMethodInvoker singleMethodInvoker, ISingleEventPublisher singleEventPublisher) { _transitionScope = transitionScope; _routineMethodIdProvider = routineMethodIdProvider; _eventIdProvider = eventIdProvider; _idGenerator = numericIdGenerator; _routineCompletionNotifier = routineCompletionNotifier; _eventSubscriber = eventSubscriber; _communicationSettingsProvider = communicationSettingsProvider; _methodInvokerFactory = methodInvokerFactory; _singleMethodInvoker = singleMethodInvoker; _singleEventPublisher = singleEventPublisher; }
public ServiceTraceIdEnricher(IServiceProvider serviceProvider) : this(serviceProvider, null) { _eventIdProvider = serviceProvider.GetService <IEventIdProvider>() ?? new NullEventIdProvider(); }
public InMemoryEventCache(IEventIdProvider eventIdProvider, IEventSerializer eventSerializer) { _cache = new ConcurrentDictionary <string, SortedList <long, EventCacheItem> >(); _eventIdProvider = eventIdProvider; _eventSerializer = eventSerializer; }