semantic_logger_ecs_addon 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9d56d0ab9e926ca66fd4889271eb4b5157b41b2b6719b6fc22ebf2acd29745eb
+  data.tar.gz: 518de9e56bd832649fdf2cda28da0a0453461bafa2895ac9cf4169058625d817
+SHA512:
+  metadata.gz: ca8f68e438c4f018e1205b513455120f8b8cefbe311b980614e4a7f739672391362b58203d99696b4d51a21e80f726488ffcb6d03893ec277822fd0caa00e47a
+  data.tar.gz: 30f219878394f83e632e222241a23323cb090323faafe86a0dccb0d430ad7cc4cea95cd942db3070e892b5765f911f6bd4f53893b66a64b992fd97124420f1a4

data.tar.gz.sig

@@ -0,0 +1 @@
+��=3�D�od��q&|}!������UE��d��"��0��}�J�ۮNg����{�P��GL���"���C<aB�{X����:��V�n`���g>�������O�'�\�H�`�O���$����G�i�<�;�8�-�m&�B9�`.+�p	BNl�,�&���\��*���WfvI%���\����k�D愕ւo�d���@�B�P

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright 2021 [Illuminate Software Solutions](https://illuminate.ae).
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,98 @@
+<p align="center">
+  <img src="semantic_logger_ecs_addon.png" alt="Semantic Logger Ecs Addon Icon"/>
+</p>
+
+# Semantic Logger Ecs Addon
+
+[![Gem Version](https://badge.fury.io/rb/semantic_logger_ecs_addon.svg)](http://badge.fury.io/rb/semantic_logger_ecs_addon)
+[![Alchemists Style Guide](https://img.shields.io/badge/code_style-alchemists-brightgreen.svg)](https://www.alchemists.io/projects/code_quality)
+
+<!-- Tocer[start]: Auto-generated, don't remove. -->
+
+## Table of Contents
+
+  - [Features](#features)
+  - [Screencasts](#screencasts)
+  - [Requirements](#requirements)
+  - [Setup](#setup)
+  - [Usage](#usage)
+  - [Development](#development)
+  - [Tests](#tests)
+  - [Versioning](#versioning)
+  - [Code of Conduct](#code-of-conduct)
+  - [Contributions](#contributions)
+  - [License](#license)
+  - [History](#history)
+  - [Credits](#credits)
+
+<!-- Tocer[finish]: Auto-generated, don't remove. -->
+
+## Features
+
+## Screencasts
+
+## Requirements
+
+1. [Ruby](https://www.ruby-lang.org)
+
+## Setup
+
+To install, run:
+
+    gem install semantic_logger_ecs_addon
+
+Add the following to your Gemfile:
+
+    gem "semantic_logger_ecs_addon"
+
+## Usage
+
+## Development
+
+To contribute, run:
+
+    git clone https://github.com/thorion3006/semantic_logger_ecs_addon.git
+    cd semantic_logger_ecs_addon
+    bin/setup
+
+You can also use the IRB console for direct access to all objects:
+
+    bin/console
+
+## Tests
+
+To test, run:
+
+    bundle exec rake
+
+## Versioning
+
+Read [Semantic Versioning](https://semver.org) for details. Briefly, it means:
+
+- Major (X.y.z) - Incremented for any backwards incompatible public API changes.
+- Minor (x.Y.z) - Incremented for new, backwards compatible, public API enhancements/fixes.
+- Patch (x.y.Z) - Incremented for small, backwards compatible, bug fixes.
+
+## Code of Conduct
+
+Please note that this project is released with a [CODE OF CONDUCT](CODE_OF_CONDUCT.md). By
+participating in this project you agree to abide by its terms.
+
+## Contributions
+
+Read [CONTRIBUTING](CONTRIBUTING.md) for details.
+
+## License
+
+Copyright 2021 [Illuminate Software Solutions](https://illuminate.ae).
+Read [LICENSE](LICENSE.md) for details.
+
+## History
+
+Read [CHANGES](CHANGES.md) for details.
+Built with [Gemsmith](https://www.alchemists.io/projects/gemsmith).
+
+## Credits
+
+Developed by [Sajeev Ramasamy]() at
+[Illuminate Software Solutions](https://illuminate.ae).

data/lib/semantic_logger_ecs_addon.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+# Main namespace.
+module SemanticLoggerEcsAddon
+  RootPath = Pathname.getwd
+  BacktraceCleaner = Utils::BacktraceCleaner.new
+  BacktraceCleaner.add_filter { |line| line.gsub(RootPath.to_s, "") }
+  BacktraceCleaner.add_silencer { |line| %r(puma|ruby/gems|rubygems).match?(line) }
+end

data/lib/semantic_logger_ecs_addon/formatters/base.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require "semantic_logger/formatters/base"
+
+module SemanticLoggerEcsAddon
+  module Formatters
+    class Base < SemanticLogger::Formatters::Base
+      # Fields are added by populating this hash.
+      attr_accessor :hash, :time_key, :log_labels, :formatted_payload
+
+      # Parameters
+      #   time_format: [String|Symbol|nil]
+      #     See Time#strftime for the format of this string.
+      #     :iso_8601 Outputs an ISO8601 Formatted timestamp.
+      #     :ms       Output in miliseconds since epoch.
+      #     nil:      Returns Empty string for time ( no time is output ).
+      #     Default: '%Y-%m-%d %H:%M:%S.%<precision>N'
+      #   log_host: [Boolean]
+      #     Whether or not to include hostname in logs
+      #     Default: true
+      #   precision: [Integer]
+      #     How many fractional digits to log times with.
+      #     Default: PRECISION (6, except on older JRuby, where 3)
+      def initialize time_key: :time, **args
+        @time_key = time_key
+        @log_application = true
+        super(**args)
+      end
+
+      # Host name
+      def host
+        log_labels[:host] = logger.host if log_host && logger.host
+      end
+
+      # Application name
+      def application
+        log_labels[:application] = logger.application if logger && logger.application
+      end
+
+      # Environment
+      def environment
+        if log_environment && logger && logger.environment
+          log_labels[:environment] = logger.environment
+        end
+      end
+
+      # Named Tags
+      def named_tags
+        log_labels[:named_tags] = log.named_tags if log.named_tags && !log.named_tags.empty?
+      end
+
+      # Date & time
+      def time
+        hash[time_key] = format_time log.time.utc
+      end
+
+      def labels
+        self.log_labels ||= {}
+        host
+        application
+        environment
+        named_tags
+        hash[:labels] = log_labels unless log_labels.empty?
+      end
+
+      # Log message
+      def message
+        hash[:message] = "#{log.name} -- #{log.cleansed_message}" if log.message
+        hash[:message] = "#{log.metric} -- #{log.metric_amount}" if log.metric && log.metric_amount
+      end
+
+      # Tags
+      def tags
+        hash[:tags] = log.tags if log.tags && !log.tags.empty?
+      end
+
+      # Exception
+      def exception
+        return log.exception if log.exception
+
+        unless log.payload.respond_to?(:empty?) && log.payload[:exception].class.ancestors.include?(StandardError)
+          return
+        end
+
+        log.payload[:exception]
+      end
+
+      def inner_exception exception
+        if exception.respond_to?(:cause) && exception.cause
+          exception.cause
+        elsif exception.respond_to?(:continued_exception) && exception.continued_exception
+          exception.continued_exception
+        elsif exception.respond_to?(:original_exception) && exception.original_exception
+          exception.original_exception
+        end
+      end
+
+      # Call the block for exception and any nested exception
+      def each_exception exception
+        # With thanks to https://github.com/bugsnag/bugsnag-ruby/blob/6348306e44323eee347896843d16c690cd7c4362/lib/bugsnag/notification.rb#L81
+        depth      = 0
+        exceptions = []
+        e = exception
+        while !e.nil? && !exceptions.include?(e) && exceptions.length < 5
+          exceptions << e
+          yield e, depth
+
+          depth += 1
+          e = inner_exception e
+        end
+      end
+
+      def exception_hash exception
+        {
+          "error.type": exception.class.name,
+          "error.message": exception.message,
+          "error.stack_trace": BacktraceCleaner.clean(exception.backtrace)
+        }
+      end
+
+      def error_log?
+        !hash[:"error.type"].nil?
+      end
+
+      def initialize_rack_keys
+        formatted_payload[:request] ||= {}
+        formatted_payload[:response] ||= {}
+        formatted_payload[:metrics] ||= {}
+      end
+
+      def rack_request
+        formatted_payload[:request].merge! formatted_payload.extract!(
+          :controller,
+          :action,
+          :params,
+          :method,
+          :path,
+          :request_id
+        )
+        formatted_payload[:request][:body] = formatted_payload[:request].delete :params
+      end
+
+      def rack_response
+        formatted_payload[:response].merge! formatted_payload.extract!(:status, :status_message)
+      end
+
+      def rack_metrics
+        metrics_keys = formatted_payload.keys.select { |k| k.to_s.end_with?("_runtime") }
+        formatted_payload[:metrics].merge! formatted_payload.extract!(:allocations, *metrics_keys)
+        formatted_payload[:metrics][:object_allocations] =
+          formatted_payload[:metrics].delete :allocations
+      end
+
+      def rack_extract
+        return unless formatted_payload.key? :controller
+
+        initialize_rack_keys
+        rack_request
+        rack_response
+        rack_metrics
+        formatted_payload.delete :format
+      end
+
+      def format_payload
+        return unless log.payload.respond_to?(:empty?) && !log.payload.empty?
+
+        self.formatted_payload = Utils::Hash[**log.payload]
+
+        rack_extract
+      end
+
+      def request
+        hash[:"http.request.id"] = formatted_payload.dig :request, :request_id
+        hash[:"http.request.body.content"] = formatted_payload.dig :request, :body
+        hash[:"http.request.method"] = formatted_payload.dig :request, :method
+      end
+
+      def response
+        hash[:"http.response.body.content"] = formatted_payload.dig :response, :body
+        hash[:"http.response.status_code"] = formatted_payload.dig :response, :status
+      end
+
+      # Ruby file name and line number that logged the message.
+      def file_name_and_line
+        file, line = log.file_name_and_line
+        return unless file
+
+        hash[:"log.origin.file.name"] = file
+        hash[:"log.origin.file.line"] = line.to_i
+      end
+
+      def calculated_log_level
+        return log.level if log.level_index > 2
+
+        (formatted_payload.dig(:response, :status) || 0) >= 500 ? "error" : log.level
+      end
+
+      # ElasticAPM
+      def apm_agent_present_and_running?
+        return false unless defined?(::ElasticAPM)
+
+        ElasticAPM.running?
+      end
+    end
+  end
+end

data/lib/semantic_logger_ecs_addon/formatters/json.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SemanticLoggerEcsAddon
+  module Formatters
+    class Json < Raw
+      # Default JSON time format is ISO8601
+      def initialize time_format: :iso_8601, precision: 3, **args
+        super(time_format: time_format, precision: precision, **args)
+      end
+
+      # Returns log messages in JSON format
+      def call log, logger
+        super(log, logger).to_json
+      end
+    end
+  end
+end

data/lib/semantic_logger_ecs_addon/formatters/raw.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module SemanticLoggerEcsAddon
+  module Formatters
+    class Raw < Base
+      def initialize time_format: :none, time_key: :@timestamp, **args
+        @time_key = time_key
+        super(time_format: time_format, time_key: @time_key, **args)
+      end
+
+      def base
+        time
+        labels
+        message
+        tags
+      end
+
+      def ecs
+        hash[:"ecs.version"] = "1.10"
+      end
+
+      def error
+        root = hash
+        each_exception exception do |e, i|
+          if i.zero?
+            root.merge! exception_hash e
+          else
+            root[:"error.cause"] = exception_hash e
+            root = root[:"error.cause"]
+          end
+        end
+      end
+
+      def event
+        hash[:"event.dataset"] = "#{logger.application}.log"
+        hash[:"event.duration"] = (log.duration || 0) * 1000000
+        hash[:"event.outcome"] = error_log? ? "failure" : "success"
+      end
+
+      def http
+        request
+        response
+      end
+
+      def ecs_log
+        hash[:"log.level"] = calculated_log_level
+        hash[:"log.logger"] = log.name
+        file_name_and_line
+      end
+
+      def ecs_process
+        hash[:"process.thread.name"] = log.thread_name
+        hash[:"process.pid"] = pid
+      end
+
+      def ecs_service
+        hash[:"service.name"] = logger.application
+      end
+
+      def ecs_source
+        hash[:"source.ip"] = formatted_payload.delete :remote_ip
+      end
+
+      def ecs_tracing
+        return unless apm_agent_present_and_running?
+
+        hash[:"transaction.id"] = ElasticAPM.current_transaction&.id
+        hash[:"trace.id"] = ElasticAPM.current_transaction&.trace_id
+        hash[:"span.id"] = ElasticAPM.current_span&.id
+      end
+
+      def ecs_url
+        hash[:"url.path"] = formatted_payload.dig :request, :path
+      end
+
+      def ecs_user
+        hash[:"user.email"] = formatted_payload.dig :user, :email
+        hash[:"user.full_name"] = formatted_payload.dig :user, :full_name
+        hash[:"user.id"] = formatted_payload.dig :user, :id
+        hash[:"user.name"] = formatted_payload.dig :user, :name
+        hash[:"user.domain"] = formatted_payload.dig :user, :type
+      end
+
+      def extras
+        return unless formatted_payload.respond_to?(:empty?) && !formatted_payload.empty?
+
+        hash.merge! formatted_payload.except(:request, :response, :user)
+      end
+
+      # Returns log messages in Hash format
+      def call log, logger
+        self.hash   = {}
+        self.log    = log
+        self.logger = logger
+        format_payload
+
+        base
+        ecs
+        error
+        event
+        http
+        ecs_log
+        ecs_process
+        ecs_service
+        ecs_source
+        ecs_tracing
+        ecs_url
+        ecs_user
+        extras
+
+        hash.compact
+      end
+    end
+  end
+end

data/lib/semantic_logger_ecs_addon/identity.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SemanticLoggerEcsAddon
+  # Gem identity information.
+  module Identity
+    NAME = "semantic_logger_ecs_addon"
+    LABEL = "Semantic Logger Ecs Addon"
+    VERSION = "0.1.0"
+    VERSION_LABEL = "#{LABEL} #{VERSION}"
+    SUMMARY = "A semantic logger formatter that formats the logs according to Elastic Common Schema and adds APM trace data if ElasticAPM is enabled."
+  end
+end

data/lib/semantic_logger_ecs_addon/utils/backtrace_cleaner.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module SemanticLoggerEcsAddon
+  module Utils
+    # Backtraces often include many lines that are not relevant for the context
+    # under review. This makes it hard to find the signal amongst the backtrace
+    # noise, and adds debugging time. With a BacktraceCleaner, filters and
+    # silencers are used to remove the noisy lines, so that only the most relevant
+    # lines remain.
+    #
+    # Filters are used to modify lines of data, while silencers are used to remove
+    # lines entirely. The typical filter use case is to remove lengthy path
+    # information from the start of each line, and view file paths relevant to the
+    # app directory instead of the file system root. The typical silencer use case
+    # is to exclude the output of a noisy library from the backtrace, so that you
+    # can focus on the rest.
+    #
+    #   bc = ActiveSupport::BacktraceCleaner.new
+    #   bc.add_filter   { |line| line.gsub(Rails.root.to_s, '') } # strip the Rails.root prefix
+    #   bc.add_silencer { |line| /puma|rubygems/.match?(line) } # skip any lines from puma or rubygems
+    #   bc.clean(exception.backtrace) # perform the cleanup
+    #
+    # To reconfigure an existing BacktraceCleaner (like the default one in Rails)
+    # and show as much data as possible, you can always call
+    # <tt>BacktraceCleaner#remove_silencers!</tt>, which will restore the
+    # backtrace to a pristine state. If you need to reconfigure an existing
+    # BacktraceCleaner so that it does not filter or modify the paths of any lines
+    # of the backtrace, you can call <tt>BacktraceCleaner#remove_filters!</tt>
+    # These two methods will give you a completely untouched backtrace.
+    #
+    # Borrowed from ActiveSupport gem.
+    class BacktraceCleaner
+      FORMATTED_GEMS_PATTERN = %r(\A[^/]+ \([\w.]+\) )
+      def initialize
+        @filters = []
+        @silencers = []
+        add_gem_filter
+        add_gem_silencer
+        add_stdlib_silencer
+      end
+
+      # Returns the backtrace after all filters and silencers have been run
+      # against it. Filters run first, then silencers.
+      def clean backtrace, kind = :silent
+        filtered = filter_backtrace backtrace
+
+        case kind
+          when :silent
+            silence filtered
+          when :noise
+            noise filtered
+          else
+            filtered
+        end
+      end
+      alias filter clean
+
+      # Adds a filter from the block provided. Each line in the backtrace will be
+      # mapped against this filter.
+      #
+      #   # Will turn "/my/rails/root/app/models/person.rb" into "/app/models/person.rb"
+      #   backtrace_cleaner.add_filter { |line| line.gsub(Rails.root, '') }
+      def add_filter &block
+        @filters << block
+      end
+
+      # Adds a silencer from the block provided. If the silencer returns +true+
+      # for a given line, it will be excluded from the clean backtrace.
+      #
+      #   # Will reject all lines that include the word "puma", like "/gems/puma/server.rb" or "/app/my_puma_server/rb"
+      #   backtrace_cleaner.add_silencer { |line| /puma/.match?(line) }
+      def add_silencer &block
+        @silencers << block
+      end
+
+      # Removes all silencers, but leaves in the filters. Useful if your
+      # context of debugging suddenly expands as you suspect a bug in one of
+      # the libraries you use.
+      def remove_silencers!
+        @silencers = []
+      end
+
+      # Removes all filters, but leaves in the silencers. Useful if you suddenly
+      # need to see entire filepaths in the backtrace that you had already
+      # filtered out.
+      def remove_filters!
+        @filters = []
+      end
+
+      private
+
+      def add_gem_filter
+        gems_paths = (Gem.path | [Gem.default_dir]).map { |p| Regexp.escape(p) }
+        return if gems_paths.empty?
+
+        gems_regexp = %r{\A(#{gems_paths.join '|'})/(bundler/)?gems/([^/]+)-([\w.]+)/(.*)}
+        gems_result = '\3 (\4) \5'
+        add_filter { |line| line.sub(gems_regexp, gems_result) }
+      end
+
+      def add_gem_silencer
+        add_silencer { |line| FORMATTED_GEMS_PATTERN.match?(line) }
+      end
+
+      def add_stdlib_silencer
+        add_silencer { |line| line.start_with?(RbConfig::CONFIG["rubylibdir"]) }
+      end
+
+      def filter_backtrace backtrace
+        @filters.each { |f| backtrace = backtrace.map { |line| f.call(line) } }
+
+        backtrace
+      end
+
+      def silence backtrace
+        @silencers.each { |s| backtrace = backtrace.reject { |line| s.call(line) } }
+
+        backtrace
+      end
+
+      def noise backtrace
+        backtrace.select { |line| @silencers.any? { |s| s.call line } }
+      end
+    end
+  end
+end

data/lib/semantic_logger_ecs_addon/utils/hash.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SemanticLoggerEcsAddon
+  module Utils
+    class Hash < ::Hash
+      # With thanks to https://github.com/rails/rails/blob/83217025a171593547d1268651b446d3533e2019/activesupport/lib/active_support/core_ext/hash/slice.rb#L24
+      # Removes and returns the key/value pairs matching the given keys.
+      #
+      #   hash = { a: 1, b: 2, c: 3, d: 4 }
+      #   hash.extract!(:a, :b) # => {:a=>1, :b=>2}
+      #   hash                  # => {:c=>3, :d=>4}
+      def extract! *keys
+        keys.each_with_object self.class.new do |key, result|
+          result[key] = delete key if key? key
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: semantic_logger_ecs_addon
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sajeev Ramasamy
+autorequire: 
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIERDCCAqygAwIBAgIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt0aG9y
+  aW9uMzAwNi9EQz1nbWFpbC9EQz1jb20wHhcNMjEwNjA4MTAyMzI4WhcNMjIwNjA4
+  MTAyMzI4WjAmMSQwIgYDVQQDDBt0aG9yaW9uMzAwNi9EQz1nbWFpbC9EQz1jb20w
+  ggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQC1entXzzkGYW4W906xYuTr
+  6SQWJXxjPo3GrsWk2L+KXMkY94d1MyJN9IJ0LEy6M7onkmpYSzFqBQ8W+8VRaW0y
+  HVLX1EQRZ9hVd0LV9j5tNx2pDUfXzoxeyNllBd64Ne7r/6D93lAErATC/+v9X6QC
+  cHd17QBGWU8Qb0ePkYY1UvImbePdgLRwu6F2KrUPyn3ewoAvBxsAG74XU6SbORQ2
+  7Hhfh9vvRAcgboXmbyPW+6Z6KN7YdBFnAwI7r/9M9cMRhWwpprTPwKNdAMR0wl+l
+  Bdp7Se7x8fxriTl9TTpgMScGdXIc/m2Pj48W+cnk5Wf2xlcrzXptX3UYelF8f7j3
+  R/Ft2OTSvG0jdYW50mGD96Om0WKM6Ggfx0Dz6pvComl2LNajTSYpHB0xj8d1L6QX
+  UQ2kcIERhnVMqriZauA21b2J9ZLxFf+Ddou7V2AiLMlFi9cPxgj4eHrHLiOylC29
+  sBztOdq1mbfofNe5ifothYpj/uMKYEdXRjlKXUITCFcCAwEAAaN9MHswCQYDVR0T
+  BAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFP9FcvZBAdqH9D6ECTtDk6GsVUYL
+  MCAGA1UdEQQZMBeBFXRob3Jpb24zMDA2QGdtYWlsLmNvbTAgBgNVHRIEGTAXgRV0
+  aG9yaW9uMzAwNkBnbWFpbC5jb20wDQYJKoZIhvcNAQELBQADggGBAK0XGR9ezspt
+  S4Dy1PZ0FeGQXjtUkXcEgY6a/BnJGie9PnHRQZx4fHeVWLH3cDTsy860rTp7tmmw
+  Q/5NIM05AfHabnA/HVqNj/jQt1+EpQS2DGIRNiVtD+Mk/NEyggb4nvg1AJa++IpS
+  XmIAlpJdGwDAsLAv8JlKVbH252QFYVNVTBaikFAQ70GOxL2PnnVPl+GrC23DCpVs
+  eDXVMLZlUe40RTL3Ru6mEMXASB6byp4PwQ7eCaoAUlGQwvdvW09ai0jRI4zqgsAi
+  sSKEjVZRRZcr6wP+zvDReTG5FSVOag1G5g0SivvltgjWqDy2EmY41Qp08jtLu+iQ
+  m3Fy3/MP/izFtIvuQAJaZH+1l83GFI//m8V53ZH7Gg+1VFPlXXmpGQIMR9yZSDBe
+  ewungQjw99puFMSK2d/NFj2L2oSvamT0vGoiH63zwx02vLziB6Jbn34/tuDEqUQ9
+  WEUeG6yA2jP44YUZzNP+Xbjpzr/RvJxAmFw+7SNkHkmP3csIS+0TIg==
+  -----END CERTIFICATE-----
+date: 2021-06-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: semantic_logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+description: 
+email:
+- thorion3006@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE.md
+files:
+- LICENSE.md
+- README.md
+- lib/semantic_logger_ecs_addon.rb
+- lib/semantic_logger_ecs_addon/formatters/base.rb
+- lib/semantic_logger_ecs_addon/formatters/json.rb
+- lib/semantic_logger_ecs_addon/formatters/raw.rb
+- lib/semantic_logger_ecs_addon/identity.rb
+- lib/semantic_logger_ecs_addon/utils/backtrace_cleaner.rb
+- lib/semantic_logger_ecs_addon/utils/hash.rb
+homepage: https://github.com/thorion3006/semantic_logger_ecs_addon
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/thorion3006/semantic_logger_ecs_addon/issues
+  changelog_uri: https://github.com/thorion3006/semantic_logger_ecs_addon/blob/master/CHANGES.md
+  documentation_uri: https://github.com/thorion3006/semantic_logger_ecs_addon
+  source_code_uri: https://github.com/thorion3006/semantic_logger_ecs_addon
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.15
+signing_key: 
+specification_version: 4
+summary: A semantic logger formatter that formats the logs according to Elastic Common
+  Schema and adds APM trace data if ElasticAPM is enabled.
+test_files: []