public void ShouldSerializeMessageWithAdditionalFields()
        {
            var dateTime = new DateTime(2015, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
            var message = new GelfMessageBuilder("Backtrace here\n\nmore stuff", "example.org", dateTime, GelfLevel.Alert)
                .SetAdditionalField(GelfAdditionalFields.Facility, "facility")
                .SetAdditionalField(GelfAdditionalFields.LoggerName, "loggerName")
                .SetAdditionalField(GelfAdditionalFields.ThreadName, "threadName")
                .SetAdditionalField(GelfAdditionalFields.SourceFileName, "sourceFileName")
                .SetAdditionalField(GelfAdditionalFields.SourceLineNumber, "sourceLineNumber")
                .SetAdditionalField(GelfAdditionalFields.SourceClassName, "sourceClassName")
                .SetAdditionalField(GelfAdditionalFields.SourceMethodName, "sourceMethodName")
                .ToMessage();

            var serializedMessage = Encoding.UTF8.GetString(serializer.Serialize(message));
            Assert.AreEqual("{\"version\":\"1.1\"," +
                            "\"host\":\"example.org\"," +
                            "\"short_message\":\"Backtrace here\\n\\nmore stuff\"," +
                            "\"full_message\":\"Backtrace here\\n\\nmore stuff\"," +
                            "\"timestamp\":1420070400," +
                            "\"level\":1," +
                            "\"_facility\":\"facility\"," +
                            "\"_loggerName\":\"loggerName\"," +
                            "\"_threadName\":\"threadName\"," +
                            "\"_sourceFileName\":\"sourceFileName\"," +
                            "\"_sourceLineNumber\":\"sourceLineNumber\"," +
                            "\"_sourceClassName\":\"sourceClassName\"," +
                            "\"_sourceMethodName\":\"sourceMethodName\"}", serializedMessage);
        }
Example #2
0
 protected override void Write(LogEventInfo loggingEvent)
 {
     try
     {
         var renderedEvent = Layout.Render(loggingEvent);
         var messageBuilder = new GelfMessageBuilder(renderedEvent, HostName, loggingEvent.TimeStamp, ToGelf(loggingEvent.Level))
             .SetAdditionalField(GelfAdditionalFields.Facility, Facility)
             .SetAdditionalField(GelfAdditionalFields.LoggerName, loggingEvent.LoggerName);
         if (IncludeSource)
         {
             var userStackFrame = loggingEvent.UserStackFrame;
             if (userStackFrame != null)
             {
                 messageBuilder.SetAdditionalField(GelfAdditionalFields.SourceFileName, userStackFrame.GetFileName());
                 messageBuilder.SetAdditionalField(GelfAdditionalFields.SourceLineNumber, userStackFrame.GetFileLineNumber().ToString(CultureInfo.InvariantCulture));
             }
         }
         if (IncludeStackTrace)
         {
             var exception = loggingEvent.Exception;
             if (exception != null)
             {
                 messageBuilder.SetAdditionalField(GelfAdditionalFields.ExceptionMessage, exception.Message);
                 messageBuilder.SetAdditionalField(GelfAdditionalFields.ExceptionStackTrace, exception.StackTrace);
             }
         }
         transport.Send(messageBuilder.ToMessage());
     }
     catch (Exception exception)
     {
         logger.Error("Failed to send message", exception);
     }
 }
Example #3
0
        protected override void Write(LogEventInfo loggingEvent)
        {
            try
            {
                var renderedEvent = Layout.Render(loggingEvent);
                var messageBuilder = new GelfMessageBuilder(renderedEvent, HostName, loggingEvent.TimeStamp, ToGelf(loggingEvent.Level))
                    .SetAdditionalField(GelfAdditionalFields.Facility, Facility)
                    .SetAdditionalField(GelfAdditionalFields.LoggerName, loggingEvent.LoggerName);
                if (IncludeSource)
                {
                    var userStackFrame = loggingEvent.UserStackFrame;
                    if (userStackFrame != null)
                    {
                        messageBuilder.SetAdditionalField(GelfAdditionalFields.SourceFileName, userStackFrame.GetFileName());
                        messageBuilder.SetAdditionalField(GelfAdditionalFields.SourceLineNumber, userStackFrame.GetFileLineNumber().ToString(CultureInfo.InvariantCulture));
                    }
                }
                if (IncludeStackTrace)
                {
                    var exception = loggingEvent.Exception;
                    if (exception != null)
                    {
                        messageBuilder.SetAdditionalField(GelfAdditionalFields.ExceptionMessage, exception.Message);
                        messageBuilder.SetAdditionalField(GelfAdditionalFields.ExceptionStackTrace, exception.StackTrace);
                    }
                }

                //Add user-defined fields from config
                foreach (GelfParameterInfo param in Parameters)
                {
                    var value = param.Layout.Render(loggingEvent);
                    if (string.IsNullOrWhiteSpace(value))
                        continue;
                    var key = param.Name;

                    long longValue;
                    decimal decimalValue;
                    bool boolValue;

                    if (param.Type == GelfParameterInfoType.Boolean
                        && BooleanTryParse(value, out boolValue))
                    {
                        messageBuilder.SetAdditionalField(key, boolValue);
                    }
                    else if (param.Type == GelfParameterInfoType.Integer
                        && long.TryParse(value, out longValue))
                    {
                        messageBuilder.SetAdditionalField(key, longValue);
                    }
                    else if (param.Type == GelfParameterInfoType.Decimal
                        && decimal.TryParse(value, out decimalValue))
                    {
                        messageBuilder.SetAdditionalField(key, decimalValue);
                    }
                    else
                    {
                        messageBuilder.SetAdditionalField(key, value);
                    }
                }

                //Add log event properties
                if (IncludeEventProperties)
                {
                    foreach (var property in loggingEvent.Properties)
                    {
                        messageBuilder.SetAdditionalField(property.Key.ToString(), property.Value.ToString());
                    }
                }

                transport.Send(messageBuilder.ToMessage());
            }
            catch (Exception exception)
            {
                logger.Error("Failed to send message", exception);
            }
        }
Example #4
0
        protected override void Append(LoggingEvent loggingEvent)
        {
            try
            {
                var renderedEvent = RenderLoggingEvent(loggingEvent);
                var messageBuilder = new GelfMessageBuilder(renderedEvent, HostName, loggingEvent.TimeStamp, loggingEvent.Level.ToGelf())
                    .SetAdditionalField(GelfAdditionalFields.Facility, Facility)
                    .SetAdditionalField(GelfAdditionalFields.LoggerName, loggingEvent.LoggerName)
                    .SetAdditionalField(GelfAdditionalFields.ThreadName, loggingEvent.ThreadName);

                foreach (var item in _staticOutFields)
                {
                    messageBuilder.SetAdditionalField(item.Name, item.Value);
                }

                if (IncludeSource)
                {
                    var locationInformation = loggingEvent.LocationInformation;
                    if (locationInformation != null)
                    {
                        messageBuilder.SetAdditionalField(GelfAdditionalFields.SourceFileName, locationInformation.FileName)
                            .SetAdditionalField(GelfAdditionalFields.SourceClassName, locationInformation.ClassName)
                            .SetAdditionalField(GelfAdditionalFields.SourceMethodName, locationInformation.MethodName)
                            .SetAdditionalField(GelfAdditionalFields.SourceLineNumber, locationInformation.LineNumber);
                    }
                }
                if (IncludeStackTrace)
                {
                    var exception = loggingEvent.ExceptionObject;
                    if (exception != null)
                    {
                        messageBuilder.SetAdditionalField(GelfAdditionalFields.ExceptionMessage, exception.Message);
                        messageBuilder.SetAdditionalField(GelfAdditionalFields.ExceptionStackTrace, exception.StackTrace);
                    }
                }
                transport.Send(messageBuilder.ToMessage());
            }
            catch (Exception exception)
            {
                logger.Error("Unable to send logging event to remote host", exception);
            }
        }