C# LoggingEvent.GetExceptionString方法代码示例

        protected override void Append(LoggingEvent loggingEvent)
        {
            var entity = new LogEventAzure();

            try
            {
                entity.Message = loggingEvent.RenderedMessage;
                entity.Level = loggingEvent.Level.Name;
                entity.LoggerName = loggingEvent.LoggerName;
                entity.ThreadName = loggingEvent.ThreadName;
                entity.CorrelationId = null;
                entity.Value = 0.0;
                entity.UnitType = null;
                entity.Exception = null;

                if (!string.IsNullOrEmpty(loggingEvent.GetExceptionString()))
                    entity.Exception = loggingEvent.ExceptionObject.Message;

                if (loggingEvent.Properties["correlationId"] != null)
                    entity.CorrelationId = loggingEvent.Properties["correlationId"].ToString();

                if (loggingEvent.Properties["value"] != null)
                    entity.Value = Convert.ToDouble(loggingEvent.Properties["value"]);

                if (loggingEvent.Properties["unitType"] != null)
                    entity.UnitType = loggingEvent.Properties["unitType"].ToString();

                TableOperation insertOperation = TableOperation.Insert(entity);
                _table.Execute(insertOperation);
            }
            catch (Exception e)
            {
                ErrorHandler.Error("Could not write log entry", e);
            }
        }

        public AzureLoggingEventEntity(LoggingEvent e, PartitionKeyTypeEnum partitionKeyType)
        {
            Domain = e.Domain;
            Identity = e.Identity;
            Level = e.Level.ToString();
            var sb = new StringBuilder(e.Properties.Count);
            foreach (DictionaryEntry entry in e.Properties)
            {
                sb.AppendFormat("{0}:{1}", entry.Key, entry.Value);
                sb.AppendLine();
            }
            Properties = sb.ToString();
            Message = e.RenderedMessage + Environment.NewLine + e.GetExceptionString();
            ThreadName = e.ThreadName;
            EventTimeStamp = e.TimeStamp;
            UserName = e.UserName;
            Location = e.LocationInformation.FullInfo;
            ClassName = e.LocationInformation.ClassName;
            FileName = e.LocationInformation.FileName;
            LineNumber = e.LocationInformation.LineNumber;
            MethodName = e.LocationInformation.MethodName;
            StackFrames = e.LocationInformation.StackFrames;

            if (e.ExceptionObject != null)
            {
                Exception = e.ExceptionObject.ToString();
            }

            PartitionKey = e.MakePartitionKey(partitionKeyType);
            RowKey = e.MakeRowKey();
        }

		private XMS.Core.Logging.ServiceModel.Log CreateLogData(LoggingEvent logEvent)
		{
			XMS.Core.Logging.ServiceModel.Log log = new ServiceModel.Log();

			log.LogTime = logEvent.TimeStamp;
			log.Level = logEvent.Level.ToString();
			log.Message = logEvent.RenderedMessage;
			log.Exception = logEvent.GetExceptionString();
			log.Category = (string)logEvent.LookupProperty("Category");

			log.AppName = RunContext.AppName;
			log.AppVersion = RunContext.AppVersion;
			log.Machine = RunContext.Machine;

			log.UserId = logEvent.Properties.Contains("UserId") ? (int)logEvent.LookupProperty("UserId") : -1;
			log.UserIP = (string)logEvent.LookupProperty("UserIP");

			log.RawUrl = (string)logEvent.LookupProperty("RawUrl");


			log.AgentName = (string)logEvent.LookupProperty("AppAgent-Name");
			log.AgentVersion = (string)logEvent.LookupProperty("AppAgent-Version");
			log.AgentPlatform = (string)logEvent.LookupProperty("AppAgent-Platform");
			log.MobileDeviceManufacturer = (string)logEvent.LookupProperty("AppAgent-MobileDeviceManufacturer");
			log.MobileDeviceModel = (string)logEvent.LookupProperty("AppAgent-MobileDeviceModel");
			log.MobileDeviceId = (string)logEvent.LookupProperty("AppAgent-MobileDeviceId");

			return log;
		}

        public AzureDynamicLoggingEventEntity(LoggingEvent e, PartitionKeyTypeEnum partitionKeyType)
        {
            this["Domain"] = e.Domain;
            this["Identity"] = e.Identity;
            this["Level"] = e.Level.ToString();
            this["LoggerName"] = e.LoggerName;
            this["Message"] = e.RenderedMessage + Environment.NewLine + e.GetExceptionString();
            this["EventTimeStamp"] = e.TimeStamp;
            this["ThreadName"] = e.ThreadName;
            this["UserName"] = e.UserName;
            this["Location"] = e.LocationInformation.FullInfo;

            if (e.ExceptionObject != null)
            {
                this["Exception"] = e.ExceptionObject.ToString();
            }
            
            foreach (DictionaryEntry entry in e.Properties)
            {
                var key = entry.Key.ToString()
                    .Replace(":", "_")
                    .Replace("@", "_")
                    .Replace(".", "_");
                this[key] = entry.Value;
            }

            Timestamp = e.TimeStamp;
            PartitionKey = e.MakePartitionKey(partitionKeyType);
            RowKey = e.MakeRowKey();
        }

        internal static string GetXmlString(LoggingEvent loggingEvent)
        {
            var xmlMessage = new XElement(
                "LogEntry",
                new XElement("UserName", loggingEvent.UserName),
                new XElement("TimeStamp",
                             loggingEvent.TimeStamp.ToString(CultureInfo.InvariantCulture)),
                new XElement("ThreadName", loggingEvent.ThreadName),
                new XElement("LoggerName", loggingEvent.LoggerName),
                new XElement("Level", loggingEvent.Level.ToString()),
                new XElement("Identity", loggingEvent.Identity),
                new XElement("Domain", loggingEvent.Domain),
                new XElement("CreatedOn", DateTime.UtcNow.ToString(CultureInfo.InvariantCulture)),
                new XElement("RenderedMessage", loggingEvent.RenderedMessage)
                );

            string exceptionStr = loggingEvent.GetExceptionString();

            if (!string.IsNullOrEmpty(exceptionStr))
            {
                xmlMessage.Add(new XElement("Exception", exceptionStr));
            }

            return xmlMessage.ToString();
        }

		/// <summary>
		/// Write the exception text to the output
		/// </summary>
		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
		/// <param name="loggingEvent">the event being logged</param>
		/// <remarks>
		/// <para>
		/// If an exception object is stored in the logging event
		/// it will be rendered into the pattern output with a
		/// trailing newline.
		/// </para>
		/// <para>
		/// If there is no exception then nothing will be output
		/// and no trailing newline will be appended.
		/// It is typical to put a newline before the exception
		/// and to have the exception as the last data in the pattern.
		/// </para>
		/// </remarks>
		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
		{
			string exceptionString = loggingEvent.GetExceptionString();
			if (exceptionString != null && exceptionString.Length > 0) 
			{
				writer.WriteLine(exceptionString);
			}
		}

        /// <summary>
        /// Formats email's subject using <see cref="SubjectLayout"/>.
        /// 
        /// <see cref="AppenderSkeleton.RenderLoggingEvent(TextWriter, log4net.Core.LoggingEvent)"/>
        /// </summary>
        /// <param name="loggingEvent"></param>
        protected void FormatSubject(LoggingEvent loggingEvent)
        {
            var layout = SubjectLayout;

            if (layout == null)
            {
                LogLog.Warn("SmtpAppender: No subjectLayout configured for appender [" + Name + "]");
                return;
            }

            var writer = new StringWriter(System.Globalization.CultureInfo.InvariantCulture);

            if (layout.IgnoresException)
            {
                string exceptionStr = loggingEvent.GetExceptionString();
                if (!string.IsNullOrEmpty(exceptionStr))
                {
                    // render the event and the exception
                    layout.Format(writer, loggingEvent);
                    writer.WriteLine(exceptionStr);
                }
                else
                {
                    // there is no exception to render
                    layout.Format(writer, loggingEvent);
                }
            }
            else
            {
                // The layout will render the exception
                layout.Format(writer, loggingEvent);
            }

            string subject = writer.ToString();

            //  Take first line only (Subject may not contain any control chars)
            var idx = subject.IndexOf("\r\n");
            if (idx != -1)
            {
                subject = subject.Substring(0, idx);
            }

            //  Cut subject to specified length
            if (!string.IsNullOrEmpty(SubjectMaxLength))
            {
                int maxLength;
                if (int.TryParse(SubjectMaxLength, out maxLength))
                {
                    if (maxLength > 0 && subject.Length > maxLength)
                    {
                        subject = subject.Substring(0, maxLength);
                    }
                }
            }

            Subject = subject;
        }

 protected override void Append(LoggingEvent loggingEvent)
 {
     TraderHubUtil.BroadcastLogMessage(new LogMessage()
     {
         LoggerName = loggingEvent.LoggerName,
         TimeStamp = loggingEvent.TimeStamp,
         Level = loggingEvent.Level.ToString(),
         Message = loggingEvent.RenderedMessage,
         ExceptionString = loggingEvent.GetExceptionString()
     });
 }

        public void Log_exception_string_without_object()
        {
            var eventData = new LoggingEventData()
            {
                LoggerName = "logger",
                Message = "the message",
                ExceptionString = "Exception string",
            };
            var loggingEvent = new LoggingEvent(eventData);

            var logEvent = _logEventFactory.CreateLogEvent(loggingEvent);
            Assert.AreEqual(loggingEvent.RenderedMessage, logEvent["Message"]);
            Assert.AreEqual(loggingEvent.GetExceptionString(), logEvent["Exception"]);
            Assert.IsFalse(logEvent.ContainsKey("ExceptionObject"));
        }

        public void Log_exception()
        {
            var loggingEvent = new LoggingEvent(
                this.GetType(),
                null,
                "logger.name",
                Level.Info,
                "message",
                new Exception("Exception string"));

            var logEvent = _logEventFactory.CreateLogEvent(loggingEvent);
            Assert.AreEqual(loggingEvent.RenderedMessage, logEvent["Message"]);
            Assert.AreEqual(loggingEvent.GetExceptionString(), logEvent["Exception"]);
            Assert.AreEqual(loggingEvent.ExceptionObject.Message, ((JsonSerializableException)logEvent["ExceptionObject"]).Message);
        }

        public AzureLayoutLoggingEventEntity(LoggingEvent e, PartitionKeyTypeEnum partitionKeyType, ILayout layout)
        {
            Level = e.Level.ToString();
            Message = e.RenderedMessage + Environment.NewLine + e.GetExceptionString();
            ThreadName = e.ThreadName;
            EventTimeStamp = e.TimeStamp;
            using (var w = new StringWriter())
            {
                layout.Format(w, e);
                Message = w.ToString();
            }

            PartitionKey = e.MakePartitionKey(partitionKeyType);
            RowKey = e.MakeRowKey();
        }

 private JObject PreParse(LoggingEvent loggingEvent)
 {
     var exceptionString = loggingEvent.GetExceptionString();
      if (string.IsNullOrWhiteSpace(exceptionString))
      {
     exceptionString = null; //ensure empty strings aren't included in the json output.
      }
      var jobject = new JObject();
      jobject.Add("level", loggingEvent.Level.DisplayName);
      jobject.Add("time", loggingEvent.TimeStamp.ToString("yyyyMMdd HHmmss.fff zzz"));
      jobject.Add("machine", Environment.MachineName);
      jobject.Add("process", _currentProcess.ProcessName);
      jobject.Add("thread", loggingEvent.ThreadName);
       jobject.Add("message", JObject.FromObject(loggingEvent.MessageObject));
      jobject.Add("ex", exceptionString);
      return jobject;
 }

 private object PreParse(LoggingEvent loggingEvent)
 {
     var exceptionString = loggingEvent.GetExceptionString();
     if (string.IsNullOrWhiteSpace(exceptionString))
     {
         exceptionString = null; //ensure empty strings aren't included in the json output.
     }
     return new
            	{
            		level = loggingEvent.Level.DisplayName,
            		time = loggingEvent.TimeStamp.ToString("yyyyMMdd HHmmss.fff zzz"),
                 machine = Environment.MachineName,
                 process = _currentProcess.ProcessName,
                 thread = loggingEvent.ThreadName,
                 message = loggingEvent.MessageObject,
                 ex = exceptionString,
            	};
 }

 protected override void Append(LoggingEvent loggingEvent)
 {
     try
     {
         QueueLog(new LogMessage()
         {
             Exception = loggingEvent.GetExceptionString(),
             Level = loggingEvent.Level.Name,
             Message = loggingEvent.RenderedMessage,
             Thread = loggingEvent.ThreadName,
             Timestamp = loggingEvent.TimeStamp.ToString()
         });
     }
     catch (Exception ex)
     {
         //hide any exceptions to prevent logging exceptions/bottlenecks
     }
 }

        private object PreParse(LoggingEvent loggingEvent)
        {
            var exceptionString = loggingEvent.GetExceptionString();
            var message = loggingEvent.RenderedMessage;

            //ensure empty strings aren't included in the json output. Pass null instead.
            return new
                   	{
                   		level = loggingEvent.Level.DisplayName,
                   		time = loggingEvent.TimeStamp.ToString("yyyyMMdd HHmmss.fff zzz"),
                        machine = Environment.MachineName,
                        logger = loggingEvent.LoggerName,
                        process = loggingEvent.Domain,
                        thread = loggingEvent.ThreadName,
                        message = string.IsNullOrWhiteSpace(message) ? null : message,
                        ex = string.IsNullOrWhiteSpace(exceptionString) ? null : exceptionString,
                   	};
        }