periskop-client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0d35f32e41d59a38412f7c5a424fe1586c836313c48af76ffa2aadbddd36b15b
+  data.tar.gz: 6a03127bfa7a1f521d2719557330c8dc9c4d2d4f11f24c8da612ce2249e16302
+SHA512:
+  metadata.gz: 1e7fdfa8becf464beba2e157dc5baf55d7a71f23f628b64e43d7f39ec830a67e497fe02bddaff931b37b56279abcbf20fd6144827286a1d1b734ce7b2f6172fb
+  data.tar.gz: 4c50cdae5ac0f5c619567074ef53470157b730c6005799c365a47decb99ec740beee943a10bad70fcbf322db9e7d293082b1455723802ccd374028d89e8b6ce7

data/lib/periskop/client/collector.rb

@@ -0,0 +1,71 @@
+require 'periskop/client/models'
+require 'json'
+require 'securerandom'
+
+module Periskop
+  module Client
+    # ExceptionCollector collects reported exceptions and aggregates them
+    class ExceptionCollector
+      def initialize
+        @aggregated_exceptions_dict = {}
+        @uuid = SecureRandom.uuid
+      end
+
+      attr_reader :aggregated_exceptions_dict
+
+      def aggregated_exceptions
+        Payload.new(@aggregated_exceptions_dict.values, @uuid)
+      end
+
+      # Report an exception
+      # Params:
+      # exception:: captured exception
+      def report(exception)
+        add_exception(exception, nil)
+      end
+
+      # Report an exception with context
+      # Params:
+      # exception:: captured exception
+      # context:: HTTP context of the exception
+      def report_with_context(exception, context)
+        add_exception(exception, context)
+      end
+
+      private
+
+      def add_exception(exception, context)
+        exception_instance = ExceptionInstance.new(
+          exception.class.name,
+          exception.message,
+          exception.backtrace,
+          get_cause(exception)
+        )
+        exception_with_context = ExceptionWithContext.new(
+          exception_instance,
+          context,
+          Periskop::Client::SEVERITY_ERROR
+        )
+        aggregation_key = exception_with_context.aggregation_key()
+
+        unless @aggregated_exceptions_dict.key?(aggregation_key)
+          aggregated_exception = AggregatedException.new(
+            aggregation_key,
+            Periskop::Client::SEVERITY_ERROR
+          )
+          @aggregated_exceptions_dict.store(aggregation_key, aggregated_exception)
+        end
+        aggregated_exception = @aggregated_exceptions_dict[aggregation_key]
+        aggregated_exception.add_exception(exception_with_context)
+      end
+
+      def get_cause(exception)
+        if RUBY_VERSION > '2.0'
+          return exception.cause
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/periskop/client/exporter.rb

@@ -0,0 +1,25 @@
+require 'net/http'
+require 'uri'
+
+module Periskop
+  module Client
+    # Exporter exposes in json format all collected exceptions from the specified `collector`
+    class Exporter
+      def initialize(collector)
+        @collector = collector
+      end
+
+      def export
+        @collector.aggregated_exceptions.to_json
+      end
+
+      def push_to_gateway(addr)
+        uri = URI.parse("#{addr}/errors")
+        http = Net::HTTP.new(uri.host, uri.port)
+        request = Net::HTTP::Post.new(uri.request_uri, 'Content-Type' => 'application/json')
+        request.body = export
+        http.request(request)
+      end
+    end
+  end
+end

data/lib/periskop/client/models.rb

@@ -0,0 +1,154 @@
+require 'time'
+require 'securerandom'
+require 'digest'
+
+module Periskop
+  module Client
+    SEVERITY_INFO = "info"
+    SEVERITY_WARNING = "warning"
+    SEVERITY_ERROR = "error"
+    # ExceptionInstance has all metadata of a reported exception
+    class ExceptionInstance
+      attr_accessor :class, :message, :stacktrace, :cause
+
+      def initialize(cls, message, stacktrace, cause)
+        @class = cls
+        @message = message
+        @stacktrace = stacktrace
+        @cause = cause
+      end
+
+      def as_json(_options = {})
+        {
+          class: @class,
+          message: @message,
+          stacktrace: @stacktrace,
+          cause: @cause
+        }
+      end
+
+      def to_json(*options)
+        as_json(*options).to_json(*options)
+      end
+    end
+
+    # HTTPContext represents data from HTTP context of an exception
+    class HTTPContext
+      attr_accessor :request_method
+
+      def initialize(request_method, request_url, request_headers, request_body)
+        @request_method = request_method
+        @request_url = request_url
+        @request_headers = request_headers
+        @request_body = request_body
+      end
+
+      def as_json(_options = {})
+        {
+          request_method: @request_method,
+          request_url: @request_url,
+          request_headers: @request_headers,
+          request_body: @request_body
+        }
+      end
+
+      def to_json(*options)
+        as_json(*options).to_json(*options)
+      end
+    end
+
+    # ExceptionWithContext represents a reported exception with HTTP context
+    class ExceptionWithContext
+      attr_accessor :exception_instance, :http_context
+
+      NUM_HASH_CHARS = 8
+      MAX_TRACES = 5
+
+      def initialize(exception_instance, http_context, severity)
+        @exception_instance = exception_instance
+        @http_context = http_context
+        @severity = severity
+        @uuid = SecureRandom.uuid
+        @timestamp = Time.now.utc.iso8601
+      end
+
+      # Generates the aggregation key with a hash using the last MAX_TRACES
+      def aggregation_key
+        stacktrace_head = @exception_instance.stacktrace.first(MAX_TRACES).join('')
+        error_hash = Digest::MD5.hexdigest(stacktrace_head)[0..NUM_HASH_CHARS - 1]
+        "#{@exception_instance.class}@#{error_hash}"
+      end
+
+      def as_json(_options = {})
+        {
+          error: @exception_instance,
+          http_context: @http_context,
+          severity: @severity,
+          uuid: @uuid,
+          timestamp: @timestamp
+        }
+      end
+
+      def to_json(*options)
+        as_json(*options).to_json(*options)
+      end
+    end
+
+    # AggregatedException represents the aggregation of a group of exceptions
+    class AggregatedException
+      attr_accessor :latest_errors, :total_count
+
+      MAX_ERRORS = 10
+
+      def initialize(aggregation_key, severity)
+        @aggregation_key = aggregation_key
+        @latest_errors = []
+        @total_count = 0
+        @severity = severity
+        @created_at = Time.now.utc.iso8601
+      end
+
+      # Add exception to the list of latest errors up to MAX_ERRORS
+      def add_exception(exception_with_context)
+        if @latest_errors.size >= MAX_ERRORS
+          @latest_errors.shift
+        end
+        @latest_errors.push(exception_with_context)
+        @total_count += 1
+      end
+
+      def as_json(_options = {})
+        {
+          aggregation_key: @aggregation_key,
+          created_at: @created_at,
+          total_count: @total_count,
+          severity: @severity,
+          latest_errors: @latest_errors
+        }
+      end
+
+      def to_json(*options)
+        as_json(*options).to_json(*options)
+      end
+    end
+
+    # Payload represents the aggregated structure of errors
+    class Payload
+      def initialize(aggregated_errors, target_uuid)
+        @aggregated_errors = aggregated_errors
+        @target_uuid = target_uuid
+      end
+
+      def as_json(_options = {})
+        {
+          aggregated_errors: @aggregated_errors,
+          target_uuid: @target_uuid
+        }
+      end
+
+      def to_json(*options)
+        as_json(*options).to_json(*options)
+      end
+    end
+  end
+end

data/lib/periskop/periskop.rb

@@ -0,0 +1,3 @@
+# Periskop module
+module Periskop
+end

data/lib/periskop/rack/middleware.rb

@@ -0,0 +1,92 @@
+require 'periskop/client/collector'
+require 'periskop/client/exporter'
+require 'periskop/client/models'
+
+module Periskop
+  module Rack
+    class Middleware
+      attr_accessor :collector
+
+      def initialize(app, options = {})
+        @app = app
+        @pushgateway_address = options.fetch(:pushgateway_address)
+        options[:collector] ||= Periskop::Client::ExceptionCollector.new
+        @collector = options.fetch(:collector)
+
+        @exporter =
+          if @pushgateway_address
+            @exporter = Periskop::Client::Exporter.new(@collector)
+          end
+      end
+
+      def call(env)
+        begin
+          response = @app.call(env)
+        rescue Exception => ex
+          report_push(env, ex)
+          raise(ex)
+        end
+
+        maybe_ex = framework_exception(env)
+        report_push(env, maybe_ex) if maybe_ex
+
+        response
+      end
+
+      private
+
+      # Web framework middlewares often store rescued exceptions inside the
+      # Rack env, but Rack doesn't have a standard key for it:
+      #
+      # - Rails uses action_dispatch.exception: https://goo.gl/Kd694n
+      # - Sinatra uses sinatra.error: https://goo.gl/LLkVL9
+      # - Goliath uses rack.exception: https://goo.gl/i7e1nA
+      def framework_exception(env)
+        env['rack.exception'] ||
+          env['sinatra.error'] ||
+          env['action_dispatch.exception']
+      end
+
+      def find_request(env)
+        if defined?(ActionDispatch::Request)
+          ActionDispatch::Request.new(env)
+        elsif defined?(Sinatra::Request)
+          Sinatra::Request.new(env)
+        else
+          ::Rack::Request.new(env)
+        end
+      end
+
+      def get_http_headers(request_env)
+        header_prefixes = %w[
+          HTTP_
+          CONTENT_TYPE
+          CONTENT_LENGTH
+        ].freeze
+
+        request_env.map.with_object({}) do |(key, value), headers|
+          if header_prefixes.any? { |prefix| key.to_s.start_with?(prefix) }
+            headers[key] = value
+          end
+          headers
+        end
+      end
+
+      def get_http_context(env)
+        request = find_request(env)
+        Periskop::Client::HTTPContext.new(request.request_method, request.url, get_http_headers(request.env), nil)
+      end
+
+      def report_push(env, maybe_ex)
+        ex =
+          if maybe_ex.is_a?(Exception)
+            maybe_ex
+          else
+            RuntimeError.new(maybe_ex.to_s)
+          end
+        @collector.report_with_context(ex, get_http_context(env))
+        @exporter&.push_to_gateway(@pushgateway_address)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: periskop-client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Julio Zynger
+- Marc Tuduri
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-01-14 00:00:00.000000000 Z
+dependencies: []
+description: Periskop client for Ruby
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/periskop/client/collector.rb
+- lib/periskop/client/exporter.rb
+- lib/periskop/client/models.rb
+- lib/periskop/periskop.rb
+- lib/periskop/rack/middleware.rb
+homepage: 
+licenses:
+- Apache
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Periskop client for Ruby
+test_files: []