protected static void TestLogger(Action <ILogger, Func <List <string> > > act)
{
// These layout renderers need to registered statically as ultimately ConfigurationItemFactory.Default is called in the call stack.
LayoutRenderer.Register <ApmTraceIdLayoutRenderer>(ApmTraceIdLayoutRenderer.Name); //generic
LayoutRenderer.Register <ApmTransactionIdLayoutRenderer>(ApmTransactionIdLayoutRenderer.Name); //generic
var logFactory = new LogFactory();
var logConfig = new Config.LoggingConfiguration(logFactory);
var ecsLayout = new EcsLayout();
ecsLayout.ExcludeProperties.Add("NotX");
var memoryTarget = new MemoryTarget {
Layout = ecsLayout, OptimizeBufferReuse = true
};
logConfig.AddRule(LogLevel.Trace, LogLevel.Fatal, memoryTarget);
logConfig.DefaultCultureInfo = System.Globalization.CultureInfo.InvariantCulture;
logFactory.Configuration = logConfig;
List <string> GetLogEvents() => memoryTarget.Logs.ToList();
var logger = logFactory.GetCurrentClassLogger();
act(logger, GetLogEvents);
}
///// <summary>
/////
///// </summary>
//public IContainer AutofacContainer;
///// <summary>
///// ϵͳµ÷ÓÃ
///// </summary>
///// <param name="builder"></param>
//public void ConfigureContainer(ContainerBuilder builder)
//{
// builder.RegisterModule<CustomAutofacModule>();
//}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
LayoutRenderer.Register("basedir", p => env.ContentRootPath);
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseMiddleware <SeoMiddleware>();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapDefaultControllerRoute();
endpoints.MapBlazorHub();
endpoints.MapFallbackToPage("/_Host");
});
}
public static void Initialise()
{
LayoutRenderer.Register <PrettyExceptionLayoutRenderer>("pretty-exception");
LayoutRenderer.Register("linefeed", _ => '\n'); // Workaround for newline using Environment.NewLine.
var config = new LoggingConfiguration();
var fileTarget = new FileTarget
{
Name = "file",
FileName = "${basedir}/WebSiteAdvantage.KeePass.Firefox.log",
LineEnding = LineEndingMode.LF,
Encoding = Encoding.UTF8,
Layout = @"${date:format=yyyy-MM-ddTHH\:mm\:ss,fffK} - [${level:uppercase=true}] ${logger}: ${message}${onexception:${linefeed}${pretty-exception}}",
KeepFileOpen = true,
ConcurrentWrites = false,
OpenFileCacheTimeout = 20
};
var bufferedFileTarget = new BufferingTargetWrapper(fileTarget, 5);
config.AddTarget("buffFile", bufferedFileTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, bufferedFileTarget));
LogManager.Configuration = config;
}
public static void Main(string[] args)
{
LayoutRenderer.Register("user-domain", (logEvent) => Environment.UserDomainName);
LayoutRenderer.Register("user-name", (logEvent) => Environment.UserName);
LayoutRenderer.Register("os-version", (logEvent) => Environment.OSVersion);
LayoutRenderer.Register("current-directory", (logEvent) => Environment.CurrentDirectory);
LayoutRenderer.Register("custom-shortdate", (logEvent) => DateTime.Now.ToString("yyyyMMdd"));
LayoutRenderer.Register("application-name", (logEvent) => Assembly.GetExecutingAssembly().FullName);
var logger = NLog.Web.NLogBuilder.ConfigureNLog("NLog.config").GetCurrentClassLogger();
try
{
//CreateWebHostBuilder(args).Build().Run();
var host = BuildWebHost(args);
host.Run();
}
catch (Exception ex)
{
logger.Error(ex, "Programa parado por causa de uma exception.");
throw;
}
finally
{
NLog.LogManager.Shutdown();
}
}
public static void Main(string[] args)
{
LayoutRenderer.Register <UserIdLayoutRenderer>("user-id");
NLog.Logger logger = NLog.Web.NLogBuilder.ConfigureNLog("nlog.config").GetCurrentClassLogger();
try
{
logger.Debug("init main");
IHost host = CreateHostBuilder(args).Build();
host.RunIdentityMigrations();
host.SeedSystemEntities();
host.SeedIdentityAdmin("admin", "Password");
logger.Debug("run host");
host.Run();
}
catch (Exception exception)
{
logger.Error(exception, "Stopped program because of exception");
throw;
}
finally
{
NLog.LogManager.Shutdown();
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseCors("EnableCORS");
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "Retrospectives API V1");
});
//map basedir from NLog.config file to root path of application folder
LayoutRenderer.Register("basedir", (logEvent) => env.ContentRootPath);
}
public static void Main(string[] args)
{
LayoutRenderer.Register <ExceptionLayoutRenderer>("appy-exception");
LayoutRenderer.Register <CorrelationIdLayoutRenderer>("correlationid");
var url = ConfigurationManager.AppSettings["server.url"];
var gitRepoPath = ConfigurationManager.AppSettings["git.repository.path"];
var remoteUrl = ConfigurationManager.AppSettings["remote.url"];
var userName = ConfigurationManager.AppSettings["remote.user.name"];
var userEmail = ConfigurationManager.AppSettings["remote.user.email"];
var password = ConfigurationManager.AppSettings["remote.user.password"];
if (!int.TryParse(ConfigurationManager.AppSettings["transactions.timeout"], out int transactionTimeout))
{
transactionTimeout = 10;
}
var app = App.Create(url, new LocalGitDb(gitRepoPath, remoteUrl, userName, userEmail, password, transactionTimeout), new List <User>
{
new User {
UserName = "******", Password = ConfigurationManager.AppSettings["GitAdmin"], Roles = new [] { "admin", "read", "write" }
},
new User {
UserName = "******", Password = ConfigurationManager.AppSettings["GitAdmin"], Roles = new [] { "read" }
},
new User {
UserName = "******", Password = ConfigurationManager.AppSettings["GitWriter"], Roles = new [] { "write" }
}
});
using (app.Start())
{
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
public void OnHasActivityStarted()
{
// Arrange
System.Diagnostics.Activity.Current = null;
LayoutRenderer.Register("activity", typeof(ActivityTraceLayoutRenderer));
LayoutRenderer.Register("onhasactivity", typeof(OnHasActivityTraceLayoutRendererWrapper));
var logFactory = new LogFactory();
var logConfig = new LoggingConfiguration(logFactory);
var memTarget = new NLog.Targets.MemoryTarget("memory");
logConfig.AddRuleForAllLevels(memTarget);
memTarget.Layout = "${message} ${onhasactivity:inner=${activity:operationName}}";
logFactory.Configuration = logConfig;
var logger = logFactory.GetLogger(nameof(OnHasActivityNotActive));
// Act
var activity = new System.Diagnostics.Activity("World");
try
{
activity.Start();
logger.Info("Hello");
// Assert
Assert.NotNull(System.Diagnostics.Activity.Current);
Assert.Single(memTarget.Logs);
Assert.Equal("Hello World", memTarget.Logs[0]);
}
finally
{
activity.Stop();
}
}
/// <summary>
/// 添加NLog日志
/// </summary>
/// <param name="register"></param>
public static IServiceCollection AddNLog(this IServiceCollection services, NLogAspNetCoreOptions options, bool clearProviders = true)
{
services.AddLogging(builder =>
{
if (clearProviders)
{
builder.ClearProviders();
}
builder.SetMinimumLevel(LogLevel.Trace);
});
options = options ?? NLogAspNetCoreOptions.Default;
services.AddSingleton <ILoggerProvider>(serviceProvider =>
{
serviceProvider.SetupNLogServiceLocator();
if (options.RegisterHttpContextAccessor)
{
LayoutRenderer.Register <WebInfoLayoutRenderer>("webinfo");
WebInfoLayoutRenderer.httpContextAccessor = serviceProvider.GetService <IHttpContextAccessor>();
}
return(new NLogLoggerProvider(options));
});
if (options.RegisterHttpContextAccessor)
{
services.TryAddSingleton <IHttpContextAccessor, HttpContextAccessor>();
}
return(services);
}
public static void Main(string[] args)
{
var h = new WebHostBuilder();
var environment = h.GetSetting("environment");
var builder = new ConfigurationBuilder()
.AddJsonFile("appSettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appSettings.{environment}.json", optional: true)
.AddEnvironmentVariables();
configuration = builder.Build();
LayoutRenderer.Register("NLogConnectionString", (logEvent) => configuration.GetValue <string>("NLog:NLogConnectionString"));
LayoutRenderer.Register("NlogDB", (logEvent) => configuration.GetValue <string>("NLog:NLogDB"));
// NLog: Database for logging
EnsureDB();
// NLog: setup the logger first to catch all errors
var logger = NLogBuilder.ConfigureNLog("nlog.config").GetCurrentClassLogger();
try
{
logger.Debug("init main");
BuildWebHost(args).Run();
}
catch (Exception e)
{
//NLog: catch setup errors
logger.Error(e, "Stopped program because of exception");
throw;
}
}
static NLogConfigrationProvider()
{
var traceId = TraceIdContext.Current?.TraceId ?? "traceId"; //初始化TraceId
LayoutRenderer.Register("traceid", (logEvent) => traceId);
LayoutRenderer.Register("MyDateTime", (logEvent) => DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"));//初始化日期格式
}
static void Main()
{
LayoutRenderer.Register <ProcessStartTimeLayoutRenderer>("process_start_time");
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new TrayForm());
}
public static IHost BuildHost(string[] args)
{
return(Host.CreateDefaultBuilder(args)
.ConfigureLogging(logging => logging.ClearProviders())
.ConfigureWebHostDefaults(webBuilder => webBuilder
.UseNLog()
.ConfigureAppConfiguration((context, configuration) =>
{
LayoutRenderer.Register <TenantLayoutRenderer>(TenantLayoutRenderer.LayoutRendererName);
var logConfigPath = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == Environments.Development
? "NLog.dev.config"
: "NLog.config";
var environment = context.HostingEnvironment;
environment.ConfigureNLog(logConfigPath);
LogManager.Configuration.Variables["configDir"] = environment.ContentRootPath;
})
.ConfigureKestrel(options => options.AddServerHeader = false)
//todo: remove theme's we don't need
// .UseSetting(WebHostDefaults.HostingStartupExcludeAssembliesKey,
//"TheComingSoonTheme;TheBlogTheme;TheTheme")
// "{TheComingSoonTheme;TheBlogTheme;TheTheme}")
// "TheComingSoonTheme, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null")
.UseStartup <Startup>())
.Build());
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory)
{
loggerFactory.AddNLog();
LayoutRenderer.Register("basedir", (logEvent) => env.ContentRootPath);
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseCors();
app.UseHttpsRedirection();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
});
ConfigureEventBus(app);
}
/// <summary>
/// Initializes the log manager.
/// </summary>
public static void Initialize()
{
LayoutRenderer.Register <AudioBandExceptionLayoutRenderer>("audioband-exception");
var configFileFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var config = new XmlLoggingConfiguration(Path.Combine(configFileFolder, "nlog.config"));
LogFactory.Configuration = config;
}
/// <summary>
/// 注册NLog日志操作
/// </summary>
/// <param name="services">服务集合</param>
public static void AddNLog(this IServiceCollection services)
{
LayoutRenderer.Register <NLogLayoutRenderer>("log");
services.TryAddScoped <ILogProviderFactory, YF.Logs.NLog.LogProviderFactory>();
services.TryAddSingleton <ILogFormat, ContentFormat>();
services.TryAddScoped <ILogContext, LogContext>();
services.TryAddScoped <ILog, Log>();
}
public static void Main(string[] arguments)
{
LayoutRenderer.Register("appData", _ => AppData.GetFolder());
App app = new App();
app.InitializeComponent();
app.Run();
}
void FuncLayoutRendererRegisterTest1()
{
LayoutRenderer.Register("the-answer", (info) => "42");
Layout l = "${the-answer}";
var result = l.Render(LogEventInfo.CreateNullEvent());
Assert.Equal("42", result);
}
void FuncLayoutRendererRegisterTest2()
{
LayoutRenderer.Register("message-length", (info) => info.Message.Length);
Layout l = "${message-length}";
var result = l.Render(LogEventInfo.Create(LogLevel.Error, "logger-adhoc", "1234567890"));
Assert.Equal("10", result);
}
public static IApplicationBuilder UseNLogWeb(this IApplicationBuilder app, ILoggerFactory loggerFactory)
{
LayoutRenderer.Register <TenantLayoutRenderer>(TenantLayoutRenderer.LayoutRendererName);
loggerFactory.AddNLog();
app.AddNLogWeb();
return(app);
}
private static void InitializeNLog()
{
// LogManager.ThrowExceptions = true;
// LogManager.ThrowConfigExceptions = true;
LayoutRenderer.Register("unixtimestamp", (logEvent) => (long)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalMilliseconds);
LogManager.Configuration = LogManager.Configuration.Reload();
LogManager.ReconfigExistingLoggers();
}
public LoggerServiceBase(string name)
{
LayoutRenderer.Register <MethodNameLayout>("method-name");
LayoutRenderer.Register <ClaimLayout>("claim");
LayoutRenderer.Register <ConnectionStringLayout>("nlog-connection-string");
logger = NLogBuilder.ConfigureNLog("nlog.config").GetLogger(name);
}
public static void Main()
{
NLog.Config.ConfigurationItemFactory.Default = new NLog.Config.ConfigurationItemFactory(typeof(NLog.ILogger).GetTypeInfo().Assembly);
LayoutRenderer.Register <Int32HexLayoutRenderer>("int32hex");
Directory.SetCurrentDirectory(Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName));
CreateWebHostBuilder().Build().Run();
NLog.LogManager.Flush();
NLog.LogManager.Shutdown();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IServiceProvider serviceProvider, ILoggerFactory loggerFactory)
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
loggerFactory.AddNLog();
app.UseSession();
app.AddNLogWeb();
//注册根目录地址
LayoutRenderer.Register("basedir", (logEvent) => env.ContentRootPath);
HttpContext.Configure(app.ApplicationServices.
GetRequiredService <Microsoft.AspNetCore.Http.IHttpContextAccessor>()
);
app.UseCookieAuthentication(new CookieAuthenticationOptions()
{
AuthenticationScheme = "SysManager",
LoginPath = "/SysManager/Account/Login",
LogoutPath = "/SysManager/Account/LoginOut",
AccessDeniedPath = "/SysManager/Account/Login",
AutomaticAuthenticate = true,
AutomaticChallenge = true,
CookieHttpOnly = true,
ExpireTimeSpan = new TimeSpan(0, 0, 30, 0),
CookiePath = "/"
});
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseWebpackDevMiddleware(new WebpackDevMiddlewareOptions
{
HotModuleReplacement = true
});
}
else
{
app.UseExceptionHandler("/Home/Error");
}
//
app.UseMiddleware <CaptchaMiddleware>();
app.UseWebSockets();
app.MapWebSocketManager("/LiveChat", serviceProvider.GetService <ChartHandler>());
app.UseStaticFiles();
//app.UseMiddleware<LoggerMiddleware>();
app.UseMvc(routes =>
{
routes.MapRoute("areaRoute", "{area:exists}/{controller=Home}/{action=Index}/{id?}");
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
routes.MapSpaFallbackRoute("spa-fallback", new { controller = "Home", action = "Index" });
});
}
public void SessionWithCulture()
{
LayoutRenderer.Register <AspNetSessionValueLayoutRenderer>("aspnet-session");
Layout layout = "${aspnet-session:a.b:culture=en-GB:evaluateAsNestedProperties=true}";
var o = new { b = new DateTime(2015, 11, 24, 2, 30, 23) };
//set in "a"
ExecTest("a", o, "24/11/2015 02:30:23", layout);
}
public static IApplicationBuilder UseNLogWeb(this IApplicationBuilder app, ILoggerFactory loggerFactory, IHostingEnvironment env)
{
LayoutRenderer.Register <TenantLayoutRenderer>(TenantLayoutRenderer.LayoutRendererName);
loggerFactory.AddNLog();
app.AddNLogWeb();
env.ConfigureNLog($"{env.ContentRootPath}{Path.DirectorySeparatorChar}NLog.config");
LogManager.Configuration.Variables["configDir"] = env.ContentRootPath;
return(app);
}
private static void ConfigureLogging(string configPath, ConfigurationRoot configurationRoot)
{
var assembly = Assembly.GetExecutingAssembly();
GlobalDiagnosticsContext.Set("Application", assembly.GetName().Name);
GlobalDiagnosticsContext.Set("Version", assembly.GetName().Version);
GlobalDiagnosticsContext.Set("LogPath", configurationRoot.Logging.LogPath);
LayoutRenderer.Register("context", _ => 1);
LogManager.Configuration = new XmlLoggingConfiguration(Path.Combine(configPath, "nlog.config"));
}
private static void ConfigureLogging(WebHostBuilderContext hostingContext, ILoggingBuilder loggingBuilder)
{
loggingBuilder.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
loggingBuilder.AddConsole();
loggingBuilder.AddDebug();
LayoutRenderer.Register("basedir", (logEvent) => hostingContext.HostingEnvironment.ContentRootPath);
LayoutRenderer.Register <AspNetBuildDateLayoutRenderer>("custom-build-date");
LogHolder.Init(new NLogFactory());
}
public static IServiceCollection AddNlog(this IServiceCollection services, string configFile = "nlog.config")
{
//Config'den önce olmalıdır.
LayoutRenderer.Register <JsonLogDetailLayout>("json-log-detail");
var rootPath = AppContext.BaseDirectory;
var configPath = Path.Combine(rootPath, configFile);
var config = new XmlLoggingConfiguration(configPath);
var logger = NLog.LogManager.Configuration = config;
return(services);
}
internal NewRelicCsvLayout(Func <NewRelic.Api.Agent.IAgent> agentFactory) : base()
{
_nrAgent = new Lazy <NewRelic.Api.Agent.IAgent>(agentFactory);
LayoutRenderer.Register <UnixTimestampLayoutRenderer>(TimestampLayoutRendererName);
LayoutRenderer.Register <TraceDataLayoutRenderer>(TraceDataLayoutRendererName);
// add new relic version for mc donalds and hardcode it to nr1
// they insist.
Columns.Add(new CsvColumn("newrelic.version", "nr1"));
// Add Nr linking metadata
if (_nrAgent.Value != null)
{
try
{
var metadata = _nrAgent.Value.GetLinkingMetadata();
if (metadata != null)
{
foreach (var pair in metadata)
{
Columns.Add(new CsvColumn(pair.Key, "${" + TraceDataLayoutRendererName + ":metaproperty=" + pair.Key + "}"));
}
}
}
catch (Exception ex)
{
InternalLogger.Error(ex, "Exception caught in NewRelicCsvLayout");
}
}
//var traceMetadata = _nrAgent.Value.TraceMetadata;
// If transaction is not started, the column header will not contain the traceid and spanid
// they are only available once transaction is started, hence adding coloumn
Columns.Add(new CsvColumn(TRACEID, "${" + TraceDataLayoutRendererName + ":metaproperty=" + TRACEID + "}"));
Columns.Add(new CsvColumn(SPANID, "${" + TraceDataLayoutRendererName + ":metaproperty=" + SPANID + "}"));
Columns.Add(new CsvColumn(NewRelicLoggingProperty.Timestamp.GetOutputName(), "${" + TimestampLayoutRendererName + "}"));
Columns.Add(new CsvColumn(NewRelicLoggingProperty.LogLevel.GetOutputName(), "${level:upperCase=true}"));
Columns.Add(new CsvColumn(NewRelicLoggingProperty.MessageText.GetOutputName(), "${message}"));
Columns.Add(new CsvColumn(NewRelicLoggingProperty.MessageTemplate.GetOutputName(), "${message:raw=true}"));
// correlation
Columns.Add(new CsvColumn(NewRelicLoggingProperty.ThreadId.GetOutputName(), "${threadid}"));
Columns.Add(new CsvColumn(NewRelicLoggingProperty.CorrelationId.GetOutputName(), "${ActivityId}"));
Columns.Add(new CsvColumn(NewRelicLoggingProperty.ProcessId.GetOutputName(), "${processid}"));
// exceptions
Columns.Add(new CsvColumn(NewRelicLoggingProperty.ErrorClass.GetOutputName(), "${exception:format=Type}"));
Columns.Add(new CsvColumn(NewRelicLoggingProperty.ErrorMessage.GetOutputName(), "${exception:format=Message}"));
Columns.Add(new CsvColumn(NewRelicLoggingProperty.ErrorStack.GetOutputName(), "${exception:format=StackTrace}"));
}
