Created new VTEXSplunkLogger library project

#17

Author: Caldas

src/SampleWebAPI/Logging/VTEXSplunkEntryExtensions.cs renamed to src/VTEXSplunkLogger/ILoggerExtensions.cs

@@ -1,13 +1,13 @@
 using System;
 using Microsoft.Extensions.Logging;
-using VTEX.SampleWebAPI.Logging;
+using Vtex.SplunkLogger;
 
-namespace VTEX.SampleWebAPI
+namespace Vtex
 {
     /// <summary>
     /// This class contains ILogger extension method to simplify the process to record a VTEX log.
     /// </summary>
-    public static class VTEXSplunkEntryExtensions
+    public static class ILoggerExtensions
     {
         static readonly EventId EmptyEventId = new EventId();
 

src/VTEXSplunkLogger/LoggerFactoryExtensions.cs

@@ -0,0 +1,61 @@
+using Microsoft.Extensions.Logging;
+using Splunk.Providers;
+using Splunk.Configurations;
+using Splunk;
+
+namespace Vtex.SplunkLogger
+{
+    /// <summary>
+    /// This class contains ILoggerFactory extension method to simplify the process to add a Splunk logger provider.
+    /// </summary>
+    public static class LoggerFactoryExtensions
+    {
+        /// <summary>
+        /// Add <see cref="T:Splunk.Providers.SplunkHECRawLoggerProvider"/> as provider to logger factory.
+        /// </summary>
+        /// <param name="loggerFactory">Logger factory.</param>
+        /// <param name="configuration">Configuration.</param>
+        /// <param name="formatter">Custom text formatter.</param>
+        public static ILoggerFactory AddHECRawSplunkLogger(this ILoggerFactory loggerFactory, SplunkLoggerConfiguration configuration, ILoggerFormatter formatter)
+        {
+            loggerFactory.AddProvider(new SplunkHECRawLoggerProvider(configuration, formatter));
+            return loggerFactory;
+        }
+
+        /// <summary>
+        /// Add <see cref="T:Splunk.Providers.SplunkHECJsonLoggerProvider"/> as provider to logger factory.
+        /// </summary>
+        /// <param name="loggerFactory">Logger factory.</param>
+        /// <param name="configuration">Configuration.</param>
+        /// <param name="formatter">Custom text formatter.</param>
+        public static ILoggerFactory AddHECJsonSplunkLogger(this ILoggerFactory loggerFactory, SplunkLoggerConfiguration configuration, ILoggerFormatter formatter)
+        {
+            loggerFactory.AddProvider(new SplunkHECJsonLoggerProvider(configuration, formatter));
+            return loggerFactory;
+        }
+
+        /// <summary>
+        /// Add <see cref="T:Splunk.Providers.SplunkTcpLoggerProvider"/> as provider to logger factory.
+        /// </summary>
+        /// <param name="loggerFactory">Logger factory.</param>
+        /// <param name="configuration">Configuration.</param>
+        /// <param name="formatter">Custom text formatter.</param>
+        public static ILoggerFactory AddTcpSplunkLogger(this ILoggerFactory loggerFactory, SplunkLoggerConfiguration configuration, ILoggerFormatter formatter)
+        {
+            loggerFactory.AddProvider(new SplunkTcpLoggerProvider(configuration, formatter));
+            return loggerFactory;
+        }
+
+        /// <summary>
+        /// Add <see cref="T:Splunk.Providers.SplunkUdpLoggerProvider"/> as provider to logger factory.
+        /// </summary>
+        /// <param name="loggerFactory">Logger factory.</param>
+        /// <param name="configuration">Configuration.</param>
+        /// <param name="formatter">Custom text formatter.</param>
+        public static ILoggerFactory AddUdpSplunkLogger(this ILoggerFactory loggerFactory, SplunkLoggerConfiguration configuration, ILoggerFormatter formatter)
+        {
+            loggerFactory.AddProvider(new SplunkUdpLoggerProvider(configuration, formatter));
+            return loggerFactory;
+        }
+    }
+}

src/VTEXSplunkLogger/VTEXEventLevel.cs

@@ -0,0 +1,14 @@
+
+namespace Vtex.SplunkLogger
+{
+    /// <summary>
+    /// This enumeration represents the log event levels defined at VTEX.
+    /// </summary>
+    public enum VTEXEventLevel : int
+    {
+        Critical = 3,
+        Important = 2,
+        Default = 1,
+        Debug = 0,
+    }
+}

src/VTEXSplunkLogger/VTEXLogType.cs

@@ -0,0 +1,13 @@
+
+namespace Vtex.SplunkLogger
+{
+    /// <summary>
+    /// This enumeration represents the log types defined at VTEX.
+    /// </summary>
+    public enum VTEXLogType
+    {
+        Error,
+        Warning,
+        Info
+    }
+}

src/VTEXSplunkLogger/VTEXSplunkEntry.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+
+namespace Vtex.SplunkLogger
+{
+    /// <summary>
+    /// This class represents a VTEX log entry.
+    /// </summary>
+    public class VTEXSplunkEntry
+    {
+        /// <summary>
+        /// Workflow type is a VTEX concept almost similar as `{EventId.Name}` concept.
+        /// </summary>
+        public string WorkflowType { get; private set; }
+
+        /// <summary>
+        /// Workflow instace is a VTEX concept almost similar as `{EventId.Id}` concept.
+        /// </summary>
+        public string WorkflowInstance { get; private set; }
+
+        /// <summary>
+        /// For which account this log happened.
+        /// </summary>
+        public string Account { get; private set; }
+
+        /// <summary>
+        /// Exception to be logged.
+        /// </summary>
+        public Exception Exception { get; private set; }
+
+        /// <summary>
+        /// Extra parameters that will be represented as `{Key}="{Value}"` entries at Splunk text message.
+        /// </summary>
+        public List<Tuple<string, string>> ExtraParameters { get; private set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:VTEX.SampleWebAPI.Logging.VTEXSplunkEntry"/> class.
+        /// </summary>
+        /// <param name="workflowType">Workflow type.</param>
+        /// <param name="workflowInstance">Workflow instance.</param>
+        /// <param name="account">Account.</param>
+        /// <param name="exception">Exception.</param>
+        /// <param name="extraParameters">Extra parameters.</param>
+        public VTEXSplunkEntry(string workflowType, string workflowInstance, string account = "", Exception exception = null, params Tuple<string, string>[] extraParameters)
+        {
+            if (string.IsNullOrWhiteSpace(workflowType))
+                throw new ArgumentNullException(nameof(workflowType));
+
+            if (string.IsNullOrWhiteSpace(workflowInstance))
+                throw new ArgumentNullException(nameof(workflowInstance));
+
+            ExtraParameters = new List<Tuple<string, string>>(extraParameters);
+            WorkflowType = workflowType;
+            WorkflowInstance = workflowInstance;
+            Account = account;
+            Exception = exception;
+
+            if (exception != null)
+            {
+                ExtraParameters.Add(new Tuple<string, string>("exception_type", exception.GetType().FullName));
+                ExtraParameters.Add(new Tuple<string, string>("exception_message", exception.Message));
+            }
+        }
+    }
+}

src/VTEXSplunkLogger/VTEXSplunkLogger.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <Description>VTEX SplunkLogger library</Description>
+    <ReleaseVersion>1.0.1</ReleaseVersion>
+    <RootNamespace>Vtex.SplunkLogger</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\SplunkLogger\SplunkLogger.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.PlatformAbstractions" Version="1.1.0" />
+  </ItemGroup>
+</Project>

src/VTEXSplunkLogger/VTEXSplunkLoggerFormatter.cs

@@ -0,0 +1,168 @@
+using System;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using Microsoft.Extensions.Logging;
+using Splunk;
+
+namespace Vtex.SplunkLogger
+{
+    /// <summary>
+    /// This class contains all methods to format a Log event into a VTEX standard text.
+    /// </summary>
+    /// <remarks>
+    /// At our Splunk environment at VTEX we expect certain standard of text to be processed and
+    /// we also have field extraction rules to be applied.
+    /// Thats the reason why we use a custom LoggerFormmater.
+    /// </remarks>
+    public class VTEXSplunkLoggerFormatter : ILoggerFormatter
+    {
+        const string DateTimeFormat = "yyyy-MM-ddTHH:mm:ss.fffZ";
+
+        readonly string appVersion;
+        readonly string host;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:VTEX.SampleWebAPI.Logging.VTEXSplunkLoggerFormatter"/> class.
+        /// </summary>
+        public VTEXSplunkLoggerFormatter()
+        {
+            appVersion = Microsoft.Extensions.PlatformAbstractions.PlatformServices.Default.Application.ApplicationVersion;
+            host = GetHost();
+        }
+
+        /// <summary>
+        /// Format the specified logLevel, eventId, state and exception into log string entry.
+        /// </summary>
+        /// <returns>Formatted log string.</returns>
+        /// <param name="logLevel">Log level.</param>
+        /// <param name="eventId">Event identifier.</param>
+        /// <param name="state">Log object state.</param>
+        /// <param name="exception">Log exception.</param>
+        /// <typeparam name="T">Log entry.</typeparam>
+        public string Format<T>(LogLevel logLevel, EventId eventId, T state, Exception exception)
+        {
+            string log;
+            if (state is VTEXSplunkEntry)
+            {
+                var splunkEntry = state as VTEXSplunkEntry;
+                var dateTime = DateTime.UtcNow.ToString(DateTimeFormat);
+                string extraData = string.Empty;
+                if (splunkEntry.ExtraParameters != null && splunkEntry.ExtraParameters.Count > 0)
+                    extraData = string.Join(" ", splunkEntry.ExtraParameters.Select(part => { return $"{part.Item1}=\"{part.Item2}\""; }));
+                string account = splunkEntry.Account;
+                if (string.IsNullOrWhiteSpace(splunkEntry.Account))
+                    account = "-";
+                log = string.Format($"{dateTime} VTEXLog,splunkmanager,{host},{GetVTEXEventLevel(logLevel)},{GetVTEXLogType(logLevel)},\"{splunkEntry.WorkflowType}\",\"{splunkEntry.WorkflowInstance}\",{account},{appVersion} {extraData}");
+            }
+            else
+            {
+                var eventSegment = "";
+                if (!string.IsNullOrWhiteSpace(eventId.Name))
+                    eventSegment = $"Event '{eventId.Name}' on {eventId.Id}";
+                var exceptionSegment = "";
+                if (exception != null)
+                    exceptionSegment = $"Exception type: {exception.GetType().FullName}. Exception message: {exception.Message}";
+                log = string.Format($"[{logLevel}] {eventSegment} {state.ToString()}. {exceptionSegment}");
+            }
+            return log;
+        }
+
+        /// <summary>
+        /// Formats the specified logLevel, eventId, state and exception into json entry.
+        /// </summary>
+        /// <returns>The json.</returns>
+        /// <param name="logLevel">Log level.</param>
+        /// <param name="eventId">Event identifier.</param>
+        /// <param name="state">Log object state.</param>
+        /// <param name="exception">Log exception.</param>
+        /// <typeparam name="T">Log entry.</typeparam>
+        public SplunkJSONEntry FormatJson<T>(LogLevel logLevel, EventId eventId, T state, Exception exception)
+        {
+            return new SplunkJSONEntry(Format(logLevel, eventId, state, exception), 0, host, string.Empty, "Log");
+        }
+
+        /// <summary>
+        /// Method created to get AWS EC2 host Id, or set `dev` as host if AWS internal call fails.
+        /// </summary>
+        string GetHost()
+        {
+            string ec2Host = string.Empty;
+            try
+            {
+                using (HttpClient httpClient = new HttpClient())
+                {
+                    TimeSpan timeSpan = new TimeSpan(0, 0, 5);
+                    var cancellationTokenSource = new CancellationTokenSource((int)timeSpan.TotalMilliseconds);
+                    httpClient.Timeout = timeSpan;
+                    httpClient.BaseAddress = new Uri("http://169.254.169.254/latest/meta-data/");
+                    ec2Host = httpClient
+                        .GetAsync("instance-id", cancellationTokenSource.Token)
+                        .Result
+                        .Content
+                        .ReadAsStringAsync()
+                        .Result;
+                }
+            }
+            catch
+            {
+                ec2Host = "dev";
+            }
+            return ec2Host;
+        }
+
+        /// <summary>
+        /// Based on LogLevel we define the correspondent VTEX event level.
+        /// </summary>
+        /// <returns>VTEX event level.</returns>
+        string GetVTEXEventLevel(LogLevel logLevel)
+        {
+            VTEXEventLevel eventLevel = VTEXEventLevel.Debug;
+            switch (logLevel)
+            {
+                case LogLevel.Critical:
+                    eventLevel = VTEXEventLevel.Critical;
+                    break;
+                case LogLevel.Warning:
+                case LogLevel.Error:
+                    eventLevel = VTEXEventLevel.Important;
+                    break;
+                case LogLevel.Information:
+                    eventLevel = VTEXEventLevel.Default;
+                    break;
+                case LogLevel.Trace:
+                case LogLevel.Debug:
+                case LogLevel.None:
+                    eventLevel = VTEXEventLevel.Debug;
+                    break;
+            }
+            return eventLevel.ToString().ToLower();
+        }
+
+        /// <summary>
+        /// Based on LogLevel we define the correspondent VTEX log type.
+        /// </summary>
+        /// <returns>VTEX log type.</returns>
+        string GetVTEXLogType(LogLevel logLevel)
+        {
+            VTEXLogType logType = VTEXLogType.Info;
+            switch (logLevel)
+            {
+                case LogLevel.Critical:
+                case LogLevel.Error:
+                    logType = VTEXLogType.Error;
+                    break;
+                case LogLevel.Warning:
+                    logType = VTEXLogType.Warning;
+                    break;
+                case LogLevel.Debug:
+                case LogLevel.Information:
+                case LogLevel.Trace:
+                case LogLevel.None:
+                    logType = VTEXLogType.Info;
+                    break;
+            }
+            return logType.ToString().ToLower();
+        }
+    }
+}