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

data/app/controllers/application_controller.rb

@@ -1,2 +1,3 @@
 class ApplicationController < ActionController::API
+  include DatadogSetTraceDetails # inject user_id in datadog APM trace
 end

data/app/controllers/concerns/datadog_set_trace_details.rb

@@ -0,0 +1,36 @@
+module DatadogSetTraceDetails
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :set_trace_tags, unless: -> { Rails.env.development? }
+  end
+
+  def set_trace_tags
+    begin
+      # set log context as (Datadog) APM trace tags
+      tracer = Datadog.configuration[:rails][:tracer]
+      span = tracer.active_span
+      dotted_hash(ContextualizedLogger.config.current_context).each do |k, v|
+        span.set_tag(k, v)
+      end
+    rescue StandardError => e
+      Rails.logger.info "Error setting trace tags #{e}"
+    end
+  end
+
+  private
+
+  # {http: {uuid: 123}} => {http.uuid: 123}
+  # could be added to Hash
+  def dotted_hash(hash, recursive_key = "")
+    hash.each_with_object({}) do |(k, v), ret|
+      key = recursive_key + k.to_s
+      if v.is_a? Hash
+        ret.merge! dotted_hash(v, key + ".")
+      else
+        ret[key] = v
+      end
+    end
+  end
+
+end

data/app/controllers/custom_context_controller.rb

@@ -0,0 +1,17 @@
+class CustomContextController < ApplicationController
+  include ContextualizedLogs::ContextualizedController
+
+  def contextualize_request(controller)
+    super(controller)
+
+    ContextualizedLogs::ContextualizedController.current_context.custom_attributes = {
+      http: {
+        service: 'rails'
+      }
+    }
+  end
+
+  def show
+    render json: {}, status: 200
+  end
+end

data/app/controllers/model_controller.rb

@@ -1,6 +1,6 @@
 class ModelController < ApplicationController
   include ContextualizedLogs::ContextualizedController
-  contextualized_model true
+  contextualize_model true
 
   def index
     models = Model.all.map { |model| { id: model.id, value: model.value} }

data/app/models/model.rb

@@ -1,4 +1,4 @@
 class Model < ActiveRecord::Base
   include ContextualizedLogs::ContextualizedModel
-  contextualizable keys: { values: :value }
+  contextualizable keys: { model_ids: :id, model_values: :value }
 end

data/app/workers/model_worker.rb

@@ -1,8 +1,8 @@
 class ModelWorker
   include Sidekiq::Worker
   include ContextualizedLogs::ContextualizedWorker
-  contextualized_worker true
-  contextualized_model true
+  contextualize_worker true
+  contextualize_model true
   def self.contextualize_args(args)
     { model_id: args.first, action: args.last }
   end

data/config/initializers/contextualized_logs.rb

@@ -0,0 +1,23 @@
+require 'contextualized_logs'
+require 'json'
+
+module ContextualizedLogs
+  configure do |config|
+    config.log_formatter = proc do |severity, timestamp, progname, msg|
+      log = ContextualizedLogger.default_formatter.call(severity, timestamp, progname, msg)
+      log = JSON.parse(log)
+      # set log <> APM trace correlation
+      datadog_correlation = Datadog.tracer.active_correlation
+      log.merge(
+        dd: {
+          trace_id: datadog_correlation.trace_id,
+          span_id: datadog_correlation.span_id
+        },
+        ddsource: ['ruby']
+      ).to_json + "\n"
+    end
+    config.controller_default_contextualizer = proc do |controller|
+      ContextualizedController.default_contextualize_request(controller)
+    end
+  end
+end

data/config/initializers/datadog.rb

@@ -0,0 +1,17 @@
+Datadog.configure do |c|
+  service_name = "#{Rails.env}-rails-app"
+  # https://docs.datadoghq.com/tracing/trace_search_and_analytics/?tab=ruby#automatic-configuration
+  # c.analytics_enabled = true
+
+  # add runtime metrics (runtime.ruby.class_count, runtime.ruby.thread_count, runtime.ruby.gc.*)
+  # http://gems.datadoghq.com/trace/docs/#Processing_Pipeline
+  # c.runtime_metrics_enabled = true
+  #c.tracer debug: true, hostname: '127.0.0.1', log: Logger.new(File.new('log/datadog.log', 'w+'))
+  c.tracer hostname: '127.0.0.1'
+
+  # c.use :rack, service_name: "#{service_name}-rack"
+  c.use :rails, service_name: service_name, database_service: "#{service_name}-active_record", analytics_enabled: false
+  # c.use :rake, service_name: "#{service_name}-rake"
+  # c.use :redis, service_name: "#{service_name}-redis"
+  # c.use :sidekiq, client_service_name: "#{service_name}-sidekiq-client", service_name: "#{service_name}-sidekiq-worker"
+end

data/config/initializers/sidekiq.rb

@@ -8,16 +8,16 @@ require 'sidekiq'
 # require 'sidekiq/throttled'
 # Sidekiq::Throttled.setup!
 
-Sidekiq.configure_server do |config|
-  config.redis = { url: 'redis://127.0.0.1:6379/1' }
-  config.server_middleware do |chain|
-    chain.add ContextualizedLogs::Sidekiq::Middleware::Server::RestoreCurrentContext
-  end
-end
-
-Sidekiq.configure_client do |config|
-  config.redis = { url: 'redis://127.0.0.1:6379/1' }
-  config.client_middleware do |chain|
-    chain.add ContextualizedLogs::Sidekiq::Middleware::Client::InjectCurrentContext
-  end
-end
+# Sidekiq.configure_server do |config|
+#   config.redis = { url: 'redis://127.0.0.1:6379/1' }
+#   config.server_middleware do |chain|
+#     chain.add ContextualizedLogs::Sidekiq::Middleware::Server::RestoreCurrentContext
+#   end
+# end
+#
+# Sidekiq.configure_client do |config|
+#   config.redis = { url: 'redis://127.0.0.1:6379/1' }
+#   config.client_middleware do |chain|
+#     chain.add ContextualizedLogs::Sidekiq::Middleware::Client::InjectCurrentContext
+#   end
+# end

data/config/routes.rb

@@ -1,3 +1,4 @@
 Rails.application.routes.draw do
   resources :model
+  get '/custom_context' => 'custom_context#show'
 end

data/lib/contextualized_logs.rb

@@ -5,7 +5,32 @@ require "contextualized_logs/current_context"
 require "contextualized_logs/sidekiq/middleware/client/inject_current_context"
 require "contextualized_logs/sidekiq/middleware/server/restore_current_context"
 require "contextualized_logs/contextualized_worker"
+require "contextualized_logs/config"
 
 module ContextualizedLogs
   require "contextualized_logs/railtie" if defined?(Rails)
+
+  class << self
+    attr_accessor :config
+
+    def config
+      @config || Config.default
+    end
+
+    def configure(&block)
+      config = Config.default
+      block.call(config)
+      self.config = config
+      ContextualizedLogger.formatter = config.log_formatter
+      ContextualizedController.default_contextualizer = config.controller_default_contextualizer
+      ContextualizedController.default_contextualize_model = config.controller_default_contextualize_model
+      ContextualizedWorker.default_contextualize_model = config.worker_default_contextualize_model
+      ContextualizedWorker.default_contextualize_worker = config.worker_default_contextualize_worker
+      if defined?(Rails) && Rails.logger.is_a?(ContextualizedLogger)
+        Rails.logger.formatter = config.log_formatter
+      end
+    end
+  end
 end
+
+ContextualizedLogs.configure { |config| } # set default configuration

data/lib/contextualized_logs/config.rb

@@ -0,0 +1,27 @@
+
+module ContextualizedLogs
+  class Config
+    DEFAULT_CURRENT_CONTEXT = CurrentContext
+    DEFAULT_CONTROLLER_CONTEXTUALIZE_MODEL = false
+    DEFAULT_WORKER_CONTEXTUALIZE_MODEL = false
+    DEFAULT_WORKER_CONTEXTUALIZE_WORKER = true
+
+    attr_accessor :log_formatter
+    attr_accessor :current_context
+    attr_accessor :controller_default_contextualizer
+    attr_accessor :controller_default_contextualize_model
+    attr_accessor :worker_default_contextualize_worker
+    attr_accessor :worker_default_contextualize_model
+
+    class << self
+      def default
+        config = new
+        config.current_context = DEFAULT_CURRENT_CONTEXT
+        config.controller_default_contextualize_model = DEFAULT_CONTROLLER_CONTEXTUALIZE_MODEL
+        config.worker_default_contextualize_worker = DEFAULT_WORKER_CONTEXTUALIZE_MODEL
+        config.worker_default_contextualize_model = DEFAULT_WORKER_CONTEXTUALIZE_WORKER
+        config
+      end
+    end
+  end
+end

data/lib/contextualized_logs/contextualized_controller.rb

@@ -1,62 +1,76 @@
 # https://github.com/rails/rails/pull/29180
 require 'active_support'
-require_relative 'current_context'
+require 'action_controller'
 
 module ContextualizedLogs
   module ContextualizedController
     extend ActiveSupport::Concern
 
-    DEFAULT_CONTEXTUALIZED_MODEL_ENABLED = false
-    DEFAULT_CURRENT_CONTEXT = ContextualizedLogs::CurrentContext
+    class << self
+      attr_accessor :default_contextualizer
+      attr_writer :default_contextualize_model
+      attr_writer :current_context
 
-    included do
-      before_action :contextualize_requests
-    end
+      def current_context
+        @current_context || ContextualizedLogs.config.current_context
+      end
 
-    def contextualize_requests
-    # Rails.logger.debug "contextualize_requests"
-     # store request && user info in CurrentContext ActiveSupport attribute
-     # which can then be read from anywhere
-     self.class.current_context.contextualized_model_enabled = self.class.contextualized_model_enabled?
-     begin
-       self.class.current_context.resource_name = "#{self.class.name.downcase}_#{action_name.downcase}" rescue nil
-       self.class.current_context.request_uuid = request.uuid
-       self.class.current_context.request_origin = request.origin
-       self.class.current_context.request_user_agent = request.user_agent
-       self.class.current_context.request_referer = request.referer&.to_s
-       self.class.current_context.request_ip = request.ip
-       self.class.current_context.request_remote_ip = request.remote_ip
-       self.class.current_context.request_remote_addr = request.remote_addr
-       self.class.current_context.request_x_forwarded_for = request.x_forwarded_for
-       self.class.current_context.request_xhr = request.xhr? ? 'true' : 'false'
-     rescue StandardError => e
-       Rails.logger.dump_error('error setting context', e)
-     end
-    end
+      def default_contextualize_model
+        @default_contextualize_model || ContextualizedLogs.config.controller_default_contextualize_model
+      end
+
+      def included(base)
+        if !base.ancestors.include?(ActionController::Base) && !base.ancestors.include?(ActionController::API)
+          raise ArgumentError, "ContextualizedLogs::ContextualizedController can only be included in a ActionController::Base or ActionController::API"
+        end
+
+        base.class_eval do
+          before_action do |controller|
+            contextualize_request(controller)
+          end
+        end
 
-    def self.included(base)
-      if !base.ancestors.include?(ActionController::Base) && !base.ancestors.include?(ActionController::API)
-        raise ArgumentError, "ContextualizedLogs::ContextualizedController can only be included in a ActionController::Base or ActionController::API"
+        base.extend(ClassMethods)
       end
 
-      base.extend(ClassMethods)
+      def default_contextualize_request(controller)
+        # Rails.logger.debug "contextualize_request"
+        # store request && user info in CurrentContext ActiveSupport attribute
+        # which can then be read from anywhere
+        ContextualizedController.current_context.contextualize_model_enabled = controller.class.contextualize_model_enabled?
+        ContextualizedController.current_context.resource_name = "#{controller.class.name.downcase}_#{controller.action_name.downcase}" rescue nil
+        ContextualizedController.current_context.request_uuid = controller.request.uuid
+        ContextualizedController.current_context.request_origin = controller.request.origin
+        ContextualizedController.current_context.request_user_agent = controller.request.user_agent
+        ContextualizedController.current_context.request_referer = controller.request.referer&.to_s
+        ContextualizedController.current_context.request_ip = controller.request.ip
+        ContextualizedController.current_context.request_remote_ip = controller.request.remote_ip
+        ContextualizedController.current_context.request_remote_addr = controller.request.remote_addr
+        ContextualizedController.current_context.request_x_forwarded_for = controller.request.x_forwarded_for
+        ContextualizedController.current_context.request_xhr = controller.request.xhr? ? 'true' : 'false'
+      end
     end
 
-    module ClassMethods
-      def contextualized_model_enabled?
-        @contextualized_model_enabled || DEFAULT_CONTEXTUALIZED_MODEL_ENABLED
+    def contextualize_request(controller)
+      if ContextualizedController.default_contextualizer
+        ContextualizedController.default_contextualizer.call(controller)
+        return
       end
 
-      def contextualized_model(enable)
-        @contextualized_model_enabled = enable
-      end
+      ContextualizedController.default_contextualize_request(controller)
+    rescue StandardError => e
+       Rails.logger.dump_error('error setting controller context', e)
+    end
 
-      def current_context
-        @current_context || DEFAULT_CURRENT_CONTEXT
+    module ClassMethods
+      def contextualize_model_enabled?
+        return @contextualize_model_enabled if defined?(@contextualize_model_enabled)
+
+        ContextualizedController.default_contextualize_model
       end
 
-      def set_current_context(current_context)
-        @current_context = current_context
+      def contextualize_model(enable)
+        @contextualize_model_enabled = enable
       end
     end
   end

data/lib/contextualized_logs/contextualized_logger.rb

@@ -6,9 +6,82 @@ module ContextualizedLogs
   # support Rails.logger.dump('msg', hash)
 
   class ContextualizedLogger < ActiveSupport::Logger
+    class << self
+      attr_accessor :formatter
+      attr_writer :current_context
+
+      def current_context
+        @current_context || ContextualizedLogs.config.current_context
+      end
+      
+      def default_formatter
+        proc do |severity, timestamp, progname, msg|
+          # format (and enrich) log in JSON format (-> )
+          # https://docs.hq.com/logs/processing/attributes_naming_convention/#source-code
+          # correlation = Datadog.tracer.active_correlation
+          data = {
+            # dd: {
+            #   trace_id: correlation.trace_id,
+            #   span_id: correlation.span_id
+            # },
+            # ddsource: ['ruby'],
+            syslog: { env: Rails.env, host: Socket.gethostname },
+            type: severity.to_s,
+            time: timestamp
+          }
+          data[:stack] = Kernel.caller.
+            map { |caller| caller.gsub(/#{Rails.root}/, '') }.
+            reject { |caller| caller.start_with?('/usr/local') || caller.include?('/shared/bundle/') || caller.start_with?('/Users/') }.
+            first(15)
+          data[:log_type] = 'log'
+          data.merge!(parse_msg(msg)) # parse message (string, hash, error, ...)
+          data.merge!(current_context.context) # merge current request context
+          data.to_json + "\n"
+        end
+      end
+
+      private
+
+      def parse_msg(msg)
+        data = {}
+        case msg
+        when Hash
+          # used by logger.dump(msg|error, attributes = {})
+          if msg.include?(:attributes)
+            # adding message as log attributes if is a hash
+            data.merge!(parse_error(msg[:msg]))
+            data[:attributes] = msg[:attributes]
+          else
+            data.merge!(parse_error(msg))
+          end
+        else
+          data.merge!(parse_error(msg))
+        end
+        data
+      end
+
+      def parse_error(msg)
+        data = {}
+        case msg
+        when ::Exception
+          # format data to be interpreted as an error logs by
+          data[:error] = {
+            kind: msg.class.to_s,
+            message: msg.message,
+            stack: (msg.backtrace || []).join('; ')
+          }
+        else
+          data[:message] = msg.to_s
+        end
+        data
+      end
+    end
+
+    attr_accessor :formatter
+
     def initialize(*args)
       super(*args)
-      @formatter = formatter
+      @formatter = self.class.formatter || self.class.default_formatter
     end
 
     def dump(msg, attributes, severity = :info)
@@ -19,72 +92,6 @@ module ContextualizedLogs
     def dump_error(msg, attributes)
       dump(msg, attributes, :error)
     end
-
-    def current_context
-      CurrentContext.context
-    end
-
-    def formatter
-      Proc.new{|severity, timestamp, progname, msg|
-        # format (and enrich) log in JSON format (-> )
-        # https://docs.hq.com/logs/processing/attributes_naming_convention/#source-code
-        # correlation = Datadog.tracer.active_correlation
-        data = {
-          # dd: {
-          #   trace_id: correlation.trace_id,
-          #   span_id: correlation.span_id
-          # },
-          # ddsource: ['ruby'],
-          syslog: { env: Rails.env, host: Socket.gethostname },
-          type: severity.to_s,
-          time: timestamp
-        }
-        data[:stack] = Kernel.caller.
-          map { |caller| caller.gsub(/#{Rails.root}/, '') }.
-          reject { |caller| caller.start_with?('/usr/local') || caller.include?('/shared/bundle/') || caller.start_with?('/Users/') }.
-          first(15)
-        data[:log_type] = 'log'
-        data.merge!(parse_msg(msg)) # parse message (string, hash, error, ...)
-        data.merge!(current_context) # merge current request context
-        data.to_json + "\n"
-      }
-    end
-
-    private
-
-    def parse_msg(msg)
-      data = {}
-      case msg
-      when Hash
-        # used by logger.dump(msg|error, attributes = {})
-        if msg.include?(:attributes)
-          # adding message as log attributes if is a hash
-          data.merge!(parse_error(msg[:msg]))
-          data[:attributes] = msg[:attributes]
-        else
-          data.merge!(parse_error(msg))
-        end
-      else
-        data.merge!(parse_error(msg))
-      end
-      data
-    end
-
-    def parse_error(msg)
-      data = {}
-      case msg
-      when ::Exception
-        # format data to be interpreted as an error logs by
-        data[:error] = {
-          kind: msg.class.to_s,
-          message: msg.message,
-          stack: (msg.backtrace || []).join('; ')
-        }
-      else
-        data[:message] = msg.to_s
-      end
-      data
-    end
   end
 
 end