contextualized_logs 0.0.1.pre.alpha → 0.0.2.pre.alpha

data/lib/contextualized_logs/contextualized_model.rb

@@ -1,37 +1,43 @@
 require 'active_support'
-require_relative 'current_context'
+require 'active_record'
 
 module ContextualizedLogs
   module ContextualizedModel
     extend ActiveSupport::Concern
 
-    DEFAULT_CURRENT_CONTEXT = ContextualizedLogs::CurrentContext
-
-    class_methods do
-      attr_reader :contextualizable_keys
+    class << self
+      attr_writer :current_context
 
       def current_context
-        @current_context || DEFAULT_CURRENT_CONTEXT
+        @current_context || ContextualizedLogs.config.current_context
       end
 
-      private
+      def included(base)
+        unless base.ancestors.include? ActiveRecord::Base
+          raise ArgumentError, "ContextualizedLogs::ContextualizedModel can only be included in a ActiveRecord::Base"
+        end
 
-      def contextualizable(keys: {})
-        @contextualizable_keys = keys
-      end
+        base.extend(ClassMethods)
+
+        base.class_eval do
+          after_find do |object|
+            # Rails.logger.debug "after_find #{object}"
+            ContextualizedModel.contextualize(object, self.class.contextualizable_keys, ContextualizedModel.current_context)
+          end
 
-      def set_current_context(current_context)
-        @current_context = current_context
+          after_create do
+            # Rails.logger.debug "after_create #{self}"
+            ContextualizedModel.contextualize(self, self.class.contextualizable_keys, ContextualizedModel.current_context)
+          end
+        end
       end
-    end
 
-    class << self
       def contextualize(model, keys, context)
         # Rails.logger.debug "model: #{model}"
         # Rails.logger.debug "keys: #{keys}"
         # Rails.logger.debug "context.context: #{context}"
-        # Rails.logger.debug "context.contextualized_model_enabled: #{context.contextualized_model_enabled}"
-        return unless context.contextualized_model_enabled
+        # Rails.logger.debug "context.contextualize_model_enabled: #{context.contextualize_model_enabled}"
+        return unless context.contextualize_model_enabled
         keys&.each do |k, v|
           v = model.try(v.to_sym)
           context.add_context(k, v) if v
@@ -39,15 +45,13 @@ module ContextualizedLogs
       end
     end
 
-    included do
-      after_find do |object|
-        # Rails.logger.debug "after_find #{object}"
-        ContextualizedModel.contextualize(object, self.class.contextualizable_keys, self.class.current_context)
-      end
+    module ClassMethods
+      attr_reader :contextualizable_keys
 
-      after_create do
-        # Rails.logger.debug "after_create #{self}"
-        ContextualizedModel.contextualize(self, self.class.contextualizable_keys, self.class.current_context)
+      private
+
+      def contextualizable(keys: {})
+        @contextualizable_keys = keys
       end
     end
   end

data/lib/contextualized_logs/contextualized_worker.rb

@@ -1,40 +1,74 @@
 require 'active_support'
+require 'sidekiq'
 
 module ContextualizedLogs
   module ContextualizedWorker
     extend ActiveSupport::Concern
 
-    DEFAULT_CURRENT_CONTEXT = ContextualizedLogs::CurrentContext
-    DEFAULT_CONTEXTUALIZED_WORKER_ENABLED = false
-    DEFAULT_CONTEXTUALIZED_MODEL_ENABLED = false
-
-    class_methods do
-      # contextualize_args
+    class << self
+      attr_writer :current_context
+      attr_writer :default_contextualize_model
+      attr_writer :default_contextualize_worker
 
       def current_context
-        @current_context || DEFAULT_CURRENT_CONTEXT
+        @current_context || ContextualizedLogs.config.current_context
       end
 
-      def contextualized_worker_enabled
-        @contextualized_worker_enabled || DEFAULT_CONTEXTUALIZED_WORKER_ENABLED
+      def default_contextualize_model
+        @default_contextualize_model || ContextualizedLogs.config.worker_default_contextualize_model
       end
 
-      def contextualized_model_enabled
-        @contextualized_model_enabled || DEFAULT_CONTEXTUALIZED_MODEL_ENABLED
+      def default_contextualize_worker
+        @default_contextualize_worker || ContextualizedLogs.config.worker_default_contextualize_worker
       end
 
-      private
+      def included(base)
+        unless base.ancestors.include? ::Sidekiq::Worker
+          raise ArgumentError, "ContextualizedLogs::ContextualizedWorker can only be included in a Sidekiq::Worker"
+        end
+
+        base.extend(ClassMethods)
+
+        # Automatically add sidekiq middleware when we're first included
+        #
+        # This might only occur when the worker class is first loaded in a
+        # development rails environment, but that happens before the middleware
+        # chain is invoked so we're all good.
+        #
+        ::Sidekiq.configure_server do |config|
+          unless config.server_middleware.exists? Sidekiq::Middleware::Server::RestoreCurrentContext
+            config.server_middleware.add Sidekiq::Middleware::Server::RestoreCurrentContext
+          end
+        end
+        ::Sidekiq.configure_client do |config|
+          unless config.client_middleware.exists? Sidekiq::Middleware::Client::InjectCurrentContext
+            config.client_middleware.add Sidekiq::Middleware::Client::InjectCurrentContext
+          end
+        end
+      end
+    end
 
-      def set_current_context(current_context)
-        @current_context = current_context
+    module ClassMethods
+      def contextualize_worker_enabled
+        return @contextualize_worker_enabled if defined?(@contextualize_worker_enabled)
+
+        ContextualizedWorker.default_contextualize_worker
+      end
+
+      def contextualize_model_enabled
+        return @contextualize_model_enabled if defined?(@contextualize_model_enabled)
+
+        ContextualizedWorker.default_contextualize_model
       end
 
-      def contextualized_worker(enabled)
-        @contextualized_worker_enabled = enabled
+      private
+
+      def contextualize_worker(enabled)
+        @contextualize_worker_enabled = enabled
       end
 
-      def contextualized_model(enabled)
-        @contextualized_model_enabled = enabled
+      def contextualize_model(enabled)
+        @contextualize_model_enabled = enabled
       end
     end
   end

data/lib/contextualized_logs/current_context.rb

@@ -6,94 +6,96 @@ module ContextualizedLogs
   class CurrentContext < ActiveSupport::CurrentAttributes
     # ⚠️ do not use this class to store any controller specific info..
 
-    attribute \
+    attribute :custom_attributes,
       :request_uuid, :request_user_agent, :request_origin, :request_referer, :request_xhr, # request
       :current_job_id, :enqueued_jobs_ids, :worker, :worker_args, # sidekiq
       :request_remote_ip, :request_ip, :request_remote_addr, :request_x_forwarded_for, # ips
       :errors,
-      :contextualized_model_enabled, # enable model context values
+      :contextualize_model_enabled, # enable model context values
       :context_values, :context_values_count, # context values
       :resource_name # controller_action to correlate APM metrics
 
     MAX_CONTEXT_VALUES = 100
 
-    def self.context
-      # https://docs.hq.com/logs/processing/attributes_naming_convention/#source-code
-
-      data = {}
-
-      data[:resource_name] = resource_name unless resource_name.nil?
-
-      #  normalized
-      data[:http] = {}
-      data[:http][:referer] = request_referer unless request_referer.nil?
-      data[:http][:request_id] = request_uuid unless request_uuid.nil?
-      data[:http][:useragent] = request_user_agent unless request_user_agent.nil?
-      data[:http][:origin] = request_origin unless request_origin.nil?
-      data.delete(:http) if data[:http].empty?
-
-      #  normalized
-      data[:network] = { client: {} }
-      data[:network][:client][:ip] = request_ip unless request_ip.nil?
-      data[:network][:client][:remote_addr] = request_remote_addr unless request_remote_addr.nil?
-      data[:network][:client][:remote_ip] = request_remote_ip unless request_remote_ip.nil?
-      data[:network][:client][:x_forwarded_for] = request_x_forwarded_for unless request_x_forwarded_for.nil?
-      data.delete(:network) if data[:network][:client].empty?
-
-      # eventual error response
-      #  normalized
-      data[:errors] = errors unless errors.nil?
-
-      # context_values
-      unless context_values.nil?
-        if context_values.is_a?(Hash) && !context_values.empty?
-          data[:context_values] = {}
-          context_values.each { |k, v| data[:context_values][k.to_sym] = v }
+    class << self
+      def context
+        # https://docs.hq.com/logs/processing/attributes_naming_convention/#source-code
+
+        data = {}
+
+        data[:resource_name] = resource_name unless resource_name.nil?
+
+        #  normalized
+        data[:http] = data[:http] || {}
+        data[:http][:referer] = request_referer unless request_referer.nil?
+        data[:http][:request_id] = request_uuid unless request_uuid.nil?
+        data[:http][:useragent] = request_user_agent unless request_user_agent.nil?
+        data[:http][:origin] = request_origin unless request_origin.nil?
+        data.delete(:http) if data[:http].empty?
+
+        #  normalized
+        data[:network] = data[:network] || { client: {} }
+        data[:network][:client][:ip] = request_ip unless request_ip.nil?
+        data[:network][:client][:remote_addr] = request_remote_addr unless request_remote_addr.nil?
+        data[:network][:client][:remote_ip] = request_remote_ip unless request_remote_ip.nil?
+        data[:network][:client][:x_forwarded_for] = request_x_forwarded_for unless request_x_forwarded_for.nil?
+        data.delete(:network) if data[:network][:client].empty?
+
+        # eventual error response
+        #  normalized
+        data[:errors] = errors unless errors.nil?
+
+        # context_values
+        unless context_values.nil?
+          if context_values.is_a?(Hash) && !context_values.empty?
+            data[:context_values] = {}
+            context_values.each { |k, v| data[:context_values][k.to_sym] = v }
+          end
         end
-      end
 
-      unless current_job_id.nil? && worker.nil?
-        data[:job] = { id: current_job_id, worker: worker }
-        data[:job][:args] = worker_args if worker_args
-      end
+        unless current_job_id.nil? && worker.nil?
+          data[:job] = { id: current_job_id, worker: worker }
+          data[:job][:args] = worker_args if worker_args
+        end
 
-      data
-    end
+        data.deep_merge(custom_attributes || {}) 
+      end
 
-    def self.to_json
-      attributes.to_json
-    end
+      def to_json
+        attributes.to_json
+      end
 
-    def self.add_context(key, value)
-      self.context_values_count ||= 0
-      self.context_values_count += 1
-      if self.context_values_count >= MAX_CONTEXT_VALUES
-        Rails.logger.warn('high number of context values') if self.context_values_count == MAX_CONTEXT_VALUES
-        return
+      def add_context(key, value)
+        self.context_values_count ||= 0
+        self.context_values_count += 1
+        if self.context_values_count >= MAX_CONTEXT_VALUES
+          Rails.logger.warn('high number of context values') if self.context_values_count == MAX_CONTEXT_VALUES
+          return
 
+        end
+        self.context_values ||= {}
+        self.context_values[key] ||= []
+        unless self.context_values[key].include?(value)
+          self.context_values[key] << value
+        end
       end
-      self.context_values ||= {}
-      self.context_values[key] ||= []
-      unless self.context_values[key].include?(value)
-        self.context_values[key] << value
-      end
-    end
 
-    def self.from_json(json)
-      return unless json
+      def from_json(json)
+        return unless json
 
-      begin
-        values = JSON.parse(json).deep_symbolize_keys
-        values.each { |k, v| send("#{k}=", v) }
-      rescue
+        begin
+          values = JSON.parse(json).deep_symbolize_keys
+          values.each { |k, v| send("#{k}=", v) }
+        rescue
+        end
       end
-    end
 
-    def self.add_error(error)
-      return if error.nil?
+      def add_error(error)
+        return if error.nil?
 
-      self.errors ||= []
-      self.errors << error
+        self.errors ||= []
+        self.errors << error
+      end
     end
   end
 end

data/lib/contextualized_logs/sidekiq/middleware/client/inject_current_context.rb

@@ -19,11 +19,11 @@ module ContextualizedLogs
             # no need to `Current.reset`
             worker_klass = worker_class.is_a?(String) ? worker_class.constantize : worker_class
             if worker_klass.include?(ContextualizedWorker)
-              current_context = worker_klass.current_context
+              current_context = ContextualizedWorker.current_context
               current_context.enqueued_jobs_ids ||= []
               current_context.enqueued_jobs_ids << job['jid']
-              current_context.contextualized_model_enabled = worker_klass.contextualized_model_enabled
-              if worker_klass.contextualized_worker_enabled
+              current_context.contextualize_model_enabled = worker_klass.contextualize_model_enabled
+              if worker_klass.contextualize_worker_enabled
                 job['context'] = current_context.to_json
                 Rails.logger.info "sidekiq: enqueing job #{worker_class}: #{job['jid']}, on queue: #{queue}"
                 Rails.logger.dump('Injecting context', JSON.parse(current_context.to_json), :debug)

data/lib/contextualized_logs/sidekiq/middleware/server/restore_current_context.rb

@@ -15,14 +15,14 @@ module ContextualizedLogs
             worker_klass = worker.class
             if worker_klass.include?(ContextualizedWorker)
               job_context_json = job['context']
-              current_context = worker_klass.current_context
+              current_context = ContextualizedWorker.current_context
               current_context.from_json(job_context_json) if job_context_json
               current_context.current_job_id = job['jid']
               current_context.worker = worker.class.to_s
               # https://github.com/mperham/sidekiq/wiki/Job-Format
               current_context.worker_args = worker_klass.contextualize_args(job['args']) if worker_klass.respond_to?(:contextualize_args) && job['args']
-              current_context.contextualized_model_enabled = worker_klass.contextualized_model_enabled
-              if worker_klass.contextualized_worker_enabled
+              current_context.contextualize_model_enabled = worker_klass.contextualize_model_enabled
+              if worker_klass.contextualize_worker_enabled
                 Rails.logger.info "sidekiq: performing job #{worker_klass}: #{job['jid']}, on queue #{queue}"
                 yield
                 Rails.logger.info "sidekiq: completing job #{worker_klass}: #{job['jid']}, on queue #{queue}"

data/lib/contextualized_logs/version.rb

@@ -1,3 +1,3 @@
 module ContextualizedLogs
-  VERSION = '0.0.1-alpha'
+  VERSION = '0.0.2-alpha'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contextualized_logs
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre.alpha
+  version: 0.0.2.pre.alpha
 platform: ruby
 authors:
 - Hugues Bernet-Rollande
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-24 00:00:00.000000000 Z
+date: 2020-04-25 00:00:00.000000000 Z
 dependencies: []
 description: |
   Online logging solution (like [Datadog](https://www.datadoghq.com)) have drastically transform the way we log.
@@ -44,6 +44,8 @@ files:
 - app/channels/application_cable/channel.rb
 - app/channels/application_cable/connection.rb
 - app/controllers/application_controller.rb
+- app/controllers/concerns/datadog_set_trace_details.rb
+- app/controllers/custom_context_controller.rb
 - app/controllers/model_controller.rb
 - app/helpers/application_helper.rb
 - app/jobs/application_job.rb
@@ -67,7 +69,9 @@ files:
 - config/initializers/assets.rb
 - config/initializers/backtrace_silencers.rb
 - config/initializers/content_security_policy.rb
+- config/initializers/contextualized_logs.rb
 - config/initializers/cookies_serializer.rb
+- config/initializers/datadog.rb
 - config/initializers/filter_parameter_logging.rb
 - config/initializers/inflections.rb
 - config/initializers/mime_types.rb
@@ -85,6 +89,7 @@ files:
 - db/seeds.rb
 - db/test.sqlite3
 - lib/contextualized_logs.rb
+- lib/contextualized_logs/config.rb
 - lib/contextualized_logs/contextualized_controller.rb
 - lib/contextualized_logs/contextualized_logger.rb
 - lib/contextualized_logs/contextualized_model.rb