/// <summary>
        /// Write a single message line to Sumo Logic
        /// </summary>
        /// <param name="message">the message line to be sent</param>
        /// <param name="categoryName">not used for now</param>
        public void WriteLine(String message, String categoryName)
        {
            if (null == message)
            {
                return;
            }

            if (sumoLogicMessageSender == null || !sumoLogicMessageSender.CanTrySend)
            {
                DebuggingLogger?.Warn("Sender is not initialized. Dropping log entry");
                return;
            }

            String line = string.Concat(
                message.TrimEnd(Environment.NewLine.ToCharArray()),
                Environment.NewLine);

            if (LoggerOptions.IsBuffered)
            {
                messagesQueue.Add(line);
            }
            else
            {
                WriteLineToSumo(line);
            }
        }
        /// <summary>
        /// Write a single message line to Sumo Logic
        /// </summary>
        /// <param name="message">the message line to be sent</param>
        /// <param name="ex">Exception if any</param>
        /// <param name="categoryName">Logger Category Name</param>
        /// <param name="logLevel">Log message level.</param>
        public void WriteLine(string message, Exception ex, string categoryName, LogLevel logLevel)
        {
            if (string.IsNullOrWhiteSpace(message) && ex == null)
            {
                return;
            }

            if (sumoLogicMessageSender == null || !sumoLogicMessageSender.CanTrySend)
            {
                DebuggingLogger?.Warn("Sender is not initialized. Dropping log entry");
                return;
            }

            message = message ?? string.Empty;

            var fullMessage = LoggerOptions.MessageFormatterFunc(message.TrimEnd(Environment.NewLine.ToCharArray()), ex, categoryName,
                                                                 logLevel, externalScopeProviderEnforcer.GetScopeProperties());
            var line = string.Concat(fullMessage, Environment.NewLine);

            if (LoggerOptions.IsBuffered)
            {
                messagesQueue.Add(line);
            }
            else
            {
                WriteLineToSumo(line);
            }
        }
Exemplo n.º 3
0
        /// <summary>
        /// Write a single message line to Sumo Logic
        /// </summary>
        /// <param name="message">the message line to be sent</param>
        /// <param name="categoryName">not used for now</param>
        public void WriteLine(string message, string categoryName, LogLevel logLevel)
        {
            if (null == message)
            {
                return;
            }

            if (sumoLogicMessageSender == null || !sumoLogicMessageSender.CanTrySend)
            {
                DebuggingLogger?.Warn("Sender is not initialized. Dropping log entry");
                return;
            }

            var builder = new StringBuilder();

            if (includeCategory)
            {
                builder.Append(" [");
                builder.Append(logLevel.ToString());
                builder.Append("] ");
                builder.Append(categoryName);
            }

            var scopeProvider = ScopeProvider;

            if (scopeProvider != null)
            {
                scopeProvider.ForEachScope((scope, stringBuilder) =>
                {
                    stringBuilder.Append(this.scopeSeparator).Append(scope);
                }, builder);

                builder.Append(this.scopeSeparator);
            }
            else if (includeCategory)
            {
                builder.Append(this.scopeSeparator);
            }


            builder.AppendLine(message.Trim());

            if (LoggerOptions.IsBuffered)
            {
                messagesQueue.Add(builder.ToString());
            }
            else
            {
                WriteLineToSumo(builder.ToString());
            }
        }
Exemplo n.º 4
0
        /// <inheritdoc/>
        /// <exception cref="ArgumentNullException">Thrown when <paramref name="logEvent"/> is <c>null</c>.</exception>
        public void Emit(LogEvent logEvent)
        {
            if (logEvent is null)
            {
                throw new ArgumentNullException(nameof(logEvent));
            }

            if (!_messageSender.CanSend)
            {
                _log.Warn("Sink not initialized. Dropping log entry");

                return;
            }

            _messageQueue.Add(_formatter.Format(logEvent));
        }