C# LogEventInfo类代码示例

        /// <summary>
        /// Renders the log message including any positional parameters and appends it to the specified <see cref="StringBuilder" />.
        /// </summary>
        /// <param name="builder">The <see cref="StringBuilder"/> to append the rendered data to.</param>
        /// <param name="logEvent">Logging event.</param>
        protected internal override void Append(StringBuilder builder, LogEventInfo logEvent)
        {
            if (NeedPadding())
            {
                builder.Append(ApplyPadding(logEvent.FormattedMessage));
            }
            else
            {
                if (logEvent.Parameters == null || logEvent.Parameters.Length == 0)
                {
                    builder.Append(logEvent.Message);
                }
                else
                {
                    if (logEvent.FormatProvider != null)
                    {
#if NETCF
                        builder.Append(String.Format(logEvent.FormatProvider, logEvent.Message, logEvent.Parameters));
#else
                        builder.AppendFormat(logEvent.FormatProvider, logEvent.Message, logEvent.Parameters);
#endif
                    }
                    else
                    {
#if NETCF
                        builder.Append(String.Format(logEvent.Message, logEvent.Parameters));
#else
                        builder.AppendFormat(logEvent.Message, logEvent.Parameters);
#endif
                    }
                };
            }
        }

        public void AutoFlushTargetWrapperSyncTest1()
        {
            var myTarget = new MyTarget();
            var wrapper = new AutoFlushTargetWrapper
            {
                WrappedTarget = myTarget,
            };

            myTarget.Initialize(null);
            wrapper.Initialize(null);
            var logEvent = new LogEventInfo();
            Exception lastException = null;
            bool continuationHit = false;
            AsyncContinuation continuation =
                ex =>
                    {
                        lastException = ex;
                        continuationHit = true;
                    };

            wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));

            Assert.IsTrue(continuationHit);
            Assert.IsNull(lastException);
            Assert.AreEqual(1, myTarget.FlushCount);
            Assert.AreEqual(1, myTarget.WriteCount);

            continuationHit = false;
            wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
            Assert.IsTrue(continuationHit);
            Assert.IsNull(lastException);
            Assert.AreEqual(2, myTarget.WriteCount);
            Assert.AreEqual(2, myTarget.FlushCount);
        }

        /// <summary>
        /// Renders the specified ASP.NET Item value and appends it to the specified <see cref="StringBuilder" />.
        /// </summary>
        /// <param name="builder">The <see cref="StringBuilder"/> to append the rendered data to.</param>
        /// <param name="logEvent">Logging event.</param>
        protected override void Append(StringBuilder builder, LogEventInfo logEvent)
        {
            if (Variable == null)
            {
                return;
            }

            HttpContext context = HttpContext.Current;
            if (context == null)
            {
                return;
            }

            object value;
            if (EvaluateAsNestedProperties)
            {
                var path = Variable.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries);

                value = context.Items[path[0]];

                foreach (var property in path.Skip(1))
                {
                    var propertyInfo = value.GetType().GetProperty(property);
                    value = propertyInfo.GetValue(value, null);
                }
            }
            else
            {
                value = context.Items[Variable];
            }

            builder.Append(Convert.ToString(value, CultureInfo.InvariantCulture));
        }

 /// <summary>
 /// Writes the specified logging event to the <see cref="System.Diagnostics.Trace"/> facility.
 /// If the log level is greater than or equal to <see cref="LogLevel.Error"/> it uses the
 /// <see cref="System.Diagnostics.Trace.Fail(string)"/> method, otherwise it uses
 /// <see cref="System.Diagnostics.Trace.Write(string)" /> method.
 /// </summary>
 /// <param name="logEvent">The logging event.</param>
 protected override void Write(LogEventInfo logEvent)
 {
     if (logEvent.Level <= LogLevel.Debug)
     {
         Trace.WriteLine(this.Layout.Render(logEvent));
     }
     else if (logEvent.Level == LogLevel.Info)
     {
         Trace.TraceInformation(this.Layout.Render(logEvent));
     }
     else if (logEvent.Level == LogLevel.Warn)
     {
         Trace.TraceWarning(this.Layout.Render(logEvent));
     }
     else if (logEvent.Level == LogLevel.Error)
     {
         Trace.TraceError(this.Layout.Render(logEvent));
     }
     else if (logEvent.Level >= LogLevel.Fatal)
     {
         Trace.Fail(this.Layout.Render(logEvent));
     }
     else
     {
         Trace.WriteLine(this.Layout.Render(logEvent));                
     }
 }

        public override string GetFormattedString(LogWriteContext context, LogEventInfo info)
        {
            StringBuilder builder = new StringBuilder();
            builder.Append("Sequence: ");
            builder.Append(info.SequenceID);
            builder.Append("\r\nDate/time: ");
            builder.Append(info.TimeStamp.ToString(LogManager.DateTimeFormat));
            builder.Append("\r\nLevel: ");
            builder.Append(info.Level.ToString().ToUpper());
            builder.Append("\r\nThread: ");
            builder.Append(Environment.CurrentManagedThreadId);
            builder.Append("\r\nLogger: ");
            builder.Append(info.Logger);
            builder.Append("\r\n------------------------\r\n");
            builder.Append(info.Message);

            if(info.Exception != null)
            {
                builder.Append("\r\n------------------------\r\n");
                builder.Append(info.Exception);
            }

            builder.Append("\r\n------------------------\r\n");
            builder.Append("Session: ");
            builder.Append(context.Environment.ToJson());

            return builder.ToString();
        }

 /// <summary>
 /// Renders the selected process information.
 /// </summary>
 /// <param name="builder">The <see cref="StringBuilder"/> to append the rendered data to.</param>
 /// <param name="logEvent">Logging event.</param>
 protected override void Append(StringBuilder builder, LogEventInfo logEvent)
 {
     if(!_isInitialized)
         throw new InvalidOperationException("required run Initialize method");
     if (propertyInfo != null)
         builder.Append(Convert.ToString(propertyInfo.GetValue(process, null), CultureInfo.InvariantCulture));
 }

 /// <summary>
 ///     Writes the specified logging event to the attached debugger.
 /// </summary>
 /// <param name="logEvent">The logging event.</param>
 protected override void Write(LogEventInfo logEvent)
 {
     if (Debugger.IsLogging())
     {
         Debugger.Log(logEvent.Level.Ordinal, logEvent.LoggerName, Layout.Render(logEvent) + "\n");
     }
 }

 /// <summary>
 /// Does nothing. Optionally it calculates the layout text but
 /// discards the results.
 /// </summary>
 /// <param name="logEvent">The logging event.</param>
 public override void Write(LogEventInfo logEvent)
 {
     if (_formatMessage)
     {
         CompiledLayout.GetFormattedMessage(logEvent);
     }
 }

        /// <summary>
        /// First attemps to create a RollbarClient using config read from
        /// appSettings. Uses properties of this class as overrides if specified.
        /// </summary>
        /// <param name="logEvent"></param>
        /// <returns></returns>
        private RollbarClient CreateClient(LogEventInfo logEvent)
        {
            var configuration = new Configuration(AccessToken);

            if (!string.IsNullOrEmpty(Endpoint))
                configuration.Endpoint = Endpoint;

            if (Environment != null)
                configuration.Environment = Environment.Render(logEvent);

            if (Platform != null)
                configuration.Platform = Platform.Render(logEvent);

            if (Language != null)
                configuration.Language = Language.Render(logEvent);

            if (Framework != null)
                configuration.Framework = Framework.Render(logEvent);

            var client = new RollbarClient(configuration);
            client.RequestStarting += RollbarClientRequestStarting;
            client.RequestCompleted += RollbarClientRequestCompleted;

            return client;
        }

        public void FilteringTargetWrapperAsyncTest2()
        {
            var myMockCondition = new MyMockCondition(false);
            var myTarget = new MyAsyncTarget();
            var wrapper = new FilteringTargetWrapper(myTarget, myMockCondition);
            wrapper.Initialize(CommonCfg);
            var logEvent = new LogEventInfo();
            Exception lastException = null;
            var continuationHit = new ManualResetEvent(false);
            Action<Exception> continuation =
                ex =>
                {
                    lastException = ex;
                    continuationHit.Set();
                };

            wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));

            continuationHit.WaitOne();
            Assert.IsNull(lastException);
            Assert.AreEqual(0, myTarget.WriteCount);
            Assert.AreEqual(1, myMockCondition.CallCount);

            continuationHit.Reset();
            wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
            continuationHit.WaitOne();
            Assert.IsNull(lastException);
            Assert.AreEqual(0, myTarget.WriteCount);
            Assert.AreEqual(2, myMockCondition.CallCount);
        }

		public static string GetMessageInner(bool useJSON, Layout layout, LogEventInfo info)
		{
			if (!useJSON)
				return layout.Render(info);

			var logLine = new LogLine
				{
					TimeStampISO8601 = info.TimeStamp.ToUniversalTime().ToString("o", CultureInfo.InvariantCulture),
					Message = info.FormattedMessage,
					Level = info.Level.Name,
					Type = "amqp",
					Source = new Uri(string.Format("nlog://{0}/{1}", HostName, info.LoggerName))
				};

			logLine.AddField("exception", info.Exception);

			if (info.Properties.Count > 0 && info.Properties.ContainsKey("fields"))
				foreach (var kv in (IEnumerable<KeyValuePair<string, object>>) info.Properties["fields"])
					logLine.AddField(kv.Key, kv.Value);

			if (info.Properties.Count > 0 && info.Properties.ContainsKey("tags"))
				foreach (var tag in (IEnumerable<string>) info.Properties["tags"])
					logLine.AddTag(tag);

			logLine.EnsureADT();

			return JsonConvert.SerializeObject(logLine);
		}

        protected internal override sealed Task<LogWriteOperation> WriteAsync(LogWriteContext context, LogEventInfo entry)
        {
            try
            {
                // add...
                List<LogEventInfo> toFlush = null;
                lock (_lock)
                {
                    this.Buffer.Add(entry);

                    // if...
                    if (this.Buffer.Count >= this.Threshold)
                    {
                        toFlush = new List<LogEventInfo>(this.Buffer);
                        this.Buffer = new List<LogEventInfo>();
                    }
                }

                // anything to flush?
                if (toFlush != null)
                    return FlushAsync(context, toFlush);
                else
                    return Task.FromResult(new LogWriteOperation(this, entry, true));
            }
            catch (Exception ex)
            {
                InternalLogger.Current.Error(string.Format("Failed to write to target '{0}'.", this), ex);
                return Task.FromResult(new LogWriteOperation(this, entry, false));
            }
        }

        protected override void Write(LogEventInfo logEvent)
        {
            // A log event can be either an exception OR a message.
            // If both were provided, then the exception takes precedence over the message.
            if (logEvent.Exception != null)
            {
                Metadata metaData = null;

                // Do we have any metadata
                var bugsnagInterface = logEvent.Exception as IMetadata;
                if (bugsnagInterface != null)
                {
                    metaData = bugsnagInterface.Metadata;
                }

                AddFormattedMessageToMetadata(ref metaData, logEvent.FormattedMessage);

                // Notify Bugsnag of this exception.
                _baseClient.Value.Notify(logEvent.Exception, logEvent.Level.ToSeverity(), metaData);
            }
            else if (!string.IsNullOrWhiteSpace(logEvent.Message))
            {
                // We don't have an exception but we do have a message!
                var exception = new BugsnagException(logEvent.Message);
                _baseClient.Value.Notify(exception, logEvent.Level.ToSeverity());
            }
        }

        /// <summary>
        /// Renders time in the 24-h format (HH:mm:ss.mmm) and appends it to the specified <see cref="StringBuilder" />.
        /// </summary>
        /// <param name="builder">The <see cref="StringBuilder"/> to append the rendered data to.</param>
        /// <param name="logEvent">Logging event.</param>
        protected override void Append(StringBuilder builder, LogEventInfo logEvent)
        {
            DateTime dt = logEvent.TimeStamp;
            if (this.UniversalTime)
            {
                dt = dt.ToUniversalTime();
            }
            
            var culture = GetCulture(logEvent);

            string timeSeparator;
            string ticksSeparator;
            if (culture != null)
            {
#if !SILVERLIGHT
                timeSeparator = culture.DateTimeFormat.TimeSeparator;
#else
                timeSeparator = ":";
#endif
                ticksSeparator = culture.NumberFormat.NumberDecimalSeparator;
            }
            else
            {
                timeSeparator = ":";
                ticksSeparator = ".";
            }

            Append2DigitsZeroPadded(builder, dt.Hour);
            builder.Append(timeSeparator);
            Append2DigitsZeroPadded(builder, dt.Minute);
            builder.Append(timeSeparator);
            Append2DigitsZeroPadded(builder, dt.Second);
            builder.Append(ticksSeparator);
            Append4DigitsZeroPadded(builder, (int)(dt.Ticks % 10000000) / 1000);
        }

 /// <summary>
 /// Does nothing. Optionally it calculates the layout text but
 /// discards the results.
 /// </summary>
 /// <param name="logEvent">The logging event.</param>
 protected internal override void Write(LogEventInfo logEvent)
 {
     if (_formatMessage)
     {
         CompiledLayout.GetFormattedMessage(logEvent);
     }
 }