applicaster-logger 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 14eb9fb38934bed703677d907edb9a25dbf3c6fa
-  data.tar.gz: a99a2cb2212f1d8d3846fb3790b254d030b9afbc
+  metadata.gz: 7fd75cd4993d54d8fa1c251c31497786172a0923
+  data.tar.gz: 7132629f33b219958435d825b07d926ed002ff0b
 SHA512:
-  metadata.gz: 7240f155356278285e8fd0a7c6c2523acf49dfeb78eab01ffaf66a27c4fa5484b6f32946e902e07f17754780ed2d34bd8d17c85e93d503c0531f4b20873afb43
-  data.tar.gz: 89a300fbbf6c3eb294c0408a7d64178443354061d718ca37e35cfa2f571a9c76266ccc1d17f30e18980df90b04fa38af194e7c3445f6ec7b78c9264e14e20477
+  metadata.gz: 724db349ba49009faab7624ac1bd482d6c486d28d52e75d5b993836cb2b50e37f7045d74889391d25e2bc3855ae3a28327a38def721c042313fdaa3bef0ee145
+  data.tar.gz: be26f72fe14fe0210ff25054444b241eb3e4651f60ec49e4df7bc51fe081414e4296b25a3eaa98cf979879f0250d83de8b4208f55534a44975edb5b4de8f0ee4

data/README.md

@@ -25,6 +25,8 @@ And then execute:
   end
   ```
 
+  defaults to: `ENV["LOGSTASH_URI"].present?`
+
 2. Configuring logstash output:
 
   ```ruby
@@ -33,9 +35,10 @@ And then execute:
     config.applicaster_logger.logstash_config = { type: :redis }
   end
   ```
-  defaults to: `{ type: :stdout }`
+  
+  defaults to: `{ uri: ENV["LOGSTASH_URI"] }` if `LOGSTASH_URI` is set or `{ type: :stdout }` otherwise
 
-  For availible options see: https://github.com/dwbutler/logstash-logger#basic-usage
+  For available options see: https://github.com/dwbutler/logstash-logger#basic-usage
 
 3. To set the application name:
 

data/lib/applicaster-logger.rb

@@ -1,5 +1 @@
 require 'applicaster/logger'
-require "applicaster/rack/request_data"
-require "applicaster/sidekiq/middleware"
-require "applicaster/sidekiq/job_logger"
-require "applicaster/sidekiq/exception_logger"

data/lib/applicaster/logger.rb

@@ -1,84 +1,13 @@
-require "applicaster/logger/version"
-require "applicaster/logger/railtie"
-require "applicaster/logger/formatter"
+require_relative "./logger/formatter"
+require_relative "./logger/rack"
+require_relative "./logger/railtie"
+require_relative "./logger/sidekiq"
+require_relative "./logger/thread_context"
+require_relative "./logger/version"
+
 
 module Applicaster
   module Logger
-    # taken from https://github.com/rails/rails/blob/master/actionpack/lib/action_controller/log_subscriber.rb
-    INTERNAL_PARAMS = %w(controller action format only_path)
-
-    def self.setup_lograge(app)
-      app.config.lograge.enabled = true
-      app.config.lograge.formatter = Lograge::Formatters::Logstash.new
-      app.config.lograge.custom_options = lambda do |event|
-        {
-          params: event.payload[:params].except(*INTERNAL_PARAMS).inspect,
-          facility: "action_controller",
-          custom_params: event.payload[:custom_params],
-        }
-      end
-
-      app.middleware.insert_after ActionDispatch::RequestId,
-        Applicaster::Rack::RequestData
-    end
-
-    def self.setup_logger(app)
-      logstash_config = app.config.applicaster_logger.logstash_config
-
-      app.config.logger = LogStashLogger.new(logstash_config)
-      app.config.logger.level = app.config.applicaster_logger.level
-      app.config.logger.formatter =
-        Applicaster::Logger::Formatter.new(facility: "rails_logger")
-
-      if defined?(Delayed)
-        Delayed::Worker.logger = LogStashLogger.new(logstash_config)
-        Delayed::Worker.logger.level = app.config.applicaster_logger.level
-        Delayed::Worker.logger.formatter =
-          Applicaster::Logger::Formatter.new(facility: "delayed_job")
-      end
-
-      if defined?(::Sidekiq)
-        ::Sidekiq.configure_server do |config|
-          config.error_handlers.delete_if { |h| h.is_a?(::Sidekiq::ExceptionHandler::Logger) }
-          ::Sidekiq.error_handlers << Applicaster::Sidekiq::ExceptionLogger.new
-
-          if Gem::Version.new(::Sidekiq::VERSION) < Gem::Version.new("5.0")
-            require 'sidekiq/api'
-            config.server_middleware do |chain|
-              chain.remove ::Sidekiq::Middleware::Server::Logging
-              chain.add Applicaster::Sidekiq::Middleware::Server::LogstashLogging
-            end
-          else
-            logger = LogStashLogger.new(logstash_config)
-            logger.level = app.config.applicaster_logger.level
-            logger.formatter = Applicaster::Logger::Formatter.new(facility: "sidekiq")
-            ::Sidekiq::Logging.logger = logger
-            ::Sidekiq.options[:job_logger] = ::Applicaster::Sidekiq::JobLogger
-          end
-        end
-      end
-
-      if defined?(Sidetiq)
-        Sidetiq.logger = LogStashLogger.new(logstash_config)
-        Sidetiq.logger.level = app.config.applicaster_logger.level
-        Sidetiq.logger.formatter =
-          Applicaster::Logger::Formatter.new(facility: "sidetiq")
-      end
-    end
-
-    def self.with_thread_data(data)
-      old, Thread.current[:logger_thread_data] =
-        Thread.current[:logger_thread_data], data
-
-      yield
-    ensure
-      Thread.current[:logger_thread_data] = old
-    end
-
-    def self.current_thread_data
-      Thread.current[:logger_thread_data] || {}
-    end
-
     # Truncates +text+ to at most <tt>bytesize</tt> bytes in length without
     # breaking string encoding by splitting multibyte characters or breaking
     # grapheme clusters ("perceptual characters") by truncating at combining

data/lib/applicaster/logger/formatter.rb

@@ -1,6 +1,7 @@
 require 'logger'
 require 'socket'
 require 'time'
+require 'logstash-logger'
 
 module Applicaster
   module Logger
@@ -12,53 +13,36 @@ module Applicaster
       attr_accessor :default_fields
 
       def initialize(options = {})
-        @default_fields = options.dup
+        @default_fields = options.with_indifferent_access
         @datetime_format = nil
       end
 
       def call(severity, time, progname, message)
-        build_event(message, severity, time)
+        data =
+          default_fields.
+          deep_merge(message_to_data(message)).
+          merge({ severity: severity, host: HOST }).
+          deep_merge(Applicaster::Logger::ThreadContext.current)
+
+        event = LogStash::Event.new(data)
+        event.timestamp = time.utc.iso8601(3)
+        event.tags = current_tags
+        "#{event.to_json}\n"
       end
 
       protected
 
-      def build_event(message, severity, time)
-        data = JSON.parse(message).symbolize_keys rescue nil if message.is_a?(String)
-        data ||= message
-
-        event =
-          case data
-          when LogStash::Event
-            data.clone
-          when Hash
-            LogStash::Event.new(data.merge("@timestamp" => time))
-          else
-            LogStash::Event.new(message: msg2str(data), "@timestamp" => time)
-          end
-
-        event[:severity] ||= severity
-        event[:host] ||= HOST
-        event[:application] ||= Rails.application.config.applicaster_logger.application_name
-        event[:environment] ||= Rails.env
-        event[:token] = ENV['LOGZIO_TOKEN'] if ENV['LOGZIO_TOKEN']
-
-        Applicaster::Logger.current_thread_data.each do |field, value|
-          event[field] = value
-        end
-
-        default_fields.each do |field, value|
-          event[field] ||= value
+      def message_to_data(message)
+        case message
+        when Hash
+          message.with_indifferent_access
+        when LogStash::Event
+          message.to_hash.with_indifferent_access
+        when /^\{/
+          JSON.parse(message).with_indifferent_access rescue { message: msg2str(message) }
+        else
+          { message: msg2str(message) }.with_indifferent_access
         end
-
-        current_tags.each do |tag|
-          event.tag(tag)
-        end
-
-        # In case Time#to_json has been overridden
-        if event.timestamp.is_a?(Time)
-          event.timestamp = event.timestamp.iso8601(3)
-        end
-        "#{event.to_json}\n"
       end
     end
   end

data/lib/applicaster/logger/lograge/formatter.rb

@@ -0,0 +1,19 @@
+module Applicaster
+  module Logger
+    module Lograge
+      class Formatter
+        def call(data)
+          {
+            message: message(data),
+            facility: "action_controller",
+            action_controller: data,
+          }
+        end
+
+        def message(data)
+          "[#{data[:status]}] #{data[:method]} #{data[:path]} (#{data[:controller]}##{data[:action]})"
+        end
+      end
+    end
+  end
+end

data/lib/applicaster/logger/rack.rb

@@ -0,0 +1,9 @@
+require_relative "./rack/request_data"
+require_relative "./rack/thread_context"
+
+module Applicaster
+  module Logger
+    module Rack
+    end
+  end
+end

data/lib/applicaster/logger/rack/request_data.rb

@@ -0,0 +1,25 @@
+module Applicaster
+  module Logger
+    module Rack
+      class RequestData
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          Applicaster::Logger::ThreadContext.add(request_data(env))
+          @app.call(env)
+        end
+
+        def request_data(env)
+          request = ActionDispatch::Request.new(env)
+          {
+            request_uuid: request.uuid,
+            remote_ip: request.remote_ip,
+            request_host: request.host,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/applicaster/logger/rack/thread_context.rb

@@ -0,0 +1,17 @@
+module Applicaster
+  module Logger
+    module Rack
+      class ThreadContext
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          @app.call(env)
+        ensure
+          Applicaster::Logger::ThreadContext.clear!
+        end
+      end
+    end
+  end
+end

data/lib/applicaster/logger/railtie.rb

@@ -1,22 +1,74 @@
 require 'rails/railtie'
 require 'lograge'
 require 'logstash-logger'
+require_relative "./lograge/formatter"
 
 module Applicaster
   module Logger
     class Railtie < Rails::Railtie
-      config.applicaster_logger = ActiveSupport::OrderedOptions.new
-      config.applicaster_logger.enabled = false
-      config.applicaster_logger.level = ::Logger::INFO
-      config.applicaster_logger.logstash_config = { type: :stdout }
-      config.applicaster_logger.application_name = Rails.application.class.parent.to_s.underscore
+      DEFAULT_APP_NAME = Rails.application.class.parent.to_s.underscore
+
+      # taken from https://github.com/rails/rails/blob/master/actionpack/lib/action_controller/log_subscriber.rb
+      INTERNAL_PARAMS = %w(controller action format only_path)
+
+      config.applicaster_logger = ActiveSupport::OrderedOptions.new.tap do |config|
+        uri = ENV["LOGSTASH_URI"]
+        config.enabled = uri.present?
+        config.level = ::Logger::INFO
+        config.application_name = ENV.fetch("LOG_APP_NAME") { DEFAULT_APP_NAME }
+        config.logstash_config = uri.present? ? { uri: uri } : { type: :stdout }
+        config.logzio_token = ENV['LOGZIO_TOKEN'].presence
+      end
+
+      initializer :applicaster_logger_rack do |app|
+        app.middleware.insert 0, Applicaster::Logger::Rack::ThreadContext
+        app.middleware.insert_after ActionDispatch::RequestId, Applicaster::Logger::Rack::RequestData
+      end
 
       initializer :applicaster_logger_lograge, before: :lograge do |app|
-        Applicaster::Logger.setup_lograge(app) if app.config.applicaster_logger.enabled
+        setup_lograge(app) if app.config.applicaster_logger.enabled
       end
 
       initializer :applicaster_logger, before: :initialize_logger do |app|
-        Applicaster::Logger.setup_logger(app) if app.config.applicaster_logger.enabled
+        setup_logger(app) if app.config.applicaster_logger.enabled
+      end
+
+      def setup_lograge(app)
+        app.config.lograge.enabled = true
+        app.config.lograge.formatter = Applicaster::Logger::Lograge::Formatter.new
+        app.config.lograge.custom_options = lambda do |event|
+          {
+            params: event.payload[:params].except(*INTERNAL_PARAMS).inspect,
+            custom_params: event.payload[:custom_params],
+          }
+        end
+      end
+
+      def setup_logger(app)
+        config = app.config.applicaster_logger
+        app.config.logger = new_logger("rails_logger")
+        Applicaster::Logger::Sidekiq.setup(new_logger("sidekiq")) if defined?(::Sidekiq)
+        Sidetiq.logger = new_logger("sidetiq") if defined?(Sidetiq)
+        Delayed::Worker.logger = new_logger("delayed") if defined?(Delayed)
+      end
+
+      def new_logger(facility)
+        config = ::Rails.application.config.applicaster_logger
+        LogStashLogger.new(config.logstash_config).tap do |logger|
+          logger.level = config.level
+
+          logger.formatter = Applicaster::Logger::Formatter.new(
+            default_fields.merge({ facility: facility })
+          )
+        end
+      end
+
+      def default_fields
+        config = ::Rails.application.config.applicaster_logger
+        {
+          application: config.application_name,
+          environment: Rails.env.to_s
+        }.merge(config.logzio_token ? { token: config.logzio_token } : {})
       end
     end
   end

data/lib/applicaster/logger/sidekiq.rb

@@ -0,0 +1,59 @@
+require_relative "./sidekiq/middleware"
+require_relative "./sidekiq/job_logger"
+require_relative "./sidekiq/exception_logger"
+require_relative "./sidekiq/thread_context"
+
+module Applicaster
+  module Logger
+    module Sidekiq
+      def self.setup(logger)
+        ::Sidekiq::Logging.logger = logger
+        ::Sidekiq.configure_server do |config|
+          config.error_handlers.delete_if { |h| h.is_a?(::Sidekiq::ExceptionHandler::Logger) }
+          ::Sidekiq.error_handlers << Applicaster::Logger::Sidekiq::ExceptionLogger.new
+
+          config.server_middleware do |chain|
+            chain.prepend Applicaster::Logger::Sidekiq::ThreadContext
+          end
+
+          if Gem::Version.new(::Sidekiq::VERSION) < Gem::Version.new("5.0")
+            require 'sidekiq/api'
+            config.server_middleware do |chain|
+              chain.remove ::Sidekiq::Middleware::Server::Logging
+              chain.add Applicaster::Logger::Sidekiq::Middleware::Server::LogstashLogging
+            end
+          else
+            ::Sidekiq.options[:job_logger] = ::Applicaster::Logger::Sidekiq::JobLogger
+          end
+        end
+      end
+
+      def job_context(item, queue)
+        {
+          sidekiq: {
+            # job ID
+            jid: item['jid'],
+            pid: ::Process.pid,
+            # thread ID
+            tid: ::Thread.current.object_id.to_s(36),
+            # batch ID
+            bid: item['bid'],
+            # If we're using a wrapper class, like ActiveJob, use the "wrapped"
+            # attribute to expose the underlying thing.
+            class: (item['wrapped'] || item['class']).to_s,
+            queue: queue,
+            args: item['args'].inspect,
+          }
+        }
+      end
+
+      def logger
+        ::Sidekiq.logger
+      end
+
+      def item_class_name(item)
+        (item['wrapped'] || item['class']).to_s
+      end
+    end
+  end
+end

data/lib/applicaster/logger/sidekiq/common_events.rb

@@ -0,0 +1,42 @@
+module Applicaster
+  module Logger
+    module Sidekiq
+      module CommonEvents
+        include Applicaster::Logger::Sidekiq
+
+        def start_event(item)
+          {
+            message: "Start: #{item_class_name(item)} JID-#{item['jid']}",
+            sidekiq: {
+              event: "start",
+              latency: ::Sidekiq::Job.new(item).latency,
+            }
+          }
+        end
+
+        def done_event(item, opts)
+          {
+            message: "Done: #{item_class_name(item)} JID-#{item['jid']}",
+            sidekiq: {
+              event: "done",
+              runtime: opts.fetch(:runtime),
+            }
+          }
+        end
+
+        def exception_event(item, opts)
+          exception = opts.fetch(:exception)
+          {
+            message: "Fail: #{item_class_name(item)} JID-#{item['jid']}",
+            sidekiq: {
+              event: "exception",
+              runtime: opts.fetch(:runtime),
+              exception_class: exception.class.to_s,
+              exception_message: Applicaster::Logger.truncate_bytes(exception.message.to_s, 500),
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/applicaster/logger/sidekiq/exception_logger.rb

@@ -0,0 +1,22 @@
+require_relative "./common_events"
+
+module Applicaster
+  module Logger
+    module Sidekiq
+      class ExceptionLogger
+        include Applicaster::Logger::Sidekiq
+        include Applicaster::Logger::Sidekiq::CommonEvents
+
+        def call(exception, ctxHash)
+          item = ctxHash[:job]
+          queue = item[:queue]
+
+          logger.error(
+            job_context(item, queue).
+              deep_merge(exception_event(item, exception: exception, runtime: runtime))
+          )
+        end
+      end
+    end
+  end
+end

data/lib/applicaster/logger/sidekiq/job_logger.rb

@@ -0,0 +1,24 @@
+require_relative "./common_events"
+
+module Applicaster
+  module Sidekiq
+    class JobLogger
+      include Applicaster::Logger::Sidekiq
+      include Applicaster::Logger::Sidekiq::CommonEvents
+
+      def call(item, queue)
+        start = Time.now
+        logger.info(job_context(item, queue).deep_merge(start_event(item)))
+        yield
+        runtime = elapsed(start)
+        logger.info(job_context(item, queue).deep_merge(done_event(item, runtime: runtime)))
+      end
+
+      private
+
+      def elapsed(start)
+        (Time.now - start).round(3)
+      end
+    end
+  end
+end

data/lib/applicaster/logger/sidekiq/middleware.rb

@@ -0,0 +1,35 @@
+require_relative "./common_events"
+
+module Applicaster
+  module Logger
+    module Sidekiq
+      module Middleware
+        module Server
+          class LogstashLogging
+            include Applicaster::Logger::Sidekiq
+            include Applicaster::Logger::Sidekiq::CommonEvents
+
+            def call(worker, item, queue)
+              logger.info(start_event(item))
+              start = Time.now
+              yield # Pass the torch
+              runtime = elapsed(start)
+              logger.info(done_event(item, runtime: runtime))
+            rescue Exception => exception
+              runtime = elapsed(start)
+              logger.error(exception_event(item, exception: exception, runtime: runtime))
+              raise exception
+            end
+
+            private
+
+            def elapsed(start)
+              return nil if start.nil?
+              (Time.now - start).to_f.round(3)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/applicaster/logger/sidekiq/thread_context.rb

@@ -0,0 +1,16 @@
+module Applicaster
+  module Logger
+    module Sidekiq
+      class ThreadContext
+        include Applicaster::Logger::Sidekiq
+
+        def call(worker, item, queue)
+          Applicaster::Logger::ThreadContext.add(job_context(item, queue))
+          yield # Pass the torch
+        ensure
+          Applicaster::Logger::ThreadContext.clear!
+        end
+      end
+    end
+  end
+end

data/lib/applicaster/logger/thread_context.rb

@@ -0,0 +1,20 @@
+module Applicaster
+  module Logger
+    module ThreadContext
+      module_function
+      KEY = self.name.to_sym
+
+      def current
+        Thread.current[KEY] ||= HashWithIndifferentAccess.new
+      end
+
+      def add(hash)
+        current.merge!(hash)
+      end
+
+      def clear!
+        Thread.current[KEY] = HashWithIndifferentAccess.new
+      end
+    end
+  end
+end

data/lib/applicaster/logger/version.rb

@@ -1,5 +1,5 @@
 module Applicaster
   module Logger
-    VERSION = "0.7.0"
+    VERSION = "0.8.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: applicaster-logger
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Vitaly Gorodetsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-10 00:00:00.000000000 Z
+date: 2018-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logstash-logger
@@ -82,12 +82,19 @@ files:
 - lib/applicaster-logger.rb
 - lib/applicaster/logger.rb
 - lib/applicaster/logger/formatter.rb
+- lib/applicaster/logger/lograge/formatter.rb
+- lib/applicaster/logger/rack.rb
+- lib/applicaster/logger/rack/request_data.rb
+- lib/applicaster/logger/rack/thread_context.rb
 - lib/applicaster/logger/railtie.rb
+- lib/applicaster/logger/sidekiq.rb
+- lib/applicaster/logger/sidekiq/common_events.rb
+- lib/applicaster/logger/sidekiq/exception_logger.rb
+- lib/applicaster/logger/sidekiq/job_logger.rb
+- lib/applicaster/logger/sidekiq/middleware.rb
+- lib/applicaster/logger/sidekiq/thread_context.rb
+- lib/applicaster/logger/thread_context.rb
 - lib/applicaster/logger/version.rb
-- lib/applicaster/rack/request_data.rb
-- lib/applicaster/sidekiq/exception_logger.rb
-- lib/applicaster/sidekiq/job_logger.rb
-- lib/applicaster/sidekiq/middleware.rb
 homepage: ''
 licenses:
 - MIT

data/lib/applicaster/rack/request_data.rb

@@ -1,24 +0,0 @@
-module Applicaster
-  module Rack
-    class RequestData
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        Applicaster::Logger.with_thread_data(request_data(env)) do
-          @app.call(env)
-        end
-      end
-
-      def request_data(env)
-        request = ActionDispatch::Request.new(env)
-        {
-          request_uuid: request.uuid,
-          remote_ip: request.remote_ip,
-          request_host: request.host,
-        }
-      end
-    end
-  end
-end

data/lib/applicaster/sidekiq/exception_logger.rb

@@ -1,27 +0,0 @@
-module Applicaster
-  module Sidekiq
-    class ExceptionLogger
-      def call(exception, ctxHash)
-        item = ctxHash[:job]
-        queue = item[:queue]
-
-        event = log_context(item, queue).merge({
-          message: "Fail: #{item['class']} JID-#{item['jid']}",
-          exception_class: exception.class.to_s,
-          exception_message: Applicaster::Logger.truncate_bytes(exception.message.to_s, 500),
-        })
-        logger.info(event)
-      end
-
-      private
-
-      def log_context(item, queue)
-        Applicaster::Sidekiq::JobLogger.log_context(item, queue)
-      end
-
-      def logger
-        ::Sidekiq.logger
-      end
-    end
-  end
-end

data/lib/applicaster/sidekiq/job_logger.rb

@@ -1,50 +0,0 @@
-module Applicaster
-  module Sidekiq
-    class JobLogger
-      def call(item, queue)
-        puts "JobLogger"
-        start = Time.now
-        event = log_context(item, queue).merge({
-          message: "Start: #{item['class']} JID-#{item['jid']}",
-        })
-        logger.info(event)
-        yield
-        event = log_context(item, queue).merge({
-          message: "Done: #{item['class']} JID-#{item['jid']}",
-        })
-        event[:sidekiq][:duration] = elapsed(start)
-        logger.info(event)
-      end
-
-      private
-
-      def elapsed(start)
-        (Time.now - start).round(3)
-      end
-
-      def logger
-        ::Sidekiq.logger
-      end
-
-      def log_context(item, queue)
-        self.class.log_context(item, queue)
-      end
-
-      def self.sidekiq_context
-        ::Thread.current[:sidekiq_context]
-      end
-
-      def self.log_context(item, queue)
-        {
-          sidekiq: {
-            jid: item['jid'],
-            context: sidekiq_context,
-            worker: item['class'].to_s,
-            queue: queue,
-            args: item['args'].inspect,
-          }
-        }
-      end
-    end
-  end
-end

data/lib/applicaster/sidekiq/middleware.rb

@@ -1,109 +0,0 @@
-module Applicaster
-  module Sidekiq
-    module Middleware
-      module Server
-        class LogstashLogging
-
-          def call(worker, item, queue)
-            ::Sidekiq::Logging.with_context("#{worker.class.to_s} JID-#{item['jid']}") do
-              begin
-                logger.info(filter_fields({
-                  message: "Start: #{worker.class.to_s} JID-#{item['jid']}",
-                  jid: item['jid'],
-                  pid: pid,
-                  tid: tid,
-                  context: context,
-                  worker: worker.class.to_s,
-                  queue: queue,
-                  args: item['args'].inspect,
-                  latency: ::Sidekiq::Job.new(::Sidekiq.dump_json(item)).latency,
-                  memory: memory
-                }))
-
-                start = Time.now
-
-                yield # Pass the torch
-
-                logger.info(filter_fields({
-                  message: "Done: #{worker.class.to_s} JID-#{item['jid']}",
-                  jid: item['jid'],
-                  pid: pid,
-                  tid: tid,
-                  context: context,
-                  worker: worker.class.to_s,
-                  queue: queue,
-                  args: item['args'].inspect,
-                  runtime: elapsed(start),
-                  memory: memory
-                }))
-              rescue Exception => e
-                logger.error(filter_fields({
-                  message: "Fail: #{worker.class.to_s} JID-#{item['jid']}",
-                  jid: item['jid'],
-                  pid: pid,
-                  tid: tid,
-                  context: context,
-                  worker: worker.class.to_s,
-                  queue: queue,
-                  args: item['args'].inspect,
-                  runtime: elapsed(start),
-                  exception_class: e.class.to_s,
-                  exception_message: Applicaster::Logger.truncate_bytes(e.message.to_s, 500),
-                  memory: memory
-                }))
-
-                raise e
-              ensure
-                logger.device.close
-              end
-            end
-          end
-
-          def logger
-            @logger ||=
-              begin
-                applicaster_logger = ::Rails.application.config.applicaster_logger
-                logger = LogStashLogger.new(applicaster_logger.logstash_config)
-                logger.level = applicaster_logger.sidekiq_log_level || applicaster_logger.level
-                logger.formatter = Applicaster::Logger::Formatter.new(facility: "sidekiq")
-                logger
-              end
-          end
-
-          private
-
-          def pid
-            ::Process.pid
-          end
-
-          def tid
-            ::Thread.current.object_id.to_s(36)
-          end
-
-          def context
-            ::Thread.current[:sidekiq_context]
-          end
-
-          def memory
-            `ps -o rss= -p #{::Process.pid}`.chomp.to_i
-          end
-
-          def elapsed(start)
-            return nil if start.nil?
-            (Time.now - start).to_f.round(3)
-          end
-
-          def filter_fields(data)
-            data.each do |key, val|
-              if val.is_a?(String) && val.length > 32766 # max message length
-                data[key] = "[omitted; length = #{val.length}, max = 32766]"
-              end
-            end
-
-            data
-          end
-        end
-      end
-    end
-  end
-end