Exemplo n.º 1
0
 /// <inheritdoc />
 public Task Push(IWavesMessageObject message)
 {
     if (_isRecordingAvailable)
     {
         PendingMessages.Enqueue(message);
     }
     return(Task.CompletedTask);
 }
Exemplo n.º 2
0
 /// <summary>
 /// Converts message to number of log params.
 /// </summary>
 /// <param name="message">Message.</param>
 /// <returns>Returns params.</returns>
 private Task <object[]> GetParamsAsync(IWavesMessageObject message)
 {
     return(Task.FromResult(new object[]
     {
         $"{message.DateTime.ToShortDateString()} {message.DateTime.ToShortTimeString()}",
         $"[{message.Type.ToDescription()}]",
         message.Sender,
         message.ToString(),
     }));
 }
Exemplo n.º 3
0
        /// <inheritdoc />
        public override async Task WriteLogAsync(IWavesMessageObject message)
        {
            if (!IsInitialized)
            {
                return;
            }

            const string text = "{0} {1} {2}: {3}";

            switch (message.Type)
            {
            case WavesMessageType.Information:
                _logger.Info(
                    text,
                    await GetParamsAsync(message));
                break;

            case WavesMessageType.Warning:
                _logger.Warn(
                    text,
                    await GetParamsAsync(message));
                break;

            case WavesMessageType.Error:
                _logger.Error(
                    text,
                    await GetParamsAsync(message));
                break;

            case WavesMessageType.Success:
                _logger.Info(
                    text,
                    await GetParamsAsync(message));
                break;

            case WavesMessageType.Debug:
                _logger.Debug(
                    text,
                    await GetParamsAsync(message));
                break;

            case WavesMessageType.Fatal:
                _logger.Fatal(
                    text,
                    await GetParamsAsync(message));
                break;

            case WavesMessageType.Verbose:
                _logger.Fatal(
                    text,
                    await GetParamsAsync(message));
                break;
            }
        }
Exemplo n.º 4
0
        /// <inheritdoc />
        public async Task WriteLogAsync(IWavesMessageObject message)
        {
            if (!LoggingServices.Any())
            {
                await _pendingLogStorage.Push(message);
            }
            else
            {
                if (message.Type == WavesMessageType.Fatal)
                {
                    // TODO: Fatal handling.
                }

                foreach (var service in LoggingServices)
                {
                    await service.WriteLogAsync(message);
                }
            }

            OnMessageReceived(message);
        }
Exemplo n.º 5
0
        /// <inheritdoc />
        public override Task WriteLogAsync(IWavesMessageObject message)
        {
            var label      = message.Type.ToDescription();
            var labelColor = Colors.GetColor(message.Type);
            var sender     = message.Sender?.ToString();

            if (message.Sender == null)
            {
                sender = "Logger";
            }

            System.Console.WriteLine(
                "[{0}] [{1}]\t{2}: {3}",
                message.DateTime
                .ToString(CultureInfo.CurrentCulture)
                .Pastel(Colors.ConsoleDateTimeColor),
                label.Pastel(labelColor),
                sender.Pastel(Colors.ConsoleSenderColor),
                message.ToString().Pastel(Colors.ConsoleMessageColor));

            return(Task.CompletedTask);
        }
Exemplo n.º 6
0
 /// <summary>
 /// Callback when message received.
 /// </summary>
 /// <param name="e">Message argument.</param>
 protected virtual void OnMessageReceived(IWavesMessageObject e)
 {
     MessageReceived?.Invoke(this, e);
 }
 /// <inheritdoc />
 public abstract Task WriteLogAsync(IWavesMessageObject message);