public void SqlLoggerInvalidConnectionStringProcedure()
{
DateTime testStart = DateTime.Now;
Log.DefaultMemoryLogger.ValidLevels = LogLevels.All;
// Create a new SQL logger
SqlLogger sqlLogger = new SqlLogger("Test SQL Logger", Guid.NewGuid(), ConnectionStringInvalid);
// Add the SQL logger
Log.GetOrAddLogger(sqlLogger);
AddTestLogItems(testStart);
Thread.Sleep(15000);
// Now retrieve the logs.
IEnumerable <Log> logs = Log.GetForward(testStart, 10);
Assert.IsTrue(
logs.Any(l => l.Level == LogLevel.Critical) &&
logs.Any(
l =>
l.Level == LogLevel.Information && l.ExceptionType != null &&
l.ExceptionType.Equals("System.Data.SqlClient.SqlException")));
}
public override DataTable GetDataTable(string Sql)
{
try
{
SqlLogger.WriteSql(Sql);
MySqlDataAdapter adapter = new MySqlDataAdapter(Sql, conn);
DataSet ds = new DataSet();
conn.Open();
ds.EnforceConstraints = false;
adapter.FillSchema(ds, SchemaType.Source, "table");
adapter.Fill(ds, "table");
conn.Close();
return(ds.Tables[0]);
}
catch (Exception ex)
{
throw ex;
}
finally
{
conn.Close();
}
}
internal ITransaction GetTransactionRepository()
{
ITransaction result = null;
switch (_config.LoggerType)
{
case LoggingTypeModel.LogOutputType.TextFile:
result = new TextLogger
{
LogOutputFileLocation = _config.Text.FileInformation.LogFileLocation,
LogOutputFileName = _config.Text.FileInformation.LogFileName
};
break;
case LoggingTypeModel.LogOutputType.SQL:
result = new SqlLogger();
break;
case LoggingTypeModel.LogOutputType.SQLite:
result = new SqliteLogger();
break;
default:
throw new ArgumentOutOfRangeException();
}
return(result);
}
public override int ExecuteSql(string sql, QueryParameterCollection parameters = null)
{
lock (this) // although sqlite3 is thread-safe, we need to make sure that the last_insert_rowid is correct
{
var stopwatch = SqlLogger != null?Stopwatch.StartNew() : null;
var stmt = CreateCommand(sql, parameters);
try
{
int returnCode = SQLitePCL.raw.sqlite3_step(stmt);
if (returnCode == SQLitePCL.raw.SQLITE_ROW)
{
return(0); // quietly eat any rows being returned
}
if (returnCode != SQLitePCL.raw.SQLITE_DONE)
{
throw new SqliteException((SqliteReturnCode)returnCode, (SqliteExtendedErrorCode)SQLitePCL.raw.sqlite3_extended_errcode(DbHandle), SQLitePCL.raw.sqlite3_errmsg(DbHandle).utf8_to_string());
}
_lastRowId.Value = SQLitePCL.raw.sqlite3_last_insert_rowid(DbHandle);
return(SQLitePCL.raw.sqlite3_changes(DbHandle));
}
finally
{
SQLitePCL.raw.sqlite3_finalize(stmt);
SqlLogger?.LogSql(sql, parameters?.ToDictionary(p => SqlDialect.CreateParameterExpression(p.Name), p => p.Value), stopwatch?.Elapsed ?? TimeSpan.Zero);
}
}
}
public static void Update <T>(this ISqlConnectionProvider sqlConnectionProvider,
T objectToUpdate,
Expression <Func <T, object> > keyProperties = null,
string tableName = null,
string schemaName = null,
bool processColumnNames = true)
{
tableName = SqlTextFunctions.GetTableName(objectToUpdate.GetType(), tableName, schemaName);
using (var myConnection = sqlConnectionProvider.ToSqlConnection())
{
using (var myCommand = new SqlCommand {
Connection = myConnection
})
{
var setClauseProperties = SqlClrHelpers.GetRelevantPropertyInfos(objectToUpdate, null);
var whereClauseProperties = SqlClrHelpers.GetPropertiesFromObject(objectToUpdate, keyProperties);
SqlTextFunctions.UnUnderscoreColumnNames = processColumnNames;
BuildOutUpdateCommand(objectToUpdate,
tableName,
setClauseProperties,
whereClauseProperties,
myCommand,
processColumnNames);
SqlTextFunctions.UnUnderscoreColumnNames = true;
myConnection.Open();
SqlLogger.LogSqlCommand(myCommand);
myCommand.ExecuteNonQuery();
myConnection.Close();
}
}
}
private static SqlLogger Init()
{
var logger = new SqlLogger();
var evidence = AppDomain.CurrentDomain.Evidence;
//CallContext.LogicalSetData(ContextName, logger);
return logger;
}
public SqlLogger Init()
{
var logger = new SqlLogger();
#if K10
_logger.Value = logger;
#else
CallContext.LogicalSetData(ContextName, logger);
#endif
return logger;
}
private static SqlLogger Init()
{
var logger = new SqlLogger();
#if DNXCORE50
_logger.Value = logger;
#else
CallContext.LogicalSetData(ContextName, logger);
#endif
return logger;
}
private static SqlLogger Init()
{
var logger = new SqlLogger();
var evidence = AppDomain.CurrentDomain.Evidence;
//CallContext.LogicalSetData(ContextName, logger);
return(logger);
}
private static SqlLogger Init()
{
var logger = new SqlLogger();
#if DNXCORE50
_logger.Value = logger;
#else
CallContext.LogicalSetData(ContextName, logger);
#endif
return(logger);
}
public override object ExecuteDataReader(string Sql)
{
SqlLogger.WriteSql(Sql);
MySqlCommand cmd = conn.CreateCommand();
cmd.CommandText = Sql;
conn.Open();
//cmd.ExecuteNonQuery();
return(cmd.ExecuteReader());
}
public SqlLogger Init()
{
var logger = new SqlLogger();
#if ASPNETCORE50
_logger.Value = logger;
#else
CallContext.LogicalSetData(ContextName, logger);
#endif
return(logger);
}
private static void DemoSqlLogger()
{
Console.Write("using file logger ... ");
var logger = new SqlLogger();
logger.Log("test entry 1");
logger.Log("test entry 2", LogLevel.Verbose);
logger.Log("test entry 3", LogLevel.Verbose, "example category");
Console.WriteLine("log saved to database");
}
public void SqlLoggerInvalidGetStoredProcedure()
{
DateTime testStart = DateTime.Now;
Log.DefaultMemoryLogger.ValidLevels = LogLevels.All;
// Create a new SQL logger
SqlLogger sqlLogger = new SqlLogger(
"Test SQL Logger", Guid.NewGuid(), ConnectionString, getStoredProcedure: Guid.NewGuid().ToString());
// Add the SQL logger
Log.GetOrAddLogger(sqlLogger);
AddTestLogItems(testStart);
}
public ExecutionContext Prepare(string sql, ParameterContext parameterContext)
{
var cloneParameterContext = CloneParameters(parameterContext);
var routeContext = ExecuteRoute(sql, cloneParameterContext);
ExecutionContext result = new ExecutionContext(routeContext.GetSqlCommandContext());
var executionUnits = ExecuteRewrite(sql, cloneParameterContext, routeContext);
result.GetExecutionUnits().AddAll(executionUnits);
if (true)
{
SqlLogger.LogSql(sql, false, result.GetSqlCommandContext(), result.GetExecutionUnits());
}
return(result);
}
public static IEnumerable <T> MyQuery <T>(this ISqlConnectionProvider sqlConnectionProvider,
string whereClause = null,
string tableName = null,
string schemaName = null)
{
whereClause = whereClause ?? "1 = 1";
var selectClause = GenerateSelectClause <T>();
tableName = SqlTextFunctions.GetTableName(typeof(T), tableName, schemaName);
var sqlStatement = $"SELECT {selectClause} FROM {tableName} WHERE {whereClause}";
SqlLogger.LogSqlStatement(sqlStatement);
var results = sqlConnectionProvider.Query <T>(sqlStatement).ToList();
return(results);
}
public void Dispose_100VariousLogsRaised_NoExceptionsThrown()
{
// Arrange
var logger = new SqlLogger(new AzureLoggerSettingsConfiguration(), new NullCorrelationIdHelper());
for (int i = 0; i < 100; i++)
{
switch (i % 5)
{
case 0:
logger.LogDebug(string.Format("Test run index {0}", i), metaData: new Dictionary <string, object> {
{ "accountId", i }
});
break;
case 1:
logger.LogError(string.Format("Test run index {0}", i), metaData: new Dictionary <string, object> {
{ "teamId", i }
});
break;
case 2:
logger.LogFatalError(string.Format("Test run index {0}", i), metaData: new Dictionary <string, object> {
{ "userId", i }
});
break;
case 3:
logger.LogInfo(string.Format("Test run index {0}", i), metaData: new Dictionary <string, object> {
{ "companyId", i }
});
break;
case 4:
logger.LogError(string.Format("Test run index {0}", i), metaData: new Dictionary <string, object> {
{ "jobId", i }
});
break;
}
}
// Act
logger.Dispose();
// Assert
// No exception thrown
}
public override IEnumerable <Dictionary <string, object> > ExecuteSqlReader(string sql, QueryParameterCollection parameters)
{
var stopwatch = SqlLogger != null?Stopwatch.StartNew() : null;
try
{
BeginTransaction(IsolationLevel.None);
List <Dictionary <string, object> > records = new List <Dictionary <string, object> >();
using (var cmd = CreateCommand(sql, parameters, CommandType.Text))
{
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
Dictionary <string, object> rec = new Dictionary <string, object>();
for (int i = 0; i < reader.FieldCount; i++)
{
string fieldName = reader.GetName(i);
if (reader.IsDBNull(i))
{
rec[fieldName] = null;
}
else
{
rec[fieldName] = reader.GetValue(i);
}
}
records.Add(rec);
}
}
}
return(records);
}
finally
{
CommitTransaction();
SqlLogger?.LogSql(sql, parameters?.ToDictionary(p => SqlDialect.CreateParameterExpression(p.Name), p => p.Value), stopwatch?.Elapsed ?? TimeSpan.Zero);
}
}
internal ILogger GetLoggerRepository()
{
ILogger repo;
switch (_config.LoggerType)
{
case LoggingTypeModel.LogOutputType.TextFile:
var textOutput = new DirectoryInfo(_config.Text.FileInformation.LogFileLocation);
if (!textOutput.Exists)
{
textOutput.Create();
}
repo = new TextLogger
{
LogOutputFileLocation = _config.Text.FileInformation.LogFileLocation,
LogOutputFileName = _config.Text.FileInformation.LogFileName,
LoggingLevel = _config.LoggingLevel
};
break;
case LoggingTypeModel.LogOutputType.SQL:
repo = new SqlLogger()
{
LoggingLevel = _config.LoggingLevel
};
break;
case LoggingTypeModel.LogOutputType.SQLite:
var sqliteOutput = new DirectoryInfo(_config.SQLite.ServerInformation.LogFileLocation);
if (!sqliteOutput.Exists)
{
sqliteOutput.Create();
}
repo = new SqliteLogger()
{
LoggingLevel = _config.LoggingLevel
};
break;
default:
throw new ArgumentOutOfRangeException();
}
return(repo);
}
/// <summary>
/// Load global configurations.
/// </summary>
private static void Init()
{
Logger = new TraceListenerLogger();
// Load saved state
try
{
_singleInstance = AppSettings.Get <bool>(Constants.Settings.SingleInstance);
var sqlLogLevel = AppSettings.Get <bool>(Constants.Settings.SqlLoggingEnabled) ? LogLevel.All : LogLevel.None;
var sqlLogRetention = AppSettings.Get <int?>(Constants.Settings.SqlLoggingRetention);
var sqlLogDirectory = AppSettings.GetOrDefault(Constants.Settings.SqlLoggingDirectory, Path.GetFullPath(Path.Combine(DataDirectory, Constants.Defaults.SqlLoggingDirectory)));
SqlLogger = new SqlLogger(sqlLogDirectory, sqlLogRetention, sqlLogLevel);
}
catch (Exception e)
{
Logger.Warn($"Failed to apply AppSettings. Error: {e}");
}
}
public override int ExecuteProcedure(string procName, QueryParameterCollection parameters = null)
{
var stopwatch = SqlLogger != null?Stopwatch.StartNew() : null;
try
{
BeginTransaction(IsolationLevel.None);
using (var cmd = CreateCommand(procName, parameters, CommandType.StoredProcedure))
{
return(cmd.ExecuteNonQuery());
}
}
finally
{
CommitTransaction();
SqlLogger?.LogSql("EXEC " + procName, parameters?.ToDictionary(p => SqlDialect.CreateParameterExpression(p.Name), p => p.Value), stopwatch?.Elapsed ?? TimeSpan.Zero);
}
}
public override object Execute(string Sql)
{
Object lastInsertID = null;
try
{
if (Sql != "")
{
SqlLogger.WriteSql(Sql);
MySqlCommand cmd = conn.CreateCommand();
cmd.CommandText = Sql;
cmd.CommandTimeout = (this.CommandTimeOut != -1) ? this.CommandTimeOut : cmd.CommandTimeout;
conn.Open();
//cmd.ExecuteNonQuery();
lastInsertID = cmd.ExecuteScalar();
conn.Close();
}
}
catch (Exception ex)
{
if (ex.Message.Contains("foreign key constraint fails"))
{
throw new Exception("Kan niet verwijderen, want er zijn nog gerelateerde gegevens.", ex);
}
else if (ex.Message.Contains("Duplicate entry"))
{
throw new Exception("Kan niet opslaan, want een gegeven is niet uniek. Zie de volgende melding: " + ex.Message, ex);
}
throw ex;
}
finally
{
conn.Close();
}
if (lastInsertID != null && lastInsertID.ToString() == String.Empty)
{
lastInsertID = 0;
}
return(lastInsertID);
}
public void TestSqlLoggerMemoryCacheExpired()
{
DateTime testStart = DateTime.Now;
Log.DefaultMemoryLogger.ValidLevels = LogLevels.All;
// Create a new sql logger
SqlLogger sqlLogger = new SqlLogger("Test SQL Logger",
new Guid("E12A1F4A-6F69-4F35-B2A0-96B112C495D5"),
ConnectionString);
// Add the sql logger
Log.GetOrAddLogger(sqlLogger);
// Add the test log items
var testLogItems = AddTestLogItemsWrapper(testStart);
Thread.Sleep(2100000);
// Force an immediate GC of all generations.
GC.Collect(0, GCCollectionMode.Forced);
GC.Collect(1, GCCollectionMode.Forced);
GC.Collect(2, GCCollectionMode.Forced);
// Give the GC 120s econds (just to be safe).
Thread.Sleep(120000);
IEnumerable <Log> logs = Log.GetForward(sqlLogger, testStart, 10);
//foreach (string expectedOutput in testLogItems.Select(test => test.ExpectedOutput))
//{
// string output = expectedOutput;
// Assert.IsTrue(logs.Any(l => l.Operation.Name == OPERATION_NAME
// && l.Operation.CategoryName == OPERATION_CATEGORY_NAME
// && l.Operation.Parent != null
// && l.Operation.Parent.Name == OPERATION_NAME_WRAPPER
// && l.Message.Equals(output)));
//}
}
public static void Delete <T>(this ISqlConnectionProvider sqlConnectionProvider, T objToDelete,
Expression <Func <T, object> > keyProperties = null, string tableName = null, string schemaName = null, bool processColumnNames = true)
{
tableName = SqlTextFunctions.GetTableName(objToDelete.GetType(), tableName, schemaName);
using (var myConnection = sqlConnectionProvider.ToSqlConnection())
{
using (var myCommand = new SqlCommand()
{
Connection = myConnection
})
{
SqlTextFunctions.UnUnderscoreColumnNames = processColumnNames;
BuildOutMyCommand(objToDelete, keyProperties, tableName, myCommand);
SqlTextFunctions.UnUnderscoreColumnNames = true;
myConnection.Open();
SqlLogger.LogSqlStatement(myCommand.CommandText);
myCommand.ExecuteNonQuery();
myConnection.Close();
}
}
}
public void TestSqlLogger()
{
DateTime testStart = DateTime.Now;
Log.DefaultMemoryLogger.ValidLevels = LogLevels.All;
// Create a new SQL logger
SqlLogger sqlLogger = new SqlLogger("Test SQL Logger",
new Guid("E12A1F4A-6F69-4F35-B2A0-96B112C495D5"),
ConnectionString);
// Add the SQL logger
Log.GetOrAddLogger(sqlLogger);
// Every 500ms log some items.
int x = 0;
while (x < 50)
{
AddTestLogItemsWrapper(testStart);
x++;
Thread.Sleep(500);
}
// TODO: Retrieve and check we havent added the latest every time.
//foreach (string expectedOutput in testLogItems.Select(test => test.ExpectedOutput))
//{
// string output = expectedOutput;
// Assert.IsTrue(logs.Any(l => l.Operation.Name == OPERATION_NAME
// && l.Operation.CategoryName == OPERATION_CATEGORY_NAME
// && l.Operation.Parent != null
// && l.Operation.Parent.Name == OPERATION_NAME_WRAPPER
// && l.Message.Equals(output)));
//}
}
public static void Insert(this ISqlConnectionProvider sqlConnectionProvider,
object obj,
string tableName = null,
string schemaName = null,
IEnumerable <string> columnsToIgnore = null,
bool processColumnNames = true,
bool useIdentityInsert = false)
{
tableName = SqlTextFunctions.GetTableName(obj.GetType(), tableName, schemaName);
var propertyInfos = SqlClrHelpers.GetRelevantPropertyInfos(obj, columnsToIgnore);
if (propertyInfos.Count == 0)
{
return;
}
using (var myConnection = sqlConnectionProvider.GetSqlConnectionWithTimeout(60))
{
using (var myCommand = new SqlCommand {
Connection = myConnection
})
{
SqlTextFunctions.UnUnderscoreColumnNames = processColumnNames;
BuildOutMyCommand(obj, tableName, propertyInfos, myCommand, processColumnNames);
SqlTextFunctions.UnUnderscoreColumnNames = true;
myConnection.Open();
SqlLogger.LogSqlCommand(myCommand);
// if (useIdentityInsert)
// myConnection.Execute("set identity_insert on;");
myCommand.ExecuteNonQuery();
myConnection.Close();
}
}
}
public void PoolingThread_100LogsRaisedAndAPauseThenAnotherLog_PoolingThreadShutsDownAndStartsUpAgain()
{
// Arrange
var logger = new SqlLogger(new TestApplicationSettings {
EnableThreadedLogging = true, EnableDebug = true
}, new NullCorrelationIdHelper());
logger.LogDebug(string.Format("Test run index {0}", 0));
logger.LogDebug(string.Format("Test run index {0}", 1));
Thread.Sleep(5000);
for (int i = 2; i < 100; i++)
{
logger.LogDebug(string.Format("Test run index {0}", i));
}
Thread.Sleep(5000);
// Act
logger.LogDebug(string.Format("Test run index {0}", 100));
// Assert
// No exception thrown and disposing
logger.Dispose();
}
/// <summary>
/// Initializers the specified system setting reader.
/// </summary>
/// <param name="SystemSettingReader">The system setting reader.</param>
private void Initializer(ISettingReader SystemSettingReader, string SettingKey)
{
ILogger SystemLogger = null;
IOrganizationService XrmService = null;
CubeBase SystemBase = null;
List <SettingGroup> SystemSettingsGroup = SystemSettingReader.Read(SettingKey);
//load global settings
if (SystemSettingsGroup != null && SystemSettingsGroup.Count > 0)
{
SettingGroup groupGlobalSettings = SystemSettingsGroup.FirstOrDefault(s => s.GroupName == "GlobalSettings");
EnumCarrier.LogLevel logLevel = EnumCarrier.LogLevel.None;
EnumCarrier.LogScreen logScreen = EnumCarrier.LogScreen.None;
EnumCarrier.LogLocation logger = EnumCarrier.LogLocation.None;
if (groupGlobalSettings != null && groupGlobalSettings.Settings != null && groupGlobalSettings.Settings.Count > 0)
{
//load logger settings
logLevel = (EnumCarrier.LogLevel)groupGlobalSettings.Settings.FirstOrDefault(l => l.Key == "LogLevel").Value;
logScreen = (EnumCarrier.LogScreen)groupGlobalSettings.Settings.FirstOrDefault(l => l.Key == "LogScreen").Value;
logger = (EnumCarrier.LogLocation)groupGlobalSettings.Settings.FirstOrDefault(l => l.Key == "LogLocation").Value;
switch (logger)
{
case EnumCarrier.LogLocation.CRM:
break;
case EnumCarrier.LogLocation.SQL:
SystemLogger = new SqlLogger();
break;
case EnumCarrier.LogLocation.Text:
SystemLogger = new TextLogger();
break;
}
}
SettingGroup groupConnections = SystemSettingsGroup.FirstOrDefault(s => s.GroupName == "Connections");
if (groupConnections != null && groupConnections.Settings != null && groupConnections.Settings.Count > 0)
{
IDetailedLog logSystem = null;
if (logger == EnumCarrier.LogLocation.SQL)
{
string connectionString = groupConnections.Settings.FirstOrDefault(l => l.Key == "SQL").Value.ToString();
SqlConnection connection = new SqlConnection(connectionString);
logSystem = new DetailedLog(SystemLogger, logLevel, connection, logScreen);
}
else if (logger == EnumCarrier.LogLocation.Text)
{
string logPath = groupGlobalSettings.Settings.FirstOrDefault(l => l.Key == "LogPath").Value.ToString();
logSystem = new DetailedLog(SystemLogger, logLevel, logPath, logScreen);
}
SystemBase = new CubeBase();
SystemBase.LogSystem = logSystem;
bool OpenOrganizationService = (bool)groupGlobalSettings.Settings.FirstOrDefault(l => l.Key == "OpenOrganizationService").Value;
if (OpenOrganizationService)
{
string crmConnection = groupConnections.Settings.FirstOrDefault(l => l.Key == "CRM").Value.ToString();
Service service = new Service(SystemBase.LogSystem);
Result result = service.GetService(crmConnection);
if (!result.isError)
{
XrmService = (IOrganizationService)result.BusinessObject;
SystemBase.XrmService = XrmService;
}
}
}
cube = SystemBase;
cube.XRMActions.Create(new Entity());
cube.RetrieveActions.getItemsFetch("");
cube.MetadataRetrieveActions.GetOptionSets("", "");
}
}
private static void WriteToSql(Exception exception)
{
var sqlLogger = new SqlLogger(new DetailedError());
sqlLogger.Write(exception);
}
public ConsoleLoggerFactory()
{
_logger = new SqlLogger();
}
public AutoPilot()
{
_airplane = new Airplane();
_logger = new SqlLogger();
}
public void Setup()
{
ex = new Faker <Exception>().Generate();
logger = new SqlLogger(IErrorMock.GetIErrorMock());
}
public override IEnumerable <Dictionary <string, object> > ExecuteSqlReader(string sql, QueryParameterCollection parameters)
{
var stopwatch = SqlLogger != null?Stopwatch.StartNew() : null;
var stmt = CreateCommand(sql, parameters);
try
{
for (;;)
{
var returnCode = SQLitePCL.raw.sqlite3_step(stmt);
if (returnCode == SQLitePCL.raw.SQLITE_BUSY)
{
Task.Delay(100).Wait();
continue;
}
if (returnCode == SQLitePCL.raw.SQLITE_DONE)
{
break;
}
if (returnCode != SQLitePCL.raw.SQLITE_ROW)
{
throw new SqliteException((SqliteReturnCode)returnCode, (SqliteExtendedErrorCode)SQLitePCL.raw.sqlite3_extended_errcode(DbHandle), SQLitePCL.raw.sqlite3_errmsg(DbHandle).utf8_to_string());
}
Dictionary <string, object> record = new Dictionary <string, object>();
for (int i = 0; i < SQLitePCL.raw.sqlite3_column_count(stmt); i++)
{
string fieldName = SQLitePCL.raw.sqlite3_column_name(stmt, i).utf8_to_string();
var columnType = SQLitePCL.raw.sqlite3_column_type(stmt, i);
switch (columnType)
{
case SQLitePCL.raw.SQLITE_BLOB:
record[fieldName] = SQLitePCL.raw.sqlite3_column_blob(stmt, i).ToArray();
break;
case SQLitePCL.raw.SQLITE_TEXT:
record[fieldName] = SQLitePCL.raw.sqlite3_column_text(stmt, i).utf8_to_string();
break;
case SQLitePCL.raw.SQLITE_FLOAT:
record[fieldName] = SQLitePCL.raw.sqlite3_column_double(stmt, i);
break;
case SQLitePCL.raw.SQLITE_INTEGER:
record[fieldName] = SQLitePCL.raw.sqlite3_column_int64(stmt, i);
break;
case SQLitePCL.raw.SQLITE_NULL:
record[fieldName] = null;
break;
}
}
yield return(record);
}
}
finally
{
SQLitePCL.raw.sqlite3_finalize(stmt);
}
SqlLogger?.LogSql(sql, parameters?.ToDictionary(p => SqlDialect.CreateParameterExpression(p.Name), p => p.Value), stopwatch?.Elapsed ?? TimeSpan.Zero);
}
public void SqlLogger_WorksProperly()
{
using (new MunqContext())
{
var fld = SystemLogRow.Fields;
var registrar = Dependency.Resolve <IDependencyRegistrar>();
var fakeConfig = A.Fake <IConfigurationRepository>();
A.CallTo(() => fakeConfig.Load(null))
.WithAnyArguments()
.ReturnsLazily((Type t) =>
JSON.ParseTolerant(JSON.Stringify(new
{
Level = "Debug",
ConnectionKey = "Serenity",
InsertCommand = new SqlInsert(fld.TableName)
.SetTo(fld.EventDate, "@date")
.SetTo(fld.LogLevel, "@level")
.SetTo(fld.LogMessage, "@message")
.SetTo(fld.Exception, "@exception")
.SetTo(fld.SourceType, "@source")
.ToString()
}), t));
registrar.RegisterInstance <IConfigurationRepository>("Application", fakeConfig);
using (var context = NewDbTestContext())
{
context.ExpireOverrides();
var logger = new SqlLogger();
registrar.RegisterInstance <ILogger>(logger);
Log.MinimumLevel = LoggingLevel.Debug;
Log.Debug("Hello1", new Exception("SomeException1"), this.GetType());
Log.Info("Hello2", new Exception("SomeException2"), this.GetType());
Log.Warn("Hello3", new Exception("SomeException3"), this.GetType());
using (var connection = SqlConnections.NewByKey("Serenity"))
{
logger.Flush();
var items = connection.List <SystemLogRow>(q => q.SelectTableFields().OrderBy(fld.ID, desc: true).Take(3));
Assert.Equal(3, items.Count);
var item = items[2];
Assert.Equal("Hello1", item.LogMessage);
Assert.Contains("SomeException1", item.Exception);
Assert.Equal("Debug", item.LogLevel);
Assert.Equal(this.GetType().FullName, item.SourceType);
Assert.True(DateTime.Now.Subtract(item.EventDate.Value).TotalSeconds < 60);
item = items[1];
Assert.Equal("Hello2", item.LogMessage);
Assert.Contains("SomeException2", item.Exception);
Assert.Equal("Info", item.LogLevel);
Assert.Equal(this.GetType().FullName, item.SourceType);
Assert.True(DateTime.Now.Subtract(item.EventDate.Value).TotalSeconds < 60);
item = items[0];
Assert.Equal("Hello3", item.LogMessage);
Assert.Contains("SomeException3", item.Exception);
Assert.Equal("Warn", item.LogLevel);
Assert.Equal(this.GetType().FullName, item.SourceType);
Assert.True(DateTime.Now.Subtract(item.EventDate.Value).TotalSeconds < 60);
}
}
}
}
