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);