public static void LogToDb()
{
DatabaseTarget dbTarget = new DatabaseTarget
{
Name = "db",
ConnectionString = ConnectionString
};
dbTarget.Parameters.Add(new DatabaseParameterInfo("@message"
, new NLog.Layouts.SimpleLayout("${message}")));
dbTarget.CommandText = string.Format("INSERT INTO ApplicationLogs(Message, RegisteredDate) " +
"VALUES (@message, GETDATE());");
// Keep original configuration
LoggingConfiguration config = LogManager.Configuration;
if (config == null)
{
config = new LoggingConfiguration();
}
config.AddTarget(dbTarget.Name, dbTarget);
LoggingRule rule = new LoggingRule("*", LogLevel.Warn, dbTarget);
config.LoggingRules.Add(rule);
LogManager.Configuration = config;
CreateLogTableIfNotExists(dbTarget, ConnectionString);
}
/// <summary>
/// 指定された構成情報を利用してインスタンスを初期化します。
/// </summary>
/// <param name="config">構成情報</param>
public NLogAdapter(LogConfiguration config)
{
this.config = config;
var nlogConfig = new LoggingConfiguration();
foreach (var pattern in config.LogSettings)
{
if (pattern.Resource.Type == "file")
{
var target = new FileTarget();
target.Name = pattern.Resource.Name;
target.Layout = pattern.Resource.Format;
target.FileName = pattern.Resource.FileName;
target.ArchiveEvery = FileArchivePeriod.Day;
target.Encoding = System.Text.Encoding.UTF8;
nlogConfig.AddTarget(target.Name, target);
nlogConfig.LoggingRules.Add(new LoggingRule(pattern.Resource.Name, GetLogLevel(pattern), target));
}
if (pattern.Resource.Type == "db")
{
var target = new DatabaseTarget();
target.Name = pattern.Resource.Name;
target.ConnectionString = pattern.Resource.Connection;
nlogConfig.AddTarget(target.Name, target);
nlogConfig.LoggingRules.Add(new LoggingRule(pattern.Resource.Name, GetLogLevel(pattern), target));
}
}
LogManager.Configuration = nlogConfig;
}
public static void InitLogManager(bool forceInit = false)
{
if (!_init || forceInit)
{
string nlogConfigPath = Path.Combine(SpiderEnviroment.BaseDirectory, "nlog.config");
if (!File.Exists(nlogConfigPath))
{
File.AppendAllText(nlogConfigPath, Resource.nlog);
}
XmlLoggingConfiguration configuration = new XmlLoggingConfiguration(nlogConfigPath);
var connectString = Configuration.GetValue("logAndStatusConnectString");
var logAndStatusTargets = configuration.AllTargets.Where(t => t.Name == "dblog" || t.Name == "dbstatus").ToList();
if (!string.IsNullOrEmpty(connectString))
{
foreach (var logAndStatusTarget in logAndStatusTargets)
{
DatabaseTarget dbTarget = (DatabaseTarget)logAndStatusTarget;
dbTarget.ConnectionString = connectString;
}
}
var needDeleteRules = configuration.LoggingRules.Where(r => r.Targets.Any(t => t is DatabaseTarget && ((DatabaseTarget)t).ConnectionString == null)).ToList();
foreach (var rule in needDeleteRules)
{
configuration.LoggingRules.Remove(rule);
}
configuration.Install(new InstallationContext());
LogManager.Configuration = configuration;
_init = true;
}
}
public static void InitLogCenter()
{
#if !NET_CORE
string nlogConfigPath = Path.Combine(Environment.BaseDirectory, "nlog.net45.config");
#else
string nlogConfigPath = Path.Combine(Environment.BaseDirectory, "nlog.config");
#endif
if (!File.Exists(nlogConfigPath))
{
File.AppendAllText(nlogConfigPath, GetDefaultConfigString());
}
XmlLoggingConfiguration configuration = new XmlLoggingConfiguration(nlogConfigPath);
if (Environment.SystemConnectionStringSettings == null)
{
var needDeleteRules = configuration.LoggingRules.Where(r => r.Targets.Any(t => t is DatabaseTarget && ((DatabaseTarget)t).ConnectionString == null)).ToList();
foreach (var rule in needDeleteRules)
{
configuration.LoggingRules.Remove(rule);
}
configuration.RemoveTarget("dblog");
}
else
{
var dblog = configuration.AllTargets.FirstOrDefault(t => t.Name == "dblog");
if (dblog != null)
{
DatabaseTarget dbTarget = (DatabaseTarget)dblog;
dbTarget.ConnectionString = Environment.SystemConnectionStringSettings.ConnectionString;
}
}
configuration.Install(new InstallationContext());
LogManager.Configuration = configuration;
}
private void ConfigLogger(string connectionString)
{
if (LogManager.Configuration != null)
{
return;
}
var config = new LoggingConfiguration();
var dbTarget = new DatabaseTarget("database");
config.AddTarget("database", dbTarget);
config.Variables["userId"] = "";
config.Variables["callsite"] = "";
config.Variables["logtype"] = "";
dbTarget.ConnectionString = connectionString;
dbTarget.CommandText = @"insert into dbo.Logs ([CallSite],[Level],[Type],[Message],[Exception],[PersianDate],[UserId]) values (@callSite,@level,@logtype,@message,@exception,@persiandate,@userid)";
dbTarget.Parameters.Add(new DatabaseParameterInfo("@callSite", "${var:callsite"));
dbTarget.Parameters.Add(new DatabaseParameterInfo("@level", "${level}"));
dbTarget.Parameters.Add(new DatabaseParameterInfo("@logtype", "${var:logtype"));
dbTarget.Parameters.Add(new DatabaseParameterInfo("@message", "${message}"));
dbTarget.Parameters.Add(new DatabaseParameterInfo("@exception", "${exception:format=ShortType,Message,StackTrace:innerFormat=ShortType,Message,StackTrace:maxInnerExceptionLevel=10:separator= -> "));
dbTarget.Parameters.Add(new DatabaseParameterInfo("@persiandate", "${date:format=yyyy-MM-dd HH\\:mm\\:ss:culture=fa-IR}"));
dbTarget.Parameters.Add(new DatabaseParameterInfo("@userid", "${var:userId}"));
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, dbTarget));
LogManager.Configuration = config;
LogManager.KeepVariablesOnReload = true;
}
private void btnInfo_Click(object sender, EventArgs e)
{
List <string> lst = new List <string>();
Event eventFilter = new Event();
try
{
_loger.Information("Fwk Loggin test", "Mensaje de prueba para Fwk Loggin");
System.Configuration.ConnectionStringSettings cnn = System.Configuration.ConfigurationManager.ConnectionStrings[_LoggingSection.GetProvider().CnnStringName];
if (cnn == null)
{
throw new Exception("no existe la ConnectionString " + _LoggingSection.GetProvider().CnnStringName + " configurada en el config file para EventType.Information");
}
ITarget t = DatabaseTarget.TargetFactory(TargetType.Database, cnn.Name);
_loger.Information("test logging", "Informe de error");
//eventFilter.LogType = EventType.Information;
//t.SearchByParam(eventFilter);
//foreach (Event wEvent in t.SearchByParam(eventFilter))
//{
// lst.Add(wEvent.Id.ToString());
//}
//t.Remove(lst);
//eventFilter.LogType = EventType.None;
txtNoStaticResult.Text = t.SearchByParam(eventFilter).GetXml();
}
catch (Exception ex)
{
ExceptionView.Show(ex);
}
}
public void ConnectionStringBuilderTest1()
{
DatabaseTarget dt;
dt = new DatabaseTarget();
Assert.AreEqual("Server=.;Trusted_Connection=SSPI;", this.GetConnectionString(dt));
dt = new DatabaseTarget();
dt.DBHost = "${logger}";
Assert.AreEqual("Server=Logger1;Trusted_Connection=SSPI;", this.GetConnectionString(dt));
dt = new DatabaseTarget();
dt.DBHost = "HOST1";
dt.DBDatabase = "${logger}";
Assert.AreEqual("Server=HOST1;Trusted_Connection=SSPI;Database=Logger1", this.GetConnectionString(dt));
dt = new DatabaseTarget();
dt.DBHost = "HOST1";
dt.DBDatabase = "${logger}";
dt.DBUserName = "******";
dt.DBPassword = "******";
Assert.AreEqual("Server=HOST1;User id=user1;Password=password1;Database=Logger1", this.GetConnectionString(dt));
dt = new DatabaseTarget();
dt.ConnectionString = "customConnectionString42";
dt.DBHost = "HOST1";
dt.DBDatabase = "${logger}";
dt.DBUserName = "******";
dt.DBPassword = "******";
Assert.AreEqual("customConnectionString42", this.GetConnectionString(dt));
}
public static LoggingConfiguration BuildDatabaseConfiguration(string connectionString)
{
var config = new LoggingConfiguration();
var targetName = "database";
var databaseTarget = new DatabaseTarget(targetName)
{
DBProvider = "sqlserver",
ConnectionString = connectionString,
CommandText = @"
insert into dbo.Log (MachineName, Logged, Level, Message, Logger, Callsite, Exception)
values (@MachineName, @Logged, @Level, @Message, @Logger, '', @Exception);",
Parameters =
{
new DatabaseParameterInfo("@MachineName", "${machinename}"),
new DatabaseParameterInfo("@Logged", "${date}"),
new DatabaseParameterInfo("@Level", "${level}"),
new DatabaseParameterInfo("@Message", "${message}"),
new DatabaseParameterInfo("@Logger", "${Logger}"),
new DatabaseParameterInfo("@Exception", "${exception:tostring}"),
}
};
config.AddTarget(databaseTarget);
config.AddRule(NLog.LogLevel.Info, NLog.LogLevel.Fatal, targetName);
return(config);
}
static LogCenter()
{
string nlogConfigPath = Path.Combine(Environment.BaseDirectory, "nlog.config");
if (!File.Exists(nlogConfigPath))
{
File.AppendAllText(nlogConfigPath, NlogDefaultConfig);
}
XmlLoggingConfiguration configuration = new XmlLoggingConfiguration(nlogConfigPath);
var connectString = Config.GetValue("connectString");
var logAndStatusTargets = configuration.AllTargets.Where(t => t.Name == "dblog" || t.Name == "dbstatus").ToList();
if (!string.IsNullOrEmpty(connectString))
{
foreach (var logAndStatusTarget in logAndStatusTargets)
{
DatabaseTarget dbTarget = (DatabaseTarget)logAndStatusTarget;
dbTarget.ConnectionString = connectString;
}
}
else
{
var needDeleteRules = configuration.LoggingRules.Where(r => r.Targets.Any(t => t is DatabaseTarget && ((DatabaseTarget)t).ConnectionString == null)).ToList();
foreach (var rule in needDeleteRules)
{
configuration.LoggingRules.Remove(rule);
}
configuration.RemoveTarget("dblog");
configuration.RemoveTarget("dbstatus");
}
configuration.Install(new InstallationContext());
LogManager.Configuration = configuration;
}
private void SetConfiguration(string conn, LogLevel logLevel)
{
var configuration = new LoggingConfiguration();
var dbTarget = new DatabaseTarget
{
Name = LoggerConstants.TargetName,
ConnectionString = conn,
DBProvider = LoggerConstants.DbProvider,
CommandText = @"INSERT INTO [dbo].[Logs] (Id, TimeStamp, Message, Level, Exception, Logger, AdditionalData, AdditionalIdentifier)
VALUES (NEWID(), @timeStamp, @message, @level, @exception, @logger, @additionalData, @additionalIdentifier)",
Parameters =
{
new DatabaseParameterInfo("@timeStamp", "${date}"),
new DatabaseParameterInfo("@message", "${message}"),
new DatabaseParameterInfo("@level", "${level}"),
new DatabaseParameterInfo("@exception", "${exception}"),
new DatabaseParameterInfo("@logger", "${logger}"),
new DatabaseParameterInfo("@additionalData", $"${{event-properties:item={LoggerConstants.AdditionalDataPropertyKey}}}"),
new DatabaseParameterInfo("@additionalIdentifier", $"${{event-properties:item={LoggerConstants.AdditionalIdPropertyKey}}}")
}
};
configuration.AddTarget(dbTarget);
configuration.LoggingRules.Add(new LoggingRule("*", logLevel, dbTarget));
LogManager.Configuration = configuration;
}
public DatabaseTarget GetNLogDatabaseTarget()
{
DatabaseTarget dbTarget = new DatabaseTarget();
//foreach (var par in dbTarget.Parameters)
AddParameter(dbTarget, "LogDate", @"${date:format=yyyy-MM-dd HH\:mm\:ss.fff}");
AddParameter(dbTarget, "Level", @"${level}");
AddParameter(dbTarget, "Stage", @"${etllog:LogType=Stage}");
AddParameter(dbTarget, "Message", @"${etllog}");
AddParameter(dbTarget, "Type", @"${etllog:LogType=Type}");
AddParameter(dbTarget, "Action", @"${etllog:LogType=Action}");
AddParameter(dbTarget, "Hash", @"${etllog:LogType=Hash}");
AddParameter(dbTarget, "LoadProcessKey", @"${etllog:LogType=LoadProcessKey}");
AddParameter(dbTarget, "Logger", @"${logger}");
dbTarget.CommandText = new NLog.Layouts.SimpleLayout(CommandText);
if (ConnectionType == ConnectionManagerType.Postgres)
{
dbTarget.DBProvider = "Npgsql.NpgsqlConnection, Npgsql";
}
else if (ConnectionType == ConnectionManagerType.MySql)
{
dbTarget.DBProvider = "MySql.Data.MySqlClient.MySqlConnection, MySql.Data";
}
else if (ConnectionType == ConnectionManagerType.SQLite)
{
dbTarget.DBProvider = "System.Data.SQLite.SQLiteConnection, System.Data.SQLite";
}
else
{
dbTarget.DBProvider = "Microsoft.Data.SqlClient.SqlConnection, Microsoft.Data.SqlClient";
}
dbTarget.ConnectionString = ConnectionManager.ConnectionString.Value;
return(dbTarget);
}
private ServiceProvider CreateServiceProvider(DatabaseTarget target, bool useExternalMigrations = false, bool addDatabaseDeleter = true)
{
var services = new ServiceCollection();
if (target == DatabaseTarget.ImMemory)
{
services.AddDbContext <TestContext>(builder =>
builder.UseInMemoryDatabase("UnitTest")
.ConfigureWarnings(options => options.Ignore(InMemoryEventId.TransactionIgnoredWarning))
.UseDataMigrations(p => p.MigrationAssembly = useExternalMigrations ? "Extensions.EntityFrameworkCore.Migrations" : null)
);
}
else
{
services.AddDbContext <TestContext>(builder =>
builder.UseSqlServer($"Data Source=(localdb)\\mssqllocaldb; Integrated Security=true; Initial Catalog={DatabaseId:N}")
.UseDataMigrations(p => p.MigrationAssembly = useExternalMigrations ? "Extensions.EntityFrameworkCore.Migrations" : null)
);
}
if (addDatabaseDeleter)
{
services.AddSingleton <DropDatabase <TestContext> >();
}
var result = services.BuildServiceProvider();
if (addDatabaseDeleter)
{
result.GetRequiredService <DropDatabase <TestContext> >();
}
return(result);
}
private DatabaseTarget GetDataBaseTarget()
{
var isAudit = _type == LogType.SQL ? true : false;
DatabaseTarget target = new DatabaseTarget();
target.DBProvider = "mssql";
target.ConnectionString = MZHelperConfiguration.MZConnectionString;
target.CommandText = isAudit ? MZConsts.MZLogger.LoggerDataBaseInsertAudit : MZConsts.MZLogger.LoggerDataBaseInsertGeneric;
target.Name = MZConsts.MZLogger.LoggerDataBaseTargetName;
if (isAudit)
{
target.Parameters.Add(GetParameter("@action", "${gdc:Action}"));
target.Parameters.Add(GetParameter("@data", "${gdc:Data}"));
target.Parameters.Add(GetParameter("@tableName", "${gdc:TableName}"));
target.Parameters.Add(GetParameter("@tableIdValue", "${gdc:TableIdValue}"));
target.Parameters.Add(GetParameter("@userId", "${gdc:UserId}"));
target.Parameters.Add(GetParameter("@originalvalues", "${gdc:OriginalValues}"));
target.Parameters.Add(GetParameter("@serializedoriginalobject", "${gdc:SerializedOriginalObject}"));
target.Parameters.Add(GetParameter("@newvalues", "${gdc:NewValues}"));
target.Parameters.Add(GetParameter("@serializednewobject", "${gdc:SerializedNewObject}"));
target.Parameters.Add(GetParameter("@alllog", "${message}"));
}
else
{
target.Parameters.Add(GetParameter("@logtype", "${gdc:LogType}"));
target.Parameters.Add(GetParameter("@logvalue", "${gdc:LogValue}"));
}
return(target);
}
public static void ConfigureLog(string dbHost, string dbName, string dbUser, string dbPassword, bool debug = false)
{
var config = new LoggingConfiguration();
var dbTarget = new DatabaseTarget();
dbTarget.ConnectionString = "Data Source=" + dbHost + ";Initial Catalog=" + dbName + ";Persist Security Info=True;User ID=" + dbUser + ";Password="******"INSERT INTO ExceptionLog ([TimeStamp], [Level], [Logger], [Message], [Exception], [StackTrace], [Request], [Arguments]) VALUES (@TimeStamp, @Level, @Logger, @Message, @Exception, @StackTrace, @request, @arguments);";
dbTarget.Parameters.Add(new DatabaseParameterInfo("@TimeStamp", new NLog.Layouts.SimpleLayout("${date}")));
dbTarget.Parameters.Add(new DatabaseParameterInfo("@Level", new NLog.Layouts.SimpleLayout("${level}")));
dbTarget.Parameters.Add(new DatabaseParameterInfo("@Logger", new NLog.Layouts.SimpleLayout("${logger}")));
dbTarget.Parameters.Add(new DatabaseParameterInfo("@Message", new NLog.Layouts.SimpleLayout("${message}")));
dbTarget.Parameters.Add(new DatabaseParameterInfo("@Exception", new NLog.Layouts.SimpleLayout("${exception}")));
dbTarget.Parameters.Add(new DatabaseParameterInfo("@StackTrace", new NLog.Layouts.SimpleLayout("${stacktrace}")));
dbTarget.Parameters.Add(new DatabaseParameterInfo("@Request", new NLog.Layouts.SimpleLayout("${mdc:item=request}")));
dbTarget.Parameters.Add(new DatabaseParameterInfo("@Arguments", new NLog.Layouts.SimpleLayout("${mdc:item=arguments}")));
config.AddTarget("database", dbTarget);
var dbRule = new LoggingRule("*", LogLevel.Debug, dbTarget);
config.LoggingRules.Add(dbRule);
LogManager.Configuration = config;
if (debug)
{
InternalLogger.LogLevel = LogLevel.Trace;
InternalLogger.LogToConsole = true;
InternalLogger.LogToConsoleError = true;
InternalLogger.LogToTrace = true;
}
}
public static LoggingConfiguration CreateForDatabase(string connectionString, LogLevel logLevel)
{
var config = new LoggingConfiguration();
var target = new DatabaseTarget
{
Name = "db",
ConnectionString = connectionString,
CommandText = "insert into [Log] ([Timestamp], [Level], [Logger], [Message], [Callsite], [Exception], [UserName], [Method], [Url], [RemoteAddress], [LocalAddress]) " +
"values (@Timestamp, @Level, @Logger, @Message, @Callsite, @Exception, @UserName, @Method, @Url, @RemoteAddress, @LocalAddress)",
Parameters =
{
new DatabaseParameterInfo("@Timestamp", "${date:universalTime=true}"),
new DatabaseParameterInfo("@Level", "${level}"),
new DatabaseParameterInfo("@Logger", "${logger}"),
new DatabaseParameterInfo("@Message", "${message}"),
new DatabaseParameterInfo("@Callsite", "${callsite}"),
new DatabaseParameterInfo("@Exception", "${exception:format=tostring:maxInnerExceptionLevel=2}"),
new DatabaseParameterInfo("@UserName", "${aspnet-User-Identity}"),
new DatabaseParameterInfo("@Method", "${aspnet-Request-Method}"),
new DatabaseParameterInfo("@Url", "${aspnet-Request:serverVariable=HTTP_URL}"),
new DatabaseParameterInfo("@RemoteAddress", "${aspnet-Request:serverVariable=REMOTE_ADDR}"),
new DatabaseParameterInfo("@LocalAddress", "${aspnet-Request:serverVariable=LOCAL_ADDR}")
}
};
config.AddTarget(target);
config.LoggingRules.Add(new LoggingRule("*", logLevel, target));
return(config);
}
/// <summary>
///
/// </summary>
/// <param name="providerElement"></param>
/// <returns></returns>
private Target GetTargetByProviderElement(LogProviderElement providerElement)
{
switch (providerElement.Target)
{
case TargetType.Database:
{
DatabaseTarget wDatabase = new DatabaseTarget();
wDatabase.CnnStringName = providerElement.CnnStringName;
return(wDatabase);
}
case TargetType.File:
{
FileTarget wFile = new FileTarget();
wFile.FileName = providerElement.FileName;
return(wFile);
}
case TargetType.WindowsEvent:
{
return(new WindowsEventTarget());
}
case TargetType.Xml:
{
XmlTarget wXml = new XmlTarget();
wXml.FileName = providerElement.FileName;
return(wXml);
}
}
return(null);
}
public void KeepConnectionOpenBatchedTest2()
{
MockDbConnection.ClearLog();
DatabaseTarget dt = new DatabaseTarget()
{
CommandText = "INSERT INTO FooBar VALUES('${message}')",
ConnectionString = "Database=${logger}",
DBProvider = typeof(MockDbConnection).AssemblyQualifiedName,
KeepConnection = true,
};
dt.Initialize(null);
Assert.Same(typeof(MockDbConnection), dt.ConnectionType);
// when we pass multiple log events in an array, the target will bucket-sort them by
// connection string and group all commands for the same connection string together
// to minimize number of db open/close operations
// in this case msg1, msg2 and msg4 will be written together to MyLogger database
// and msg3 will be written to MyLogger2 database
List <Exception> exceptions = new List <Exception>();
var events = new[]
{
new LogEventInfo(LogLevel.Info, "MyLogger", "msg1").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "MyLogger", "msg2").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "MyLogger2", "msg3").WithContinuation(exceptions.Add),
new LogEventInfo(LogLevel.Info, "MyLogger", "msg4").WithContinuation(exceptions.Add),
};
dt.WriteAsyncLogEvents(events);
foreach (var ex in exceptions)
{
Assert.Null(ex);
}
string expectedLog = @"Open('Database=MyLogger').
ExecuteNonQuery: INSERT INTO FooBar VALUES('msg1')
ExecuteNonQuery: INSERT INTO FooBar VALUES('msg2')
ExecuteNonQuery: INSERT INTO FooBar VALUES('msg4')
Close()
Dispose()
Open('Database=MyLogger2').
ExecuteNonQuery: INSERT INTO FooBar VALUES('msg3')
";
AssertLog(expectedLog);
MockDbConnection.ClearLog();
dt.Close();
expectedLog = @"Close()
Dispose()
";
AssertLog(expectedLog);
}
public void ProviderFactoryInitTest()
{
var dt = new DatabaseTarget();
dt.DBProvider = "MockDb";
dt.CommandText = "Notimportant";
dt.Initialize(null);
Assert.AreSame(MockDbFactory.Instance, dt.ProviderFactory);
dt.OpenConnection("myConnectionString");
Assert.AreEqual(1, MockDbConnection2.OpenCount);
Assert.AreEqual("myConnectionString", MockDbConnection2.LastOpenConnectionString);
}
public static LoggingConfiguration DatabaseLogConfiguration(LoggingConfiguration config, LogLevel level = null)
{
LoggingConfiguration logconfig = config;
var target = new DatabaseTarget
{
ConnectionStringName = "autoniseLogger",
DBProvider = "System.Data.SqlClient",
CommandType = CommandType.Text,
Parameters =
{
new DatabaseParameterInfo("@application",
"${appsetting:name=AppName:default=Unknown\\: set AppName in appSettings}"),
new DatabaseParameterInfo("@logged", "${date}"),
new DatabaseParameterInfo("@level", "${level}"),
new DatabaseParameterInfo("@message", "${message}"),
new DatabaseParameterInfo("@username", "${identity}"),
//new DatabaseParameterInfo("@serverName", "${aspnet-request:serverVariable=SERVER_NAME}"),
//new DatabaseParameterInfo("@port", "${aspnet-request:serverVariable=SERVER_PORT}"),
//new DatabaseParameterInfo("@url", "${aspnet-request:serverVariable=HTTP_URL}"),
//new DatabaseParameterInfo("@https",
// "${when:inner=1:when='${aspnet-request:serverVariable=HTTPS}' == 'on'}${when:inner=0:when='${aspnet- request:serverVariable=HTTPS}' != 'on'}"),
//new DatabaseParameterInfo("@serverAddress", "${aspnet-request:serverVariable=LOCAL_ADDR}"),
//new DatabaseParameterInfo("@remoteAddress",
// "${aspnet-request:serverVariable=REMOTE_ADDR}:${aspnet-request:serverVariable=REMOTE_PORT}"),
new DatabaseParameterInfo("@serverName", ""),
new DatabaseParameterInfo("@port", ""),
new DatabaseParameterInfo("@url", ""),
new DatabaseParameterInfo("@https",
""),
new DatabaseParameterInfo("@serverAddress", ""),
new DatabaseParameterInfo("@remoteAddress",
""),
new DatabaseParameterInfo("@logger", "${logger}"),
new DatabaseParameterInfo("@callSite", "${callsite}"),
new DatabaseParameterInfo("@exception", "${exception:tostring}"),
},
CommandText = "insert into dbo.Log (Application, Logged, Level, Message,Username,ServerName," +
" Port, Url, Https,ServerAddress, RemoteAddress," +
"Logger, CallSite, Exception) " +
"values (@Application, @Logged, @Level, @Message,@Username,@ServerName, @Port, @Url," +
" @Https,@ServerAddress, @RemoteAddress," + "@Logger, @Callsite, @Exception);"
};
logconfig.LoggingRules.Add(new LoggingRule("*", level ?? LogLevel.Info, target));
//if (Debugger.IsAttached)
//{
// logconfig = ConsoleLogConfiguration(logconfig);
//}
return(logconfig);
}
public void TestNLogToDatabaseSucceeds()
{
InternalLogger.LogToConsole = true;
InternalLogger.LogToTrace = true;
InternalLogger.LogLevel = LogLevel.Trace;
var config = new LoggingConfiguration();
var target = new DatabaseTarget()
{
Name = "d",
ConnectionString = "Data Source=LAPTOP-6EA15661\\SQLEXPRESS;Initial Catalog=Logging;Integrated Security=True",
CommandText = "WriteLog",
CommandType = System.Data.CommandType.StoredProcedure
};
target.Parameters.Add(new DatabaseParameterInfo()
{
Name = "@SeverityLevel",
Layout = new NLog.Layouts.SimpleLayout("${level}")
});
target.Parameters.Add(new DatabaseParameterInfo()
{
Name = "@Source",
Layout = new NLog.Layouts.SimpleLayout("${logger}")
});
target.Parameters.Add(new DatabaseParameterInfo()
{
Name = "@Message",
Layout = new NLog.Layouts.SimpleLayout("${message}")
});
target.Parameters.Add(new DatabaseParameterInfo()
{
Name = "@LogId",
Layout = new NLog.Layouts.SimpleLayout("${..}")
});
NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Trace);
config.AddTarget(target);
var rule = new LoggingRule("*", LogLevel.Trace, target);
config.LoggingRules.Add(rule);
LogManager.Configuration = config;
var logger = LogManager.GetCurrentClassLogger();
logger.Log(LogLevel.Info, "Hello there");
logger.Log(LogLevel.Error, new Exception("Hi, I'm an exception"));
}
public void OdbcShorthandNotationTest()
{
var dt = new DatabaseTarget()
{
Name = "myTarget",
DBProvider = "odbc",
ConnectionString = "notimportant",
CommandText = "notimportant",
};
dt.Initialize(null);
Assert.AreEqual(typeof(System.Data.Odbc.OdbcConnection), dt.ConnectionType);
}
/// <summary>
/// Sets the log target.
/// </summary>
/// <param name="connectionString">The connection string.</param>
/// <param name="internalLogging">if set to <c>true</c> [internal logging].</param>
public static void SetLogTarget(string connectionString, bool internalLogging = false)
{
try
{
string tableName = "ErrorLog";
string nLogQuery = $"INSERT INTO {tableName} ([ApplicationCode],[ComponentStatus],[ErrorCode],[Exception],[LogFile],[Identity],[LogDate],[Logger],[Message],[MessageData],[Method],[Severity],[StackTrace]) " +
$" VALUES (@ApplicationCode, @ComponentStatus, @ErrorCode, @Exception, @LogFile, @Identity, @LogDate, @Logger, @Message, @MessageData, @Method, @Severity, @StackTrace)";
DatabaseTarget dbLog = new DatabaseTarget(Constants.NLOG_DB_CONFIG)
{
CommandText = nLogQuery,
CommandType = System.Data.CommandType.Text,
ConnectionString = connectionString
};
//dbLog.Parameters.Add(new DatabaseParameterInfo("@LogId", "${gdc:LogId}"));
dbLog.Parameters.Add(new DatabaseParameterInfo("@ApplicationCode", "${gdc:ApplicationCode}"));
dbLog.Parameters.Add(new DatabaseParameterInfo("@ComponentStatus", "${gdc:ComponentStatus}"));
dbLog.Parameters.Add(new DatabaseParameterInfo("@ErrorCode", "${gdc:ErrorCode}"));
dbLog.Parameters.Add(new DatabaseParameterInfo("@Exception", "${gdc:Exception}"));
dbLog.Parameters.Add(new DatabaseParameterInfo("@LogFile", "${gdc:LogFile}"));
dbLog.Parameters.Add(new DatabaseParameterInfo("@Identity", "${gdc:Identity}"));
dbLog.Parameters.Add(new DatabaseParameterInfo("@LogDate", "${gdc:LogDate}"));
dbLog.Parameters.Add(new DatabaseParameterInfo("@Logger", "${gdc:Logger}"));
dbLog.Parameters.Add(new DatabaseParameterInfo("@Message", "${gdc:Message}"));
dbLog.Parameters.Add(new DatabaseParameterInfo("@MessageData", "${gdc:MessageData}"));
dbLog.Parameters.Add(new DatabaseParameterInfo("@Method", "${gdc:Method}"));
dbLog.Parameters.Add(new DatabaseParameterInfo("@Severity", "${gdc:Severity}"));
dbLog.Parameters.Add(new DatabaseParameterInfo("@StackTrace", "${gdc:StackTrace}"));
LoggingConfiguration config = LogManager.Configuration;
if (config == null)
{
config = new LoggingConfiguration();
}
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, LogLevel.Fatal, dbLog));
if (internalLogging)
{
InternalLogger.LogFile = "nlog.txt";
InternalLogger.LogWriter = new StringWriter();
InternalLogger.LogLevel = LogLevel.Trace;
}
LogManager.Configuration = config;
}
catch (Exception ex)
{
}
}
public Configurer WithDatabaseTarget(string logTableName, string connectionString, bool async = true)
{
_ensureTableIsCreated(connectionString, logTableName);
var databaseTarget = new DatabaseTarget();
databaseTarget.DBProvider = "Microsoft.Data.SqlClient.SqlConnection, Microsoft.Data.SqlClient"; // see https://github.com/NLog/NLog/wiki/Database-target#microsoftdatasqlclient-and-net-core
databaseTarget.ConnectionString = connectionString;
databaseTarget.KeepConnection = true;
databaseTarget.CommandText = string.Format(@"
INSERT INTO[dbo].[{0}]
(
[TimestampUtc]
, [TimestampTz]
, [LogLevel]
, [Logger]
, [Callsite]
, [AppName]
, [RequestID]
, [Host]
, [Message]
, [ExceptionMessage]
)
VALUES
(
@TimestampUtc
, @TimestampTz
, @LogLevel
, @Logger
, @Callsite
, @AppName
, TRY_CONVERT(UNIQUEIDENTIFIER, @RequestID)
, @Host
, @Message
, @ExceptionMessage
)
", logTableName);
databaseTarget.Parameters.Add(new DatabaseParameterInfo("TimestampUtc", @"${date:universalTime=true}"));
databaseTarget.Parameters.Add(new DatabaseParameterInfo("TimestampTz", @"${date:format=dd-MMM-yyyy h\:mm\:ss.fff tt K}"));
databaseTarget.Parameters.Add(new DatabaseParameterInfo("LogLevel", @"${level:uppercase=true}"));
databaseTarget.Parameters.Add(new DatabaseParameterInfo("Logger", @"${logger}"));
databaseTarget.Parameters.Add(new DatabaseParameterInfo("Callsite", @"${when:when=level>=LogLevel.Error:inner=${callsite:filename=true}}"));
databaseTarget.Parameters.Add(new DatabaseParameterInfo("AppName", _appName));
databaseTarget.Parameters.Add(new DatabaseParameterInfo("RequestID", @"${mdlc:item=RequestID}"));
databaseTarget.Parameters.Add(new DatabaseParameterInfo("Host", @"${machinename}"));
databaseTarget.Parameters.Add(new DatabaseParameterInfo("Message", @"${message}"));
databaseTarget.Parameters.Add(new DatabaseParameterInfo("ExceptionMessage", @"${onexception:${exception:format=ToString}}"));
_config.AddTarget(DatabaseTarget, async ? _wrapWithAsyncTargetWrapper(databaseTarget) as Target : databaseTarget);
return(this);
}
private string GetConnectionString(DatabaseTarget dt)
{
MockDbConnection.ClearLog();
dt.DBProvider = typeof(MockDbConnection).AssemblyQualifiedName;
dt.CommandText = "NotImportant";
var exceptions = new List <Exception>();
dt.Initialize(null);
dt.WriteAsyncLogEvent(new LogEventInfo(LogLevel.Info, "Logger1", "msg1").WithContinuation(exceptions.Add));
dt.Close();
return(MockDbConnection.LastConnectionString);
}
public AutomationLogging()
{
string resultFolder = @"C:/WDTF/TestResult";
string asm = Assembly.GetCallingAssembly().FullName;
string logFormat = string.Format("{0:yyyy-MM-dd-hh-mm-ss}", DateTime.Now);
newLocationInResultFolder = resultFolder + "/" + currentGuid + "_" + logFormat;
DirectoryInfo directoryInfo = new DirectoryInfo(newLocationInResultFolder);
if (!directoryInfo.Exists)
{
System.IO.Directory.CreateDirectory(newLocationInResultFolder);
}
var config = new LoggingConfiguration();
//===========================================================================================//
var consoleTarget = new ColoredConsoleTarget();
consoleTarget.Layout = "${time} | ${level} | ${stacktrace::topFrames=2}|${message} ";
config.AddTarget("console", consoleTarget);
LoggingRule consoleInfo = new LoggingRule("*", LogLevel.Debug, consoleTarget);
config.LoggingRules.Add(consoleInfo);
//===========================================================================================//
var fileTarget = new FileTarget();
fileTarget.Layout = "${time} | ${level} | ${stacktrace:topFrames=2} | ${message} ";
fileTarget.FileName = newLocationInResultFolder + "/" + className + "_" + logFormat + DateTime.Now.Second + ".log";
config.AddTarget("file", fileTarget);
var fileInfo = new LoggingRule("*", LogLevel.Debug, fileTarget);
config.LoggingRules.Add(fileInfo);
//===========================================================================================//
TraceTarget traceTarget = new TraceTarget();
traceTarget.Layout = "${time} | ${level} | ${stacktrace:topFrames=2} | ${message} ";
//===========================================================================================//
//===========================================================================================//
DatabaseTarget dbTarget = new DatabaseTarget();
//===========================================================================================//
// Step 4. Define rules
LogManager.Configuration = config;
Console.WriteLine(logger.IsDebugEnabled);
}
// TODO: it seems like it cant do console and file logging at the same time?
public static void LogInit()
{
// TODO: move this config somewhere better and pass in the params
if (ConfigurationManager.AppSettings["LogDatabase"].Equals("true", StringComparison.OrdinalIgnoreCase))
{
DatabaseTarget target = new DatabaseTarget();
DatabaseParameterInfo param;
target.ConnectionString = ConfigurationManager.ConnectionStrings["Log"].ConnectionString;
target.CommandText = "insert into Log(timestamp,loglevel,logger,message) values(@time_stamp, @level, @logger, @message);";
param = new DatabaseParameterInfo();
param.Name = "@time_stamp";
param.Layout = "${date}";
target.Parameters.Add(param);
param = new DatabaseParameterInfo();
param.Name = "@level";
param.Layout = "${level}";
target.Parameters.Add(param);
param = new DatabaseParameterInfo();
param.Name = "@logger";
param.Layout = "${logger}";
target.Parameters.Add(param);
param = new DatabaseParameterInfo();
param.Name = "@message";
param.Layout = "${message}";
target.Parameters.Add(param);
NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target);
}
if (ConfigurationManager.AppSettings["LogConsole"].Equals("true", StringComparison.OrdinalIgnoreCase))
{
var console = new ColoredConsoleTarget();
console.Layout = "${logger} \t ${message}";
NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(console, LogLevel.Trace);
}
if (ConfigurationManager.AppSettings["LogFile"].Equals("true", StringComparison.OrdinalIgnoreCase))
{
var file = new FileTarget();
file.FileName = "testlog.log";
file.Layout = "${logger} \t ${message}";
NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(file, LogLevel.Trace);
}
}
public static void AddDatabase(this LoggingConfiguration config, LogLevel min, LogLevel max, string ConnString)
{
var t = new DatabaseTarget
{
KeepConnection = true,
DBProvider = "sqlserver",
ConnectionString = ConnString,
CommandText = @"EXEC [dbo].[p_error_log]
@Logger = '${logger}',
@Message = '${message}-${exception:format=tostring}' " ,
};
config.AddTarget("database", t);
config.LoggingRules.Add(new LoggingRule("*", min, max, t));
}
private static void BootstrapNLog()
{
GlobalDiagnosticsContext.Set("ServiceInstanceId", Guid.NewGuid().ToString("N"));
var config = new LoggingConfiguration();
var colorConsoleTarget = new ColoredConsoleTarget()
{
Name = "colorConsole"
};
config.AddTarget("colorConsole", colorConsoleTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, colorConsoleTarget));
var databaseTarget = new DatabaseTarget()
{
ConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString,
CommandText = "INSERT INTO EventLog (Logger, [TimeStamp], Level, ServiceInstanceId, JobId, Message, Exception, StackTrace) " +
"VALUES (@logger, @timeStamp, @level, @serviceinstanceid, @jobid, " +
"CASE WHEN LEN(@message) > 4000 THEN LEFT(@message, 3988) + '[truncated]' ELSE @message END," +
"CASE WHEN LEN(@exception) > 4000 THEN LEFT(@exception, 3988) + '[truncated]' ELSE @exception END," +
"CASE WHEN LEN(@stacktrace) > 4000 THEN LEFT(@stacktrace, 3988) + '[truncated]' ELSE @stacktrace END" +
")",
Parameters =
{
new DatabaseParameterInfo("@logger", new SimpleLayout("${logger}")),
new DatabaseParameterInfo("@timestamp", new SimpleLayout("${date}")),
new DatabaseParameterInfo("@level", new SimpleLayout("${level}")),
new DatabaseParameterInfo("@serviceinstanceid", new SimpleLayout("${gdc:item=ServiceInstanceId}")),
new DatabaseParameterInfo("@jobid", new SimpleLayout("${mdc:item=JobId}")),
new DatabaseParameterInfo("@message", new SimpleLayout("${message}")),
new DatabaseParameterInfo("@exception", new SimpleLayout("${exception}")),
new DatabaseParameterInfo("@stacktrace", new SimpleLayout("${exception:stacktrace}")),
}
};
config.AddTarget("database", databaseTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, databaseTarget));
var slackTarget = new SlackTarget()
{
ChannelUrl = "https://hooks.slack.com/services/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", MessagePrefix = Environment.MachineName
};
config.AddTarget("slack", slackTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Warn, slackTarget));
LogManager.Configuration = config;
}
public void KeepConnectionOpenTest2()
{
MockDbConnection.ClearLog();
DatabaseTarget dt = new DatabaseTarget()
{
CommandText = "INSERT INTO FooBar VALUES('${message}')",
ConnectionString = "Database=${logger}",
DBProvider = typeof(MockDbConnection).AssemblyQualifiedName,
KeepConnection = true,
};
dt.Initialize(null);
Assert.Same(typeof(MockDbConnection), dt.ConnectionType);
List <Exception> exceptions = new List <Exception>();
dt.WriteAsyncLogEvent(new LogEventInfo(LogLevel.Info, "MyLogger", "msg1").WithContinuation(exceptions.Add));
dt.WriteAsyncLogEvent(new LogEventInfo(LogLevel.Info, "MyLogger", "msg2").WithContinuation(exceptions.Add));
dt.WriteAsyncLogEvent(new LogEventInfo(LogLevel.Info, "MyLogger2", "msg3").WithContinuation(exceptions.Add));
dt.WriteAsyncLogEvent(new LogEventInfo(LogLevel.Info, "MyLogger", "msg4").WithContinuation(exceptions.Add));
foreach (var ex in exceptions)
{
Assert.Null(ex);
}
string expectedLog = @"Open('Database=MyLogger').
ExecuteNonQuery: INSERT INTO FooBar VALUES('msg1')
ExecuteNonQuery: INSERT INTO FooBar VALUES('msg2')
Close()
Dispose()
Open('Database=MyLogger2').
ExecuteNonQuery: INSERT INTO FooBar VALUES('msg3')
Close()
Dispose()
Open('Database=MyLogger').
ExecuteNonQuery: INSERT INTO FooBar VALUES('msg4')
";
AssertLog(expectedLog);
MockDbConnection.ClearLog();
dt.Close();
expectedLog = @"Close()
Dispose()
";
AssertLog(expectedLog);
}
public void SqlServerShorthandNotationTest()
{
foreach (string provName in new[] { "microsoft", "msde", "mssql", "sqlserver" })
{
var dt = new DatabaseTarget()
{
Name = "myTarget",
DBProvider = provName,
ConnectionString = "notimportant",
CommandText = "notimportant",
};
dt.Initialize(null);
Assert.AreEqual(typeof(System.Data.SqlClient.SqlConnection), dt.ConnectionType);
}
}
