/// <summary>
/// Adds an event logger that is enabled for <see cref="LogLevel"/>s of minLevel or higher.
/// </summary>
/// <param name="factory">The extension method argument.</param>
/// <param name="settings">The <see cref="EventLogSettings"/>.</param>
public static ILoggerFactory AddEventLog(
[NotNull] this ILoggerFactory factory,
[NotNull] EventLogSettings settings)
{
factory.AddProvider(new EventLogLoggerProvider(settings));
return(factory);
}
public static void PrintSettingsToConsole(EventLogSettings defaultSettings)
{
PrintEnterEventLog();
string eventLogName = defaultSettings.LogName;
Console.WriteLine(eventLogName);
PrintEnterMachineName();
string machineName = defaultSettings.Machine;
Console.WriteLine(machineName);
PrintEnterLogSearch();
string logSearch = defaultSettings.Search;
Console.WriteLine(logSearch);
PrintEnterStartDate();
DateTime startDateTime = DateTime.Now.Subtract(TimeSpan.FromHours(defaultSettings.Hours));
Console.WriteLine(startDateTime);
PrintEnterEndDate();
Console.WriteLine("");
}
/// <summary>
/// Adds an event logger. Use <paramref name="settings"/> to enable logging for specific <see cref="LogLevel"/>s.
/// </summary>
/// <param name="builder">The extension method argument.</param>
/// <param name="settings">The <see cref="EventLogSettings"/>.</param>
/// <returns>The <see cref="ILoggingBuilder"/> so that additional calls can be chained.</returns>
public static ILoggingBuilder AddEventLog(this ILoggingBuilder builder, EventLogSettings settings)
{
ThrowHelper.ThrowIfNull(builder);
ThrowHelper.ThrowIfNull(settings);
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <ILoggerProvider>(new EventLogLoggerProvider(settings)));
return(builder);
}
private void ConfigureServices(IServiceCollection serviceCollection)
{
_serviceCollection = serviceCollection;
// WebServerOptions
serviceCollection.Configure <WebServerOptions>(_configuration);
// logging
serviceCollection.AddLogging(loggingBuilder =>
{
WebClientLoggerProvider clientMessageLoggerProvider;
// client message log
clientMessageLoggerProvider = new WebClientLoggerProvider((category, logLevel) => category != "System" && logLevel >= LogLevel.Information);
// add logger
loggingBuilder
.AddFilter((provider, source, logLevel) => !source.StartsWith("Microsoft."))
.AddDebug()
.AddProvider(clientMessageLoggerProvider);
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
EventLogSettings eventLogSettings;
if (BasicBootloader.IsUserInteractive)
{
eventLogSettings = new EventLogSettings();
}
else
{
eventLogSettings = new EventLogSettings()
{
LogName = _webServerOptions.EventLogName,
SourceName = _webServerOptions.EventLogSourceName
};
}
eventLogSettings.Filter = (category, logLevel) => category == "System" && logLevel >= LogLevel.Information;
loggingBuilder.AddEventLog(eventLogSettings);
}
});
// OneDasEngine
serviceCollection.AddOneDas(options =>
{
options.RestoreRuntimeId = RuntimeEnvironment.GetRuntimeIdentifier();
});
// Misc
serviceCollection.AddSingleton <OneDasConsole>();
serviceCollection.AddSingleton <ExtensionLoader>();
serviceCollection.AddSingleton <ClientPushService>();
}
private static ILogger<CertificateHelper> SetupLogging()
{
var logSettings = new EventLogSettings() { SourceName = "MM", LogName = "MM" };
var loggerFactory = LoggerFactory.Create(builder =>
{
builder
.AddEventLog(logSettings);
});
return loggerFactory.CreateLogger<CertificateHelper>();
}
public static ILogger GetProductionLogger()
{
var lf = new LoggerFactory();
var els = new EventLogSettings {
LogName = "HOLMS",
SourceName = "PBXConnector"
};
lf.AddEventLog(els);
return(lf.CreateLogger("Scheduler"));
}
public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
WebHost.CreateDefaultBuilder(args)
.UseStartup <Startup>().ConfigureLogging(logging =>
{
logging.ClearProviders();
//logging.AddConsole(); //use for iis express host. see result in output win from web server
logging.AddDebug(); //use for debuging mode.see result in output win from debug
EventLogSettings event_ = new EventLogSettings();
event_.LogName = "HSBorsLog";
event_.SourceName = "HSBorsSource";
logging.AddEventLog(event_); // use anywere. see in event viewer
});
private static ILogger GetLogger()
{
var lf = new LoggerFactory();
var els = new EventLogSettings {
LogName = "HOLMS",
SourceName = "Scheduler"
};
lf.AddEventLog(els);
return(lf.CreateLogger("Scheduler"));
}
private static ILogger SetupLogging()
{
var logSettings = new EventLogSettings()
{
SourceName = "MM", LogName = "MM"
};
var loggerFactory = LoggerFactory.Create(builder =>
{
builder
.AddEventLog(logSettings);
});
return(loggerFactory.CreateLogger <Program>());
}
/// <summary>
/// Adds an event logger. Use <paramref name="settings"/> to enable logging for specific <see cref="LogLevel"/>s.
/// </summary>
/// <param name="builder">The extension method argument.</param>
/// <param name="settings">The <see cref="EventLogSettings"/>.</param>
/// <returns>The <see cref="ILoggingBuilder"/> so that additional calls can be chained.</returns>
public static ILoggingBuilder AddEventLog(this ILoggingBuilder builder, EventLogSettings settings)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <ILoggerProvider>(new EventLogLoggerProvider(settings)));
return(builder);
}
/// <summary>
/// Adds an event logger that is enabled for <see cref="LogLevel"/>s of minLevel or higher.
/// </summary>
/// <param name="factory">The extension method argument.</param>
/// <param name="settings">The <see cref="EventLogSettings"/>.</param>
public static ILoggerFactory AddEventLog(
this ILoggerFactory factory,
EventLogSettings settings)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
factory.AddProvider(new EventLogLoggerProvider(settings));
return(factory);
}
private static void Main(string[] args)
{
bool isService = !(Debugger.IsAttached || args.Contains("--console"));
var builder = new HostBuilder()
.ConfigureHostConfiguration(config =>
{
config.AddEnvironmentVariables();
})
.ConfigureAppConfiguration((hostContext, config) =>
{
config.AddJsonFile("appsettings.json", optional: false);
config.AddJsonFile($"appsettings.{hostContext.HostingEnvironment.EnvironmentName}.json", optional: true);
config.AddEnvironmentVariables();
})
.ConfigureLogging((hostContext, loggingBuilder) =>
{
loggingBuilder.AddDebug();
loggingBuilder.AddConsole();
var settings = new EventLogSettings
{
SourceName = "MessageReceiverAsAService",
Filter = (source, level) =>
{
return(level >= LogLevel.Information);
}
};
loggingBuilder.AddEventLog(settings);
})
.ConfigureServices((hostContext, services) =>
{
services.AddOptions();
services.AddSingleton <IConfigureOptions <ServiceBusSubscriptionOptions> >(serviceProvider =>
{
var section = serviceProvider.GetRequiredService <IConfiguration>().GetSection("ServiceBusSubscriptionOptions");
return(new NamedConfigureFromConfigurationOptions <ServiceBusSubscriptionOptions>(string.Empty, section));
});
services.AddMessageReceiver();
services.AddHostedService <MessageReceiverService>();
});
RunAsync(builder, isService).GetAwaiter().GetResult();
}
public void Constructor_CreatesWindowsEventLog_WithSuppliedEventLogSettings()
{
// Arrange
var settings = new EventLogSettings()
{
SourceName = "foo",
LogName = "bar",
MachineName = "blah",
EventLog = null
};
// Act
var eventLogLogger = new EventLogLogger("Test", settings);
// Assert
var windowsEventLog = Assert.IsType <WindowsEventLog>(eventLogLogger.EventLog);
Assert.Equal(settings.LogName, windowsEventLog.DiagnosticsEventLog.Log);
Assert.Equal(settings.SourceName, windowsEventLog.DiagnosticsEventLog.Source);
Assert.Equal(settings.MachineName, windowsEventLog.DiagnosticsEventLog.MachineName);
}
static void Main(string[] args)
{
var logSettings = new EventLogSettings
{
Filter = (source, level) => level >= LogLevel.Trace
};
var loggerFactory = LoggerFactory.Create(builder =>
{
builder
.AddFilter("Microsoft", LogLevel.Warning)
.AddFilter("System", LogLevel.Warning)
.AddFilter("LoggingConsoleApp.Program", LogLevel.Debug)
.AddConsole()
.AddEventLog(logSettings);
});
ILogger logger = loggerFactory.CreateLogger <Program>();
logger.LogInformation(1234, "Example log information message");
logger.LogWarning(5678, "Example log warning message");
}
public static IServiceCollection AddApp(this IServiceCollection services)
{
return(services
.AddSingleton <IStartup, ST.Startup>()
.AddSingleton <MainForm>()
.AddSingleton <IAppConfiguration, AppConfiguration>()
.AddSingleton <IRepoHolder, RepoHolder>()
.AddSingleton <IGitFileRepo, GitFileRepo>()
.AddSingleton <IProjectFileRepo, ProjectFileRepo>()
.AddSingleton <ITabsRepoBuilder, TabsRepoBuilder>()
.AddSingleton <IAppSemaphoreSlim, AppSemaphoreSlim>()
.AddSingleton <IGitVersion, RepoCommandProcessor>()
.AddSingleton <ILoggerFactory>(sp =>
{
var eventSetting = new EventLogSettings
{
Filter = (msg, level) => level > LogLevel.Debug,
SourceName = "GitLooker"
};
var provider = new EventLogLoggerProvider(eventSetting);
return new LoggerFactory(new[] { provider });
})
.AddLogging()
.AddSingleton(typeof(ILogger <>), typeof(Logger <>))
.AddSingleton <IGitValidator, GitValidator>()
.AddTransient <IProcessShell, ProcessShell>()
.AddTransient <IRepoCommandProcessor, RepoCommandProcessor>()
.AddTransient <RepoCommandProcessorController>()
.AddTransient <SemaphoreInteractionInterceptor>()
.AddTransient <TabReposControl>()
.AddTransient(service =>
{
var myInterceptedClass = service.GetService <RepoCommandProcessorController>();
var interceptor = service.GetService <SemaphoreInteractionInterceptor>();
var proxy = new ProxyGenerator();
return proxy.CreateInterfaceProxyWithTargetInterface <IRepoCommandProcessorController>(myInterceptedClass, interceptor);
})
.AddTransient <RepoControl>());
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args).
ConfigureLogging((hostingContext, logBuilder) =>
{
logBuilder.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logBuilder.ClearProviders();
logBuilder.AddConsole();
logBuilder.AddTraceSource("Information, ActivityTracing");
// because framework is not using settings from appsettings.json
var eventLogSettings = new EventLogSettings()
{
SourceName = hostingContext.Configuration["Logging:EventLog:SourceName"],
LogName = hostingContext.Configuration["Logging:EventLog:LogName"],
MachineName = hostingContext.Configuration["Logging:EventLog:MachineName"]
};
logBuilder.AddEventLog(eventLogSettings);
})
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup <Startup>();
webBuilder.ConfigureKestrel(options => options.AddServerHeader = false);
});
/// <summary>
/// Get IDs of entities tenant admins have requested security checks be traced for.
/// </summary>
/// <returns>
/// Entity IDs.
/// </returns>
private static ISet <long> GetInspectingEntitiesImpl(long tenantId)
{
EventLogSettings eventLogSettings = null;
ISet <long> result;
using (new SecurityBypassContext( ))
{
try
{
eventLogSettings = Entity.Get <EventLogSettings>(EventLogSettingsAlias,
new IEntityRef [] { EventLogSettings.InspectSecurityChecksOnResource_Field });
result = new HashSet <long>(eventLogSettings.InspectSecurityChecksOnResource.Select(e => e.Id));
}
catch (Exception ex)
{
EventLog.Application.WriteWarning("Event Log settings instance missing: " + ex);
result = new HashSet <long>( );
}
}
return(result);
}
private static void Main(string[] args)
{
bool isService = !(Debugger.IsAttached || args.Contains("--console"));
var builder = new HostBuilder()
.ConfigureHostConfiguration(config =>
{
config.AddEnvironmentVariables();
})
.ConfigureAppConfiguration((hostContext, config) =>
{
config.AddJsonFile("appsettings.json", optional: false);
config.AddJsonFile($"appsettings.{hostContext.HostingEnvironment.EnvironmentName}.json", optional: true);
config.AddEnvironmentVariables();
})
.ConfigureLogging((hostContext, loggingBuilder) =>
{
loggingBuilder.AddDebug();
loggingBuilder.AddConsole();
loggingBuilder.AddLog4Net();
var settings = new EventLogSettings
{
SourceName = "WindowsServiceExample",
Filter = (source, level) => level >= LogLevel.Information
};
loggingBuilder.AddEventLog(settings);
})
.ConfigureServices((hostContext, services) =>
{
services.AddLib();
services.AddHostedService <MessageReceiverService>();
});
RunAsync(builder, isService).GetAwaiter().GetResult();
}
/// <summary>
/// Initializes a new instance of the <see cref="EventLogLoggerProvider"/> class.
/// </summary>
/// <param name="settings">The <see cref="EventLogSettings"/>.</param>
public EventLogLoggerProvider(EventLogSettings settings)
{
_settings = settings;
}
/// <summary>
/// Logs to the named event log
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="logName">The named log to write to.</param>
/// <returns>The updated settings.</returns>
public static EventLogSettings LogTo(this EventLogSettings settings, string logName)
{
settings.LogName = logName;
return(settings);
}
/// <summary>
/// Manage logs for the named machine
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="machineName">The machine name to manage logs for.</param>
/// <returns>The updated settings.</returns>
public static EventLogSettings ForMachine(this EventLogSettings settings, string machineName)
{
settings.MachineName = machineName;
return(settings);
}
/// <summary>
/// Logs using the specified source name
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="sourceName">The source name to use for events.</param>
/// <returns>The updated settings.</returns>
public static EventLogSettings WithSourceName(this EventLogSettings settings, string sourceName)
{
settings.SourceName = sourceName;
return(settings);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
app.UseHsts();
}
app.UseStatusCodePagesWithReExecute("/error/{0}");//
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseAuthentication();//
app.UseCookiePolicy();
//loggerFactory.AddConsole(Configuration.GetSection("Logging"));
//loggerFactory.AddDebug();
//loggerFactory.AddNLog();
//loggerFactory.MinimumLevel = LogLevel.Debug;
//var settings = new EventLogSettings
//{
// SourceName = "SoftCRPWeb",
// LogName="SoftCRPWeb",
// Filter = (source, level) => level >= LogLevel.Information
//};
//loggerFactory.AddEventLog(settings);
//loggerFactory.AddEventSourceLogger();
//loggerFactory.AddEventLog(LogLevel.Error);
string _sourceName = "PlataformaClientes"; //source program name
string _logName = ""; //new event log or targeted event log name
////if custom event log does not exist, create it
//if (!EventLog.SourceExists(_logName))
//{
// //event log creates new app log and associates program, "My Program", with new log, "My Event Log"
// EventLog.CreateEventSource(_sourceName, _logName);
//}
//////IS ok
EventLogSettings myEventLogSettings = new EventLogSettings
{
SourceName = _sourceName,
LogName = _logName,
Filter = (source, level) => level >= LogLevel.Error
};
loggerFactory.AddEventLog(myEventLogSettings);
ILogger logger = loggerFactory.CreateLogger <Startup>();
//logger.LogCritical(1000, "Iniciando..."); //ok
//logger.LogInformation(1001, "Iniciando...");
//SI VALE
//logger.LogError("Logs de Errores Iniciados");
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Account}/{action=Login}/{id?}");
});
}
