/// <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;
}
