atatus 1.0.0

data/lib/atatus/config/bytes.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Atatus
+  class Config
+    # @api private
+    class Bytes
+      MULTIPLIERS = {
+        'kb' => 1024,
+        'mb' => 1024 * 1_000,
+        'gb' => 1024 * 100_000
+      }.freeze
+      REGEX = /^(\d+)(b|kb|mb|gb)?$/i.freeze
+
+      def initialize(default_unit: 'kb')
+        @default_unit = default_unit
+      end
+
+      def call(value)
+        _, amount, unit = REGEX.match(String(value)).to_a
+        unit ||= @default_unit
+        MULTIPLIERS.fetch(unit.downcase, 1) * amount.to_i
+      end
+    end
+  end
+end

data/lib/atatus/config/duration.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Atatus
+  class Config
+    # @api private
+    class Duration
+      MULTIPLIERS = { 'ms' => 0.001, 'm' => 60 }.freeze
+      REGEX = /^(-)?(\d+)(m|ms|s)?$/i.freeze
+
+      def initialize(default_unit: 's')
+        @default_unit = default_unit
+      end
+
+      def call(str)
+        _, negative, amount, unit = REGEX.match(String(str)).to_a
+        unit ||= @default_unit
+        seconds = MULTIPLIERS.fetch(unit.downcase, 1) * amount.to_i
+        seconds = 0 - seconds if negative
+        seconds
+      end
+    end
+  end
+end

data/lib/atatus/config/options.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Atatus
+  class Config
+    # @api private
+    module Options
+      # @api private
+      class Option
+        def initialize(
+          key,
+          value: nil,
+          type: :string,
+          default: nil,
+          converter: nil
+        )
+          @key = key
+          @type = type
+          @default = default
+          @converter = converter
+
+          set(value || default)
+        end
+
+        attr_reader :key, :value, :default, :type
+
+        def set(value)
+          @value = normalize(value)
+        end
+
+        def env_key
+          "ATATUS_#{key.upcase}"
+        end
+
+        private
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+        def normalize(val)
+          return unless val
+
+          if @converter
+            return @converter.call(val)
+          end
+
+          case type
+          when :string then val.to_s
+          when :int then val.to_i
+          when :float then val.to_f
+          when :bool then normalize_bool(val)
+          when :list then normalize_list(val)
+          when :dict then normalize_dict(val)
+          else
+            # raise "Unknown options type '#{type.inspect}'"
+            val
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+        def normalize_bool(val)
+          return val unless val.is_a?(String)
+          !%w[0 false].include?(val.strip.downcase)
+        end
+
+        def normalize_list(val)
+          return Array(val) unless val.is_a?(String)
+          val.split(/[ ,]/)
+        end
+
+        def normalize_dict(val)
+          return val unless val.is_a?(String)
+          Hash[val.split(/[&,]/).map { |kv| kv.split('=') }]
+        end
+      end
+
+      # @api private
+      module ClassMethods
+        def schema
+          @schema ||= {}
+        end
+
+        def option(*args)
+          key = args.shift
+          schema[key] = *args
+        end
+      end
+
+      # @api private
+      module InstanceMethods
+        def load_schema
+          Hash[self.class.schema.map do |key, args|
+            [key, Option.new(key, *args)]
+          end]
+        end
+
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def method_missing(name, *value)
+          name_str = name.to_s
+
+          if name_str.end_with?('=')
+            key = name_str[0...-1].to_sym
+            set(key, value.first)
+
+          elsif name_str.end_with?('?')
+            key = name_str[0...-1].to_sym
+            options.key?(key) ? options[key].value : super
+
+          elsif options.key?(name)
+            options.fetch(name).value
+
+          else
+            super
+          end
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+        def [](key)
+          options[key]
+        end
+        alias :get :[]
+
+        def set(key, value)
+          options.fetch(key.to_sym).set(value)
+        rescue KeyError
+          warn format("Unknown option '%s'", key)
+          nil
+        end
+      end
+
+      def self.extended(kls)
+        kls.instance_eval { extend ClassMethods }
+        kls.class_eval { include InstanceMethods }
+      end
+    end
+  end
+end

data/lib/atatus/config/regexp_list.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Atatus
+  class Config
+    # @api private
+    class RegexpList
+      def call(value)
+        value = value.is_a?(String) ? value.split(',') : Array(value)
+        value.map(&Regexp.method(:new))
+      end
+    end
+  end
+end

data/lib/atatus/context.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'atatus/context/request'
+require 'atatus/context/request/socket'
+require 'atatus/context/request/url'
+require 'atatus/context/response'
+require 'atatus/context/user'
+
+module Atatus
+  # @api private
+  class Context
+    def initialize(custom: {}, labels: {}, user: nil)
+      @custom = custom
+      @labels = labels
+      @user = user || User.new
+    end
+
+    attr_accessor :request
+    attr_accessor :response
+    attr_accessor :user
+    attr_reader :custom
+    attr_reader :labels
+
+    def empty?
+      return false if labels.any?
+      return false if custom.any?
+      return false if user.any?
+      return false if request || response
+
+      true
+    end
+  end
+end

data/lib/atatus/context/request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Atatus
+  class Context
+    # @api private
+    class Request
+      attr_accessor :body, :cookies, :env, :headers, :http_version, :method,
+        :socket, :url
+    end
+  end
+end

data/lib/atatus/context/request/socket.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  class Context
+    # @api private
+    class Request
+      # @api private
+      class Socket
+        def initialize(req)
+          @remote_addr = req.ip
+          @encrypted = req.scheme == 'https'
+        end
+
+        attr_reader :remote_addr, :encrypted
+      end
+    end
+  end
+end

data/lib/atatus/context/request/url.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  class Context
+    # @api private
+    class Request
+      # @api private
+      class Url
+        SKIPPED_PORTS = {
+          'http' => 80,
+          'https' => 443
+        }.freeze
+
+        def initialize(req)
+          @protocol = req.scheme
+          @hostname = req.host
+          @port = req.port.to_s
+          @pathname = req.path
+          @search = req.query_string
+          @hash = nil
+          @full = build_full_url req
+        end
+
+        attr_reader :protocol, :hostname, :port, :pathname, :search, :hash,
+          :full
+
+        private
+
+        def build_full_url(req)
+          url = "#{req.scheme}://#{req.host}"
+
+          if req.port != SKIPPED_PORTS[req.scheme]
+            url += ":#{req.port}"
+          end
+
+          url + req.fullpath
+        end
+      end
+    end
+  end
+end

data/lib/atatus/context/response.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Atatus
+  class Context
+    # @api private
+    class Response
+      def initialize(
+        status_code,
+        headers: {},
+        headers_sent: true,
+        finished: true
+      )
+        @status_code = status_code
+        @headers = headers
+        @headers_sent = headers_sent
+        @finished = finished
+      end
+
+      attr_accessor :status_code, :headers, :headers_sent, :finished
+    end
+  end
+end

data/lib/atatus/context/user.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Atatus
+  class Context
+    # @api private
+    class User
+      def initialize(id: nil, email: nil, username: nil)
+        @id = id
+        @email = email
+        @username = username
+      end
+
+      def self.infer(config, record)
+        return unless record
+
+        new(
+          id: safe_get(record, config.current_user_id_method)&.to_s,
+          email: safe_get(record, config.current_user_email_method),
+          username: safe_get(record, config.current_user_username_method)
+        )
+      end
+
+      attr_accessor :id, :email, :username
+
+      def empty?
+        !id && !email && !username
+      end
+
+      def any?
+        !empty?
+      end
+
+      class << self
+        private
+
+        def safe_get(record, method_name)
+          record.respond_to?(method_name) ? record.send(method_name) : nil
+        end
+      end
+    end
+  end
+end

data/lib/atatus/context_builder.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  class ContextBuilder
+    MAX_BODY_LENGTH = 2048
+    SKIPPED = '[SKIPPED]'
+
+    def initialize(config)
+      @config = config
+    end
+
+    attr_reader :config
+
+    def build(rack_env:, for_type:)
+      Context.new.tap do |context|
+        apply_to_request(context, rack_env: rack_env, for_type: for_type)
+      end
+    end
+
+    private
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def apply_to_request(context, rack_env:, for_type:)
+      req = rails_req?(rack_env) ? rack_env : Rack::Request.new(rack_env)
+
+      context.request = Context::Request.new unless context.request
+      request = context.request
+
+      request.socket = Context::Request::Socket.new(req)
+      request.http_version = build_http_version rack_env
+      request.method = req.request_method
+      request.url = Context::Request::Url.new(req)
+
+      request.body = should_capture_body?(for_type) ? get_body(req) : SKIPPED
+
+      headers, env = get_headers_and_env(rack_env)
+      request.headers = headers if config.capture_headers?
+      request.env = env if config.capture_env?
+
+      request.cookies = req.cookies
+
+      context
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    def should_capture_body?(for_type)
+      option = config.capture_body
+
+      return true if option == 'all'
+      return true if option == 'transactions' && for_type == :transaction
+      return true if option == 'errors' && for_type == :error
+
+      false
+    end
+
+    def get_body(req)
+      case req.media_type
+      when 'application/x-www-form-urlencoded', 'multipart/form-data'
+        req.POST.dup
+      else
+        body = req.body.read
+        req.body.rewind
+        body.byteslice(0, MAX_BODY_LENGTH).force_encoding('utf-8')
+      end
+    end
+
+    def rails_req?(env)
+      defined?(ActionDispatch::Request) && env.is_a?(ActionDispatch::Request)
+    end
+
+    def get_headers_and_env(rack_env)
+      # In Rails < 5 ActionDispatch::Request inherits from Hash
+      headers =
+        rack_env.respond_to?(:headers) ? rack_env.headers : rack_env
+
+      headers.each_with_object([{}, {}]) do |(key, value), (http, env)|
+        next unless key == key.upcase
+
+        if key.start_with?('HTTP_')
+          http[camel_key(key)] = value
+        else
+          env[key] = value
+        end
+      end
+    end
+
+    def camel_key(key)
+      key.gsub(/^HTTP_/, '').split('_').map(&:capitalize).join('-')
+    end
+
+    def build_http_version(rack_env)
+      return unless (http_version = rack_env['HTTP_VERSION'])
+      http_version.gsub(%r{HTTP/}, '')
+    end
+  end
+end