private void OnError(Exception exception, DbCommand command, Guid contextId, DateTime start, DateTime now, double milliseconds,
Func <Exception, string, DbParameterCollection, DateTime, DateTime, object> specificErrorAction, string memberName)
{
var localFunc = _descriptor.ExposeErrorInterceptor;
localFunc += specificErrorAction;
var userInfo = localFunc?.Invoke(exception, command.CommandText, command.Parameters, start, now) ?? string.Empty;
var eventId = new LogEventId(contextId, EventIdKeys.Error);
var logger = _loggingServiceProvider.GetLogger <DbContext>(LogEventSendMode.Automatic, _descriptor.ExposeSettings.GetRenderingOptions());
var dbParams = new List <DbParam>();
foreach (DbParameter param in command.Parameters)
{
dbParams.Add(new DbParam(param.ParameterName, param.Value, param.DbType));
}
var realExcepton = exception.Unwrap();
var loggingParams = new {
OrmName = Constants.SinkKey,
ContextId = contextId,
Sql = command.CommandText,
SqlParams = dbParams,
ExceptionType = exception.GetType(),
ExceptionMessage = exception.Message,
RealExceptionType = realExcepton.GetType(),
RealExceptionMessage = realExcepton.Message,
UsedTime = milliseconds,
UserInfo = userInfo
};
logger.LogError(eventId, exception, OrmTemplateStandard.Error, loggingParams, memberName: memberName);
}
public void EvaluateArithmeticOperationsWithOverflow(string literal, LogEventId expectedEventId)
{
var code = I($"export const r = {literal};");
var result = EvaluateWithFirstError(code);
Assert.Equal(expectedEventId, (LogEventId)result.ErrorCode);
}
private void OnLongTimeExecuted(DbCommand command, Guid contextId, DateTime start, DateTime now, double milliseconds,
Func <string, DbParameterCollection, DateTime, DateTime, object> specificLongTimeExecutedAction, string memberName)
{
var localFunc = _descriptor.ExposeLongTimeExecutedInterceptor;
localFunc += specificLongTimeExecutedAction;
var userInfo = localFunc?.Invoke(command.CommandText, command.Parameters, start, now) ?? string.Empty;
var eventId = new LogEventId(contextId, EventIdKeys.LongTimeExecuted);
var logger = _loggingServiceProvider.GetLogger <DbContext>(LogEventSendMode.Automatic, _descriptor.ExposeSettings.GetRenderingOptions());
var dbParams = new List <DbParam>();
foreach (DbParameter param in command.Parameters)
{
dbParams.Add(new DbParam(param.ParameterName, param.Value, param.DbType));
}
var loggingParams = new {
OrmName = Constants.SinkKey,
ContextId = contextId,
Sql = command.CommandText,
SqlParams = dbParams,
UsedTime = milliseconds,
UserInfo = userInfo
};
logger.LogInformation(eventId, OrmTemplateStandard.LongNormal, loggingParams, memberName: memberName);
}
/// <summary>
/// Log
/// </summary>
/// <param name="eventId"></param>
/// <param name="level"></param>
/// <param name="exception"></param>
/// <param name="messageTemplate"></param>
/// <param name="args"></param>
/// <param name="memberName"></param>
/// <param name="filePath"></param>
/// <param name="lineNumber"></param>
public virtual void Log(LogEventId eventId, LogEventLevel level, Exception exception, string messageTemplate, object[] args,
[CallerMemberName] string memberName = null,
[CallerFilePath] string filePath = null,
[CallerLineNumber] int lineNumber = 0)
{
Write(eventId, level, exception, messageTemplate, LogEventSendMode.Customize,
new LogCallerInfo(memberName, filePath, lineNumber), null, args);
}
/// <summary>
/// Log
/// </summary>
/// <param name="eventId"></param>
/// <param name="level"></param>
/// <param name="messageTemplate"></param>
/// <param name="arg1"></param>
/// <param name="arg2"></param>
/// <param name="arg3"></param>
/// <param name="memberName"></param>
/// <param name="filePath"></param>
/// <param name="lineNumber"></param>
/// <typeparam name="T1"></typeparam>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="T3"></typeparam>
public virtual void Log <T1, T2, T3>(LogEventId eventId, LogEventLevel level, string messageTemplate, T1 arg1, T2 arg2, T3 arg3,
[CallerMemberName] string memberName = null,
[CallerFilePath] string filePath = null,
[CallerLineNumber] int lineNumber = 0)
{
Write(eventId, level, null, messageTemplate, LogEventSendMode.Customize,
new LogCallerInfo(memberName, filePath, lineNumber), null, arg1, arg2, arg3);
}
internal static void LogMessage(LogEventId eventId, LogLevel level, string message, Exception exception, IDictionary <object, object> properties)
{
var type = typeof(T);
NLog.Logger logger = NLog.LogManager.GetLogger(type.FullName);
NLog.LogLevel logLevel = NLog.LogLevel.Info; // Default level to info
switch (level)
{
case LogLevel.Warn:
logLevel = NLog.LogLevel.Warn;
break;
case LogLevel.Info:
logLevel = NLog.LogLevel.Info;
break;
case LogLevel.Fatal:
logLevel = NLog.LogLevel.Fatal;
break;
case LogLevel.Error:
logLevel = NLog.LogLevel.Error;
break;
case LogLevel.Debug:
logLevel = NLog.LogLevel.Debug;
break;
case LogLevel.Trace:
logLevel = NLog.LogLevel.Trace;
break;
}
NLog.LogEventInfo logEvent = new NLog.LogEventInfo(logLevel, type.Name, message);
logEvent.Exception = exception;
CombineProperties(logEvent.Properties, properties);
if (logEvent.Properties.ContainsKey(LoggingAttributes.LOG_OBJECT))
{
logEvent.Properties[LoggingAttributes.LOG_OBJECT] =
Newtonsoft.Json.JsonConvert.SerializeObject(logEvent.Properties[LoggingAttributes.LOG_OBJECT]);
}
//Add event id to the properties
if (!logEvent.Properties.ContainsKey("EventId.Id"))
{
logEvent.Properties.Add("EventId.Id", (int)eventId);
}
else
{
logEvent.Properties["EventId.Id"] = (int)eventId;
}
logger.Log(type, logEvent);
}
public void TestNotAllowedNamespaceLevelStatements(string statement, LogEventId expectedErrorCode)
{
string code = $@"
namespace M {{
{statement}
}}";
ParseWithDiagnosticId(code, expectedErrorCode);
}
private void ParseAndInsertLogEventIntoQueueAutomatically(LogEventId eventId, LogEventLevel level, Exception exception, string messageTemplate,
ILogCallerInfo callerInfo, LogEventContext context = null, params object[] messageTemplateParameters)
{
var task = CreateEnqueueTask();
task.ContinueWith(t => DispatchForAutomatic());
task.Start();
Task CreateEnqueueTask()
{
var taskResult = new Task(async() => {
var writer = await _automaticAsyncQueue.AcquireWriteAsync(1, CancellationToken.None);
writer.Visit(
succeeded => {
_messageParameterProcessor.Process(messageTemplate, __as(messageTemplateParameters, context),
out var parsedTemplate, out var namedMessageProperties, out var positionalMessageProperties);
var logEvent = new LogEvent(StateNamespace, eventId, level, parsedTemplate, exception,
LogEventSendMode.Automatic, callerInfo, _upstreamRenderingOptions,
namedMessageProperties, positionalMessageProperties, context,
messageProcessorShortcut: _messageParameterProcessor);
if (succeeded.ItemCount >= 1)
{
_automaticAsyncQueue.ReleaseWrite(logEvent);
}
else
{
_automaticAsyncQueue.ReleaseWrite();
}
return(logEvent);
},
cancelled => {
InternalLogger.WriteLine("When insert log event(0) into async queue, task has been cancelled.");
return(null);
},
faulted => {
InternalLogger.WriteLine(
$@"Thrown an exception when insert log event(0) into async queue:{Environment.NewLine}{faulted.Exception.ToUnwrappedString()}",
faulted.Exception);
return(null);
});
});
return(taskResult);
object[] __as(object[] __paramObjs, LogEventContext __context)
{
if (__paramObjs == null || !__paramObjs.Any())
{
return(__context?.Parameters.ToArray());
}
return(__paramObjs.GetType() != typeof(object[]) ? new object[] { __paramObjs } : __paramObjs);
}
}
}
public void EvaluateUnaryPlusWithFailure(string expression, LogEventId expectedEventId)
{
const string CodeTemplate = @"
function functionFoo() {{return ""42"";}}
export const result = {0};";
string code = string.Format(CodeTemplate, expression);
EvaluateWithDiagnosticId(code, expectedEventId);
}
private static void InternalExecutedOpt(
SqlSugarInterceptorDescriptor descriptor,
SqlSugarClient client,
string sql,
SugarParameter[] @params,
Func <string, SugarParameter[], object> executedAct = null,
Func <string, LogEventLevel, bool> filter = null)
{
var ms = 0D;
if (client.TempItems.TryGetValue(TimestampKey, out var startStamp) && startStamp is DateTime stamp)
{
client.TempItems.Remove(TimestampKey);
ms = DateTime.Now.Subtract(stamp).TotalMilliseconds;
}
object loggingParams;
var userInfo = executedAct?.Invoke(sql, @params) ?? string.Empty;
var logger = descriptor.ExposeLoggingServiceProvider.GetLogger <SqlSugarClient>(filter, LogEventSendMode.Automatic, descriptor.RenderingOptions);
if (ms > 1000)
{
if (!logger.IsEnabled(LogEventLevel.Warning))
{
return;
}
var eventId = new LogEventId(client.ContextID, EventIdKeys.LongTimeExecuted);
loggingParams = new {
OrmName = Constants.SinkKey,
ContextId = client.ContextID,
Sql = sql,
SqlParams = @params.Select(param => new DbParam(param.ParameterName, param.Value, param.DbType)).ToList(),
UsedTime = ms,
UserInfo = userInfo
};
logger.LogWarning(eventId, OrmTemplateStandard.LongNormal, loggingParams);
}
else
{
if (!logger.IsEnabled(LogEventLevel.Information))
{
return;
}
var eventId = new LogEventId(client.ContextID, EventIdKeys.Executed);
loggingParams = new {
OrmName = Constants.SinkKey,
ContextId = client.ContextID,
Sql = sql,
UsedTime = ms,
UserInfo = userInfo
};
logger.LogInformation(eventId, OrmTemplateStandard.Normal, loggingParams);
}
}
/// <summary>
/// Log
/// </summary>
/// <param name="eventId"></param>
/// <param name="level"></param>
/// <param name="messageTemplate"></param>
/// <param name="arg1"></param>
/// <param name="arg2"></param>
/// <param name="arg3"></param>
/// <param name="contextAct"></param>
/// <param name="memberName"></param>
/// <param name="filePath"></param>
/// <param name="lineNumber"></param>
/// <typeparam name="T1"></typeparam>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="T3"></typeparam>
public virtual void Log <T1, T2, T3>(LogEventId eventId, LogEventLevel level, string messageTemplate, T1 arg1, T2 arg2, T3 arg3, Action <LogEventContext> contextAct,
[CallerMemberName] string memberName = null,
[CallerFilePath] string filePath = null,
[CallerLineNumber] int lineNumber = 0)
{
var ctx = TouchLogEventContext(contextAct);
Write(eventId, level, null, messageTemplate, ctx.SendMode,
new LogCallerInfo(memberName, filePath, lineNumber), ctx, arg1, arg2, arg3);
}
/// <summary>
/// Log
/// </summary>
/// <param name="eventId"></param>
/// <param name="level"></param>
/// <param name="exception"></param>
/// <param name="messageTemplate"></param>
/// <param name="args"></param>
/// <param name="contextAct"></param>
/// <param name="memberName"></param>
/// <param name="filePath"></param>
/// <param name="lineNumber"></param>
public virtual void Log(LogEventId eventId, LogEventLevel level, Exception exception, string messageTemplate, object[] args, Action <LogEventContext> contextAct,
[CallerMemberName] string memberName = null,
[CallerFilePath] string filePath = null,
[CallerLineNumber] int lineNumber = 0)
{
var ctx = TouchLogEventContext(contextAct);
Write(eventId, level, exception, messageTemplate, ctx.SendMode,
new LogCallerInfo(memberName, filePath, lineNumber), ctx, args);
}
public void Log_Writes_MicrosoftEvent()
{
var logEventId = new LogEventId(new Random().Next(), "eventName");
var logEvent = new LogEvent(
DateTimeOffset.Now,
LogLevel.Trace,
logEventId,
new LogMessageTemplate("message {value1}"),
new[] { new LogProperty("value1", 1) },
new Exception());
MicrosoftLogEvent loggedEvent = null;
_logObserver.When(o => o.OnNext(Arg.Any <MicrosoftLogEvent>()))
.Do(
ci =>
{
loggedEvent = ci.ArgAt <MicrosoftLogEvent>(0);
});
_logger.Log(logEvent);
loggedEvent.Should()
.NotBeNull();
loggedEvent.Message.Should()
.Be("message 1" + Environment.NewLine + logEvent.Exception);
loggedEvent.Level.Should()
.Be(MicrosoftLogLevel.Trace);
loggedEvent.Id.Id.Should()
.Be(logEvent.Id.Id);
loggedEvent.Id.Name.Should()
.Be(logEvent.Id.Name);
loggedEvent.Error.Should()
.Be(logEvent.Exception);
loggedEvent.State.Should()
.BeAssignableTo <IEnumerable <KeyValuePair <string, object> > >();
((IEnumerable <KeyValuePair <string, object> >)loggedEvent.State)
.Should()
.BeEquivalentTo(
new[]
{
new KeyValuePair <string, object>("{OriginalFormat}", logEvent.MessageTemplate.Format),
new KeyValuePair <string, object>("value1", 1)
});
}
public void TestCustomMergeFailures(string leftObject, string rightObject, LogEventId expectedId)
{
var result = EvaluateSpec(
$@"
const o1 = {leftObject};
const o2 = {rightObject};
export const result = o1.merge(o2);
",
new[] { "result" });
result.Errors.ExpectErrorCode(expectedId);
}
public void WriteLog(string sqlText, string suffixEventName, [CallerMemberName] string memberName = null)
{
var userInfo = _simgleLoggingAct?.Invoke(sqlText) ?? string.Empty;
var eventId = new LogEventId($"{EventIdKeys.SqlExposure}_{suffixEventName}");
var loggingObj = new {
OrmName = Constants.SinkKey,
Sql = sqlText,
UserInfo = userInfo
};
_logger.LogDebug(eventId, OrmTemplateStandard.SimpleSqlLog, loggingObj, memberName);
}
/// <summary>
/// Write
/// </summary>
/// <param name="eventId"></param>
/// <param name="level"></param>
/// <param name="exception"></param>
/// <param name="messageTemplate"></param>
/// <param name="messageTemplateParameters"></param>
public void Write(LogEventId eventId, LogEventLevel level, Exception exception, string messageTemplate, params object[] messageTemplateParameters)
{
if (!IsEnabled(level))
{
return;
}
if (string.IsNullOrWhiteSpace(messageTemplate))
{
return;
}
var cleanMessageTemplateParameters = ArgsHelper.CleanUp(messageTemplateParameters);
ParseAndInsertLogEventIntoQueueAutomatically(eventId ?? new LogEventId(), level, exception, messageTemplate, cleanMessageTemplateParameters);
}
public void TestUnresolvedInstanceMembers(string initializer, string member, LogEventId expectedError)
{
// Lets fix up the inline data for Unix runs
if (initializer.Contains("`c:") && OperatingSystemHelper.IsUnixOS)
{
initializer = initializer.Replace("`c:", "`");
}
// Need to separate receiver and member access because bool.foo() fails at parse time
// but const b: bool = true; b.foo() - at runtime.
string code = I($"const l = {initializer}; const r = (<{{unknownProperty: any, unknownMethod(): any}}><any>l).{member};");
var result = EvaluateWithFirstError(code);
Assert.Equal(expectedError, (LogEventId)result.ErrorCode);
}
public void FailOnTempInput(int tempArtifactType, LogEventId errorEvent)
{
// First pip writes a file to its temp directory
CreateAndSchedulePipWithTemp(tempArtifactType, out var tempOut);
Assert.Throws <BuildXLTestException>(() =>
{
// Second pip consumes a file from pipA's temp directory
CreateAndSchedulePipBuilder(new Operation[]
{
Operation.ReadFile(tempOut),
Operation.WriteFile(CreateOutputFileArtifact())
});
});
AssertErrorEventLogged(errorEvent);
}
public void AssignmentMustOperateOnLocalVariable(string expression, LogEventId expectedEventId)
{
const string CodeTemplate = @"
function foo() {{
let x = 0;
{0};
return x;
}}
export const r = foo();
";
var code = string.Format(CodeTemplate, expression);
EvaluateWithDiagnosticId(code, expectedEventId);
}
public void Write(LogEventId eventId, LogEventLevel level, Exception exception, string messageTemplate, LogEventSendMode sendMode, ILogCallerInfo callerInfo,
LogEventContext context = null, params object[] messageTemplateParameters)
{
if (!IsEnabled(level))
{
return;
}
if (string.IsNullOrWhiteSpace(messageTemplate))
{
return;
}
if (IsManuallySendMode(sendMode))
{
ParseAndInsertLogEvenDescriptorManually(eventId ?? new LogEventId(), level, exception, messageTemplate, callerInfo, context, messageTemplateParameters);
}
else
{
ParseAndInsertLogEventIntoQueueAutomatically(eventId ?? new LogEventId(), level, exception, messageTemplate, callerInfo, context, messageTemplateParameters);
}
}
private static void InternalErrorOpt(
SqlSugarInterceptorDescriptor descriptor,
SqlSugarClient client,
Exception exception,
Func <Exception, object> errorAct = null,
Func <string, LogEventLevel, bool> filter = null)
{
var ms = 0D;
if (client.TempItems.TryGetValue(TimestampKey, out var startStamp) && startStamp is DateTime stamp)
{
client.TempItems.Remove(TimestampKey);
ms = DateTime.Now.Subtract(stamp).TotalMilliseconds;
}
object userInfo = errorAct?.Invoke(exception) ?? string.Empty;
var logger = descriptor.ExposeLoggingServiceProvider.GetLogger <SqlSugarClient>(filter, LogEventSendMode.Automatic, descriptor.RenderingOptions);
if (!logger.IsEnabled(LogEventLevel.Error))
{
return;
}
var eventId = new LogEventId(client.ContextID, EventIdKeys.Error);
var realException = exception.Unwrap();
var loggingParams = new {
OrmName = Constants.SinkKey,
ContextId = client.ContextID,
Sql = "unknown",
SqlParams = "unknown",
ExceptionType = exception.GetType(),
ExceptionMessage = exception.Message,
RealExceptionType = realException.GetType(),
RealExceptionMessage = realException.Message,
UsedTime = ms,
UserInfo = userInfo
};
logger.LogError(eventId, exception, OrmTemplateStandard.Error, loggingParams);
}
private static void InternalErrorOpt(SqlSugarInterceptorDescriptor descriptor, SqlSugarClient client, Exception exception,
Func <Exception, object> errorAct = null,
Func <string, LogEventLevel, bool> filter = null)
{
object userInfo = errorAct?.Invoke(exception) ?? string.Empty;
var logger = descriptor.ExposeLoggingServiceProvider.GetLogger <SqlSugarClient>(filter, LogEventSendMode.Automatic, descriptor.RenderingOptions);
var eventId = new LogEventId(client?.ContextID ?? Guid.NewGuid(), EventIdKeys.Error);
var realExcepton = exception.Unwrap();
var loggingParams = new {
OrmName = Constants.SinkKey,
ContextId = "unknown",
Sql = "unknown",
SqlParams = "unknown",
ExceptionType = exception.GetType(),
ExceptionMessage = exception.Message,
RealExceptionType = realExcepton.GetType(),
RealExceptionMessage = realExcepton.Message,
UsedTime = "unknown",
UserInfo = userInfo
};
logger.LogError(eventId, exception, OrmTemplateStandard.Error, loggingParams);
}
private void WithError(string expression, LogEventId eventId)
{
ParseWithDiagnosticId($"const x = {expression};", eventId);
}
public static EventId ToMicrosoftEventId(this LogEventId eventId)
{
return(new EventId(eventId.Id, eventId.Name));
}
/// <inheritdoc /> public void LogFatal(LogEventId eventId, Exception exception, string messageTemplate, params object[] args) => Write(eventId, LogEventLevel.Fatal, exception, messageTemplate, args);
/// <inheritdoc /> public void LogFatal(LogEventId eventId, string messageTemplate, params object[] args) => Write(eventId, LogEventLevel.Fatal, null, messageTemplate, args);
/// <inheritdoc /> public void LogWarning(LogEventId eventId, string messageTemplate, params object[] args) => Write(eventId, LogEventLevel.Warning, null, messageTemplate, args);
/// <inheritdoc /> public void LogInformation(LogEventId eventId, string messageTemplate, params object[] args) => Write(eventId, LogEventLevel.Information, null, messageTemplate, args);
/// <inheritdoc /> public void LogVerbose(LogEventId eventId, string messageTemplate, params object[] args) => Write(eventId, LogEventLevel.Verbose, null, messageTemplate, args);
private void AssertNotLogged(LogEventId eventId) => AssertInformationalEventLogged(eventId, count: 0);
