strum-logs 1.0.0

data/lib/strum_logs/default_logger.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "singleton"
+module StrumLogs
+  class DefaultLogger
+    include Singleton
+
+    attr_reader :logger
+
+    def initialize
+      @logger = init_log_system
+    end
+
+    def self.logger
+      instance.logger
+    end
+
+    private
+
+    def init_log_system # rubocop:disable Metrics/AbcSize
+      $stdout.sync = true if Configuration.config.stdout_sync
+      logger = Ougai::Logger.new($stdout)
+      logger.before_log = lambda do |data|
+        tracer_info_set(data)
+      end
+      logger.level = Configuration.config.level
+      logger.formatter = Ougai::Formatters::Readable.new unless %w[prod production
+                                                                   test].include?(Configuration.config.environment)
+      logger.with_fields = { service_name: Configuration.config.application_name,
+                             version: Configuration.config.application_version }
+      logger
+    end
+
+    def tracer_info_set(data)
+      span = OpenTelemetry::Trace.current_span(OpenTelemetry::Context.current)
+      context = span.context
+      data[:trace_id] = context.hex_trace_id
+      data[:span_id] = context.hex_span_id
+    end
+  end
+end

data/lib/strum_logs/default_telemetry.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "singleton"
+module StrumLogs
+  class DefaultTelemetry
+    include Singleton
+
+    attr_reader :tracer
+
+    def initialize
+      @tracer = init_tracer
+    end
+
+    def self.tracer
+      instance.tracer
+    end
+
+    private
+
+    def init_tracer
+      open_telemetry_config
+      OpenTelemetry.tracer_provider.tracer(Configuration.config.application_name,
+                                           Configuration.config.application_version)
+    end
+
+    def open_telemetry_config # rubocop:disable  Metrics/CyclomaticComplexity,Metrics/AbcSize
+      ENV["OTEL_TRACES_EXPORTER"] = "none" if !Configuration.config.enable_export_spans && !ENV.key?("OTEL_TRACES_EXPORTER")
+      OpenTelemetry::SDK.configure do |c|
+        c.service_name = Configuration.config.application_name
+        c.service_version = Configuration.config.application_version
+        c.use "OpenTelemetry::Instrumentation::PG" if Configuration.config.pg_instrumentation
+        c.use "OpenTelemetry::Instrumentation::Redis" if Configuration.config.redis_instrumentation
+        c.use "OpenTelemetry::Instrumentation::Rack" if Configuration.config.rack_instrumentation
+        c.use "OpenTelemetry::Instrumentation::Faraday" if Configuration.config.faraday_instrumentation
+        c.use "OpenTelemetry::Instrumentation::Bunny" if Configuration.config.rabbit_instrumentation
+      end
+    end
+  end
+end

data/lib/strum_logs/errors/configuration_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module StrumLogs
+  module Errors
+    class Configuration < StandardError; end
+  end
+end

data/lib/strum_logs/esb_formatter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module StrumLogs
+  class EsbFormatter
+    def self.call(severity, time, _program_name, message)
+      {
+        level: severity,
+        pid: Process.pid,
+        message: message[:msg],
+        started_at: time.utc.iso8601
+      }.merge!(message)
+    end
+  end
+end

data/lib/strum_logs/esb_hooks.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "strum_logs/configuration"
+
+module StrumLogs
+  class StrumEsbHooks
+    class << self
+      def before_publish_hook(body, properties)
+        DefaultLogger.logger.info({ message: "Publishing AMQP message",
+                                    body: body,
+                                    properties: properties,
+                                    protocol: "AMQP" })
+      end
+
+      def before_handler_hook(body, properties, metadata)
+        DefaultLogger.logger.info({ message: "Handling AMQP message",
+                                    body: body,
+                                    properties: properties,
+                                    protocol: "AMQP",
+                                    metadata: metadata })
+      end
+
+      def after_handler_hook(body, properties, metadata, payload, error)
+        data = handler_payload(body, properties, metadata, payload)
+        if error
+          data[:message] = "Failed to process AMQP message"
+          data[:error] = error
+          data[:stack_trace] = error.backtrace if Configuration.config.stack_trace
+          DefaultLogger.logger.error(data)
+        else
+          DefaultLogger.logger.info(data)
+        end
+      end
+
+      private
+
+      def handler_payload(body, properties, metadata, payload)
+        { message: "After handling AMQP message",
+          body: payload || body,
+          protocol: "AMQP",
+          consumer_tag: properties[:consumer_tag],
+          redelivered: properties[:redelivered],
+          exchange: properties[:exchange],
+          routing_key: properties[:routing_key],
+          content_type: metadata[:content_type],
+          headers: metadata[:headers],
+          delivery_mode: metadata[:delivery_mode] }
+      end
+    end
+  end
+end

data/lib/strum_logs/faraday_log_middleware.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "strum_logs/default_logger"
+require "strum_logs/helpers/http_log_helper"
+
+module StrumLogs
+  module Faraday
+    class RequestLogMiddleware
+      include StrumLogs::Helpers::HttpLogHelper
+
+      def initialize(app)
+        @app = app
+        @logger = DefaultLogger.instance.logger
+        @tracer = DefaultTelemetry.instance.tracer
+      end
+
+      def call(request_env)
+        @tracer.in_span(request_env.url.to_s, kind: :client) do |span|
+          logging_process(request_env, span)
+        end
+      end
+
+      def logging_process(request_env, span)
+        OpenTelemetry.propagation.inject(request_env.request_headers)
+        log_entity = init_log(request_env)
+        @app.call(request_env).on_complete do |response_env|
+          tracer_info_set(response_env)
+          log_data(log_entity, response_env)
+          log_status(log_entity, response_env)
+        rescue StandardError => e
+          error_process(log_entity, e, span)
+          raise e
+        ensure
+          logg_process(log_entity, response_env)
+        end
+      end
+
+      def log_status(log_entity, env)
+        env.success? ? log_entity.merge!({ log_status: "success" }) : log_entity.merge!({ log_status: "error" })
+      end
+
+      def log_data(log_entity, response_env)
+        log_entity[:status] = response_env.status
+        log_entity[:headers] = response_env.response_headers
+        log_entity[:response_message] = parse_body(response_env.response_body)
+      end
+
+      def init_log(env)
+        {
+          method: env.method.to_s.upcase,
+          path: env.url.to_s,
+          query: query_string(env),
+          protocol: "HTTP",
+          started_at: Time.now,
+          peer: peer(env),
+          message: "Faraday HTTP Request"
+        }
+      end
+
+      def tracer_info_set(response_env)
+        span = OpenTelemetry::Trace.current_span(OpenTelemetry::Context.current)
+        context = span.context
+        response_env.response_headers[:trace_id] = context.hex_trace_id
+        response_env.response_headers[:span_id] = context.hex_span_id
+      end
+
+      def peer(env)
+        env.url&.to_s&.match(%r{//([^/]*)/})&.captures&.first || ""
+      end
+
+      def query_string(env)
+        env.url&.to_s&.match(/\?.*/).to_s
+      end
+    end
+  end
+end

data/lib/strum_logs/helpers/http_log_helper.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module StrumLogs
+  module Helpers
+    module HttpLogHelper
+      def error_process(log_entity, error, span)
+        log_entity[:error] = error.message
+        log_entity[:stack_trace] = error.backtrace if Configuration.config.stack_trace
+        headers = { "content-type" => "application/json" }
+        response = { trace_id: span.context.hex_trace_id, span_id: span.context.hex_span_id, error: error.message }
+        span.record_exception(error)
+        [500, headers, [Oj.dump(response)]]
+      end
+
+      def logg_process(log_entity, env)
+        log_entity[:request] = env["roda.json_params"]
+        log_entity[:elapsed_ms] = elapsed_ms(log_entity)
+        output(log_entity)
+      end
+
+      def elapsed_ms(log_entity)
+        log_entity[:finished] = Time.now
+        ((log_entity[:finished] - log_entity[:started_at]) * 1000).round(4)
+      end
+
+      def output(log_entity)
+        if log_entity[:error]
+          @logger.error(log_entity)
+        else
+          @logger.info(log_entity)
+        end
+      end
+
+      def parse_body(body)
+        case body
+        when Hash
+          body
+        when Array
+          body.first
+        else
+          body
+        end
+      end
+    end
+  end
+end

data/lib/strum_logs/redis_client.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "strum_logs/configuration"
+require "strum_logs/default_logger"
+require "redis"
+
+class Redis
+  class Client
+
+    def call(command)
+      reply = process([command]) { read }
+      StrumLogs::Configuration.config.redis_after_call_hooks.each { |hook| hook.call(command, reply) }
+      raise reply if reply.is_a?(CommandError)
+
+      if block_given? && reply != "QUEUED"
+        yield reply
+      else
+        reply
+      end
+    end
+
+    def log(command, reply)
+      logger = StrumLogs::DefaultLogger.instance.logger
+      logs = { request: command.join(" "), message: "redis request" }
+      logger.error(logs.merge({ error: reply })) && return if reply.is_a?(CommandError)
+
+      logger.info(logs.merge({ response_message: reply }))
+    end
+  end
+end

data/lib/strum_logs/redis_logger.rb

@@ -0,0 +1,20 @@
+require "strum_logs/default_logger"
+require 'redis'
+
+
+module StrumLogs
+  module Redis
+    class Logger
+      def initialize
+        @logger = StrumLogs::DefaultLogger.instance.logger
+      end
+
+      def call(command, reply)
+        logs = { request: command.join(" "), message: "redis request" }
+        @logger.error(logs.merge({ error: reply })) && return if reply.is_a?(::Redis::CommandError)
+
+        @logger.info(logs.merge({ response_message: reply }))
+      end
+    end
+  end
+end

data/lib/strum_logs/request_log_middleware.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "strum_logs/configuration"
+require "strum_logs/helpers/http_log_helper"
+
+module StrumLogs
+  module Rack
+    class RequestLogMiddleware
+      include StrumLogs::Configuration
+      include StrumLogs::Helpers::HttpLogHelper
+
+      def initialize(app)
+        @app = app
+        @logger = DefaultLogger.instance.logger
+        @tracer = DefaultTelemetry.instance.tracer
+      end
+
+      def propagation_context(env)
+        getter = OpenTelemetry::Common::Propagation.rack_env_getter
+        OpenTelemetry.propagation.extract(env, getter: getter)
+      end
+
+      def call(env)
+        OpenTelemetry::Context.with_current(propagation_context(env)) do
+          @tracer.in_span(env["PATH_INFO"], kind: :server) do |span|
+            logging_process(env, span)
+          end
+        end
+      end
+
+      def logging_process(env, span)
+        log_entity = init_log(env)
+        status, headers, body = @app.call(env)
+        log_entity[:status] = status
+        log_entity[:headers] = headers
+        log_entity[:response_message] = parse_body(body)
+        log_status(log_entity)
+        [status, headers, body]
+      rescue StandardError => e
+        error_process(log_entity, e, span)
+      ensure
+        propagate(headers)
+        logg_process(log_entity, env)
+      end
+
+      private
+
+      def propagate(headers)
+        return unless StrumLogs::Configuration.config.enable_export_spans
+
+        setter = OpenTelemetry::Context::Propagation.text_map_setter
+        OpenTelemetry.propagation.inject(headers, setter: setter)
+      end
+
+      def log_status(log_entity)
+        success?(log_entity[:status]) ? log_entity.merge!({ log_status: "success" }) : log_entity.merge!({ log_status: "error" })
+      end
+
+      def success?(status)
+        SUCCESSFUL_STATUSES.include?(status)
+      end
+
+      def init_log(env)
+        {
+          method: env["REQUEST_METHOD"],
+          path: env["PATH_INFO"],
+          query: query_string(env),
+          protocol: env["SERVER_PROTOCOL"],
+          started_at: Time.now,
+          peer: env["HTTP_X_FORWARDED_FOR"] || env["REMOTE_ADDR"],
+          message: "HTTP Request",
+          user: env["REMOTE_USER"]
+        }
+      end
+
+      def query_string(env)
+        env["QUERY_STRING"] == "" ? nil : env["QUERY_STRING"]
+      end
+    end
+  end
+end

data/lib/strum_logs/sequel_logger.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "sequel"
+require "strum_logs/default_logger"
+
+module StrumLogs
+  module Sequel
+    class Logger
+
+      def initialize
+        @logger = StrumLogs::DefaultLogger.instance.logger
+      end
+
+      def public_send(level, message)
+        logs = { message: "sequel request" }
+        @logger.error(logs.merge({ error: message })) && return if level == :error
+
+        @logger.info(logs.merge({ request: message }))
+      end
+    end
+  end
+end

data/lib/strum_logs/span_exporter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module StrumLogs
+  class LoggingSpanExporter
+    def initialize
+      @stopped = false
+    end
+
+    def export(spans, _timeout: nil)
+      return FAILURE if @stopped
+
+      Array(spans).each { |s| StrumLogs::DefaultLogger.logger.info(s) }
+
+      SUCCESS
+    end
+
+    def force_flush(_timeout: nil)
+      SUCCESS
+    end
+
+    def shutdown(_timeout: nil)
+      @stopped = true
+      SUCCESS
+    end
+  end
+end

data/lib/strum_logs/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module StrumLogs
+  VERSION = "1.0.0"
+end

data/lib/strum_logs.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "ougai"
+require "opentelemetry/common"
+require "opentelemetry/sdk"
+require "opentelemetry/exporter/otlp"
+require "opentelemetry/instrumentation/pg"
+require "opentelemetry/instrumentation/redis"
+require "opentelemetry/instrumentation/rack"
+require "opentelemetry/instrumentation/faraday"
+require "opentelemetry/instrumentation/sinatra"
+require "strum_logs/request_log_middleware"
+require "strum_logs/default_logger"
+require "strum_logs/configuration"
+require "strum_logs/faraday_log_middleware"
+require "strum_logs/redis_logger"
+require "strum_logs/default_telemetry"
+require "strum_logs/span_exporter"
+require "strum_logs/esb_hooks"
+require "strum_logs/esb_formatter"
+require "strum_logs/errors/configuration_error"
+require "strum_logs/sequel_logger"
+require 'strum_logs/redis_client'

data/sig/strum/logs.rbs

@@ -0,0 +1,6 @@
+module Strum
+  module Logs
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

data/strum_logs.gemspec

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "strum_logs/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "strum-logs"
+  spec.version       = ::StrumLogs::VERSION
+  spec.authors       = ["Serhiy Nazarov"]
+  spec.email         = ["sn@nazarov.com.ua"]
+
+  spec.summary       = "Logs"
+  spec.description   = "Write a longer description or delete this line."
+  spec.require_paths = ["lib"]
+  spec.homepage      = "https://gitlab.com/strum-rb/strum-logs"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
+  spec.metadata = {
+    "rubygems_mfa_required" => "true"
+  }
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+
+  spec.add_runtime_dependency "opentelemetry-common", "~> 0.19"
+  spec.add_runtime_dependency "opentelemetry-exporter-otlp", "~> 0.22"
+  spec.add_runtime_dependency "opentelemetry-instrumentation-bunny", "~> 0.19"
+  spec.add_runtime_dependency "opentelemetry-instrumentation-faraday", "~> 0.21"
+  spec.add_runtime_dependency "opentelemetry-instrumentation-pg", "~> 0.21"
+  spec.add_runtime_dependency "opentelemetry-instrumentation-rack", "~> 0.21"
+  spec.add_runtime_dependency "opentelemetry-instrumentation-redis", "~> 0.23"
+  spec.add_runtime_dependency "opentelemetry-instrumentation-sinatra", "~> 0.20"
+  spec.add_runtime_dependency "opentelemetry-sdk", "~> 1.1"
+  spec.add_runtime_dependency "sequel", "~> 5.24"
+
+  spec.add_runtime_dependency "amazing_print", "~> 1.4"
+  spec.add_runtime_dependency "ougai", "~> 2.0"
+  spec.add_development_dependency "faraday", "~> 1.10.0"
+  spec.add_development_dependency "faraday_middleware", "~> 1.2.0"
+  spec.add_runtime_dependency "rack", "~> 2.2.4"
+  spec.add_development_dependency "rake", "~> 13"
+  spec.add_runtime_dependency "redis"
+  spec.add_development_dependency "rubocop", "~> 1.30"
+  spec.add_development_dependency "strum-esb"
+  spec.add_runtime_dependency "dry-configurable", "~> 0.12.1"
+end