sentry-ruby 0.1.1

data/lib/sentry/ruby.rb

@@ -0,0 +1 @@
+require "sentry"

data/lib/sentry/scope.rb

@@ -0,0 +1,192 @@
+require "sentry/breadcrumb_buffer"
+require "etc"
+
+module Sentry
+  class Scope
+    ATTRIBUTES = [:transaction_names, :contexts, :extra, :tags, :user, :level, :breadcrumbs, :fingerprint, :event_processors, :rack_env]
+
+    attr_reader(*ATTRIBUTES)
+
+    def initialize
+      set_default_value
+    end
+
+    def clear
+      set_default_value
+    end
+
+    def apply_to_event(event)
+      event.tags = tags.merge(event.tags)
+      event.user = user.merge(event.user)
+      event.extra = extra.merge(event.extra)
+      event.contexts = contexts.merge(event.contexts)
+      event.fingerprint = fingerprint
+      event.level ||= level
+      event.transaction = transaction_names.last
+      event.breadcrumbs = breadcrumbs
+      event.rack_env = rack_env
+
+      unless @event_processors.empty?
+        @event_processors.each do |processor_block|
+          event = processor_block.call(event)
+        end
+      end
+
+      event
+    end
+
+    def add_breadcrumb(breadcrumb)
+      breadcrumbs.record(breadcrumb)
+    end
+
+    def clear_breadcrumbs
+      @breadcrumbs = BreadcrumbBuffer.new
+    end
+
+    def dup
+      copy = super
+      copy.breadcrumbs = breadcrumbs.dup
+      copy.contexts = contexts.deep_dup
+      copy.extra = extra.deep_dup
+      copy.tags = tags.deep_dup
+      copy.user = user.deep_dup
+      copy.transaction_names = transaction_names.deep_dup
+      copy.fingerprint = fingerprint.deep_dup
+      copy
+    end
+
+    def update_from_scope(scope)
+      self.breadcrumbs = scope.breadcrumbs
+      self.contexts = scope.contexts
+      self.extra = scope.extra
+      self.tags = scope.tags
+      self.user = scope.user
+      self.transaction_names = scope.transaction_names
+      self.fingerprint = scope.fingerprint
+    end
+
+    def update_from_options(
+      contexts: nil,
+      extra: nil,
+      tags: nil,
+      user: nil,
+      level: nil,
+      fingerprint: nil
+    )
+      self.contexts.merge!(contexts) if contexts
+      self.extra.merge!(extra) if extra
+      self.tags.merge!(tags) if tags
+      self.user = user if user
+      self.level = level if level
+      self.fingerprint = fingerprint if fingerprint
+    end
+
+    def set_rack_env(env)
+      env = env || {}
+      @rack_env = env
+    end
+
+    def set_user(user_hash)
+      check_argument_type!(user_hash, Hash)
+      @user = user_hash
+    end
+
+    def set_extras(extras_hash)
+      check_argument_type!(extras_hash, Hash)
+      @extra.merge!(extras_hash)
+    end
+
+    def set_extra(key, value)
+      @extra.merge!(key => value)
+    end
+
+    def set_tags(tags_hash)
+      check_argument_type!(tags_hash, Hash)
+      @tags.merge!(tags_hash)
+    end
+
+    def set_tag(key, value)
+      @tags.merge!(key => value)
+    end
+
+    def set_contexts(contexts_hash)
+      check_argument_type!(contexts_hash, Hash)
+      @contexts = contexts_hash
+    end
+
+    def set_context(key, value)
+      @contexts.merge!(key => value)
+    end
+
+    def set_level(level)
+      @level = level
+    end
+
+    def set_transaction_name(transaction_name)
+      @transaction_names << transaction_name
+    end
+
+    def transaction_name
+      @transaction_names.last
+    end
+
+    def set_fingerprint(fingerprint)
+      check_argument_type!(fingerprint, Array)
+
+      @fingerprint = fingerprint
+    end
+
+    def add_event_processor(&block)
+      @event_processors << block
+    end
+
+    protected
+
+    # for duplicating scopes internally
+    attr_writer(*ATTRIBUTES)
+
+    private
+
+    def check_argument_type!(argument, expected_type)
+      unless argument.is_a?(expected_type)
+        raise ArgumentError, "expect the argument to be a #{expected_type}, got #{argument.class} (#{argument})"
+      end
+    end
+
+    def set_default_value
+      @breadcrumbs = BreadcrumbBuffer.new
+      @contexts = { :os => self.class.os_context, :runtime => self.class.runtime_context }
+      @extra = {}
+      @tags = {}
+      @user = {}
+      @level = :error
+      @fingerprint = []
+      @transaction_names = []
+      @event_processors = []
+      @rack_env = {}
+    end
+
+    class << self
+      def os_context
+        @os_context ||=
+          begin
+            uname = Etc.uname
+            {
+              name: uname[:sysname] || RbConfig::CONFIG["host_os"],
+              version: uname[:version],
+              build: uname[:release],
+              kernel_version: uname[:version]
+            }
+          end
+      end
+
+      def runtime_context
+        @runtime_context ||= {
+          name: RbConfig::CONFIG["ruby_install_name"],
+          version: RUBY_DESCRIPTION || Sentry.sys_command("ruby -v")
+        }
+      end
+    end
+
+  end
+end

data/lib/sentry/transport.rb

@@ -0,0 +1,110 @@
+require "json"
+require "base64"
+require "sentry/transport/state"
+
+module Sentry
+  class Transport
+    PROTOCOL_VERSION = '5'
+    USER_AGENT = "sentry-ruby/#{Sentry::VERSION}"
+    CONTENT_TYPE = 'application/json'
+
+    attr_accessor :configuration, :state
+
+    def initialize(configuration)
+      @configuration = configuration
+      @transport_configuration = configuration.transport
+      @dsn = configuration.dsn
+      @state = State.new
+    end
+
+    def send_data(data, options = {})
+      raise NotImplementedError
+    end
+
+    def send_event(event)
+      content_type, encoded_data = prepare_encoded_event(event)
+
+      return nil unless encoded_data
+
+      begin
+        if configuration.async?
+          begin
+            # We have to convert to a JSON-like hash, because background job
+            # processors (esp ActiveJob) may not like weird types in the event hash
+            configuration.async.call(event.to_json_compatible)
+          rescue => e
+            configuration.logger.error(LOGGER_PROGNAME) { "async event sending failed: #{e.message}" }
+            send_data(encoded_data, content_type: content_type)
+          end
+        else
+          send_data(encoded_data, content_type: content_type)
+        end
+
+        state.success
+      rescue => e
+        failed_for_exception(e, event)
+        return
+      end
+
+      event
+    end
+
+    def generate_auth_header
+      now = Time.now.to_i.to_s
+      fields = {
+        'sentry_version' => PROTOCOL_VERSION,
+        'sentry_client' => USER_AGENT,
+        'sentry_timestamp' => now,
+        'sentry_key' => @dsn.public_key
+      }
+      fields['sentry_secret'] = @dsn.secret_key if @dsn.secret_key
+      'Sentry ' + fields.map { |key, value| "#{key}=#{value}" }.join(', ')
+    end
+
+    def encode(event_hash)
+      event_id = event_hash[:event_id] || event_hash['event_id']
+
+      envelope = <<~ENVELOPE
+        {"event_id":"#{event_id}","dsn":"#{configuration.dsn.to_s}","sdk":#{Sentry.sdk_meta.to_json},"sent_at":"#{DateTime.now.rfc3339}"}
+        {"type":"event","content_type":"application/json"}
+        #{event_hash.to_json}
+      ENVELOPE
+
+      [CONTENT_TYPE, envelope]
+    end
+
+    private
+
+    def prepare_encoded_event(event)
+      # Convert to hash
+      event_hash = event.to_hash
+
+      unless @state.should_try?
+        failed_for_previous_failure(event_hash)
+        return
+      end
+
+      event_id = event_hash[:event_id] || event_hash['event_id']
+      configuration.logger.info(LOGGER_PROGNAME) { "Sending event #{event_id} to Sentry" }
+      encode(event_hash)
+    end
+
+    def failed_for_exception(e, event)
+      @state.failure
+      configuration.logger.warn(LOGGER_PROGNAME) { "Unable to record event with remote Sentry server (#{e.class} - #{e.message}):\n#{e.backtrace[0..10].join("\n")}" }
+      log_not_sending(event)
+    end
+
+    def failed_for_previous_failure(event)
+      configuration.logger.warn(LOGGER_PROGNAME) { "Not sending event due to previous failure(s)." }
+      log_not_sending(event)
+    end
+
+    def log_not_sending(event)
+      configuration.logger.warn(LOGGER_PROGNAME) { "Failed to submit event: #{Event.get_log_message(event.to_hash)}" }
+    end
+  end
+end
+
+require "sentry/transport/dummy_transport"
+require "sentry/transport/http_transport"

data/lib/sentry/transport/configuration.rb

@@ -0,0 +1,28 @@
+module Sentry
+  class Transport
+    class Configuration
+      attr_accessor :timeout, :open_timeout, :proxy, :ssl, :ssl_ca_file, :ssl_verification, :encoding, :http_adapter, :faraday_builder, :transport_class
+
+      def initialize
+        @ssl_verification = true
+        @open_timeout = 1
+        @timeout = 2
+        @encoding = 'gzip'
+      end
+
+      def encoding=(encoding)
+        raise(Error, 'Unsupported encoding') unless %w(gzip json).include? encoding
+
+        @encoding = encoding
+      end
+
+      def transport_class=(klass)
+        unless klass.is_a?(Class)
+          raise Sentry::Error.new("config.transport.transport_class must a class. got: #{klass.class}")
+        end
+
+        @transport_class = klass
+      end
+    end
+  end
+end

data/lib/sentry/transport/dummy_transport.rb

@@ -0,0 +1,14 @@
+module Sentry
+  class DummyTransport < Transport
+    attr_accessor :events
+
+    def initialize(*)
+      super
+      @events = []
+    end
+
+    def send_event(event)
+      @events << event
+    end
+  end
+end

data/lib/sentry/transport/http_transport.rb

@@ -0,0 +1,62 @@
+require 'faraday'
+
+module Sentry
+  class HTTPTransport < Transport
+    attr_reader :conn, :adapter
+
+    def initialize(*args)
+      super
+      @adapter = @transport_configuration.http_adapter || Faraday.default_adapter
+      @conn = set_conn
+      @endpoint = @dsn.envelope_endpoint
+    end
+
+    def send_data(data, options = {})
+      unless configuration.sending_allowed?
+        logger.debug(LOGGER_PROGNAME) { "Event not sent: #{configuration.error_messages}" }
+      end
+
+      conn.post @endpoint do |req|
+        req.headers['Content-Type'] = options[:content_type]
+        req.headers['X-Sentry-Auth'] = generate_auth_header
+        req.body = data
+      end
+    rescue Faraday::Error => e
+      error_info = e.message
+      if e.response && e.response[:headers]['x-sentry-error']
+        error_info += " Error in headers is: #{e.response[:headers]['x-sentry-error']}"
+      end
+      raise Sentry::Error, error_info
+    end
+
+    private
+
+    def set_conn
+      server = @dsn.server
+
+      configuration.logger.debug(LOGGER_PROGNAME) { "Sentry HTTP Transport connecting to #{server}" }
+
+      Faraday.new(server, :ssl => ssl_configuration, :proxy => @transport_configuration.proxy) do |builder|
+        @transport_configuration.faraday_builder&.call(builder)
+        builder.response :raise_error
+        builder.options.merge! faraday_opts
+        builder.headers[:user_agent] = "sentry-ruby/#{Sentry::VERSION}"
+        builder.adapter(*adapter)
+      end
+    end
+
+    # TODO: deprecate and replace where possible w/Faraday Builder
+    def faraday_opts
+      [:timeout, :open_timeout].each_with_object({}) do |opt, memo|
+        memo[opt] = @transport_configuration.public_send(opt) if @transport_configuration.public_send(opt)
+      end
+    end
+
+    def ssl_configuration
+      (@transport_configuration.ssl || {}).merge(
+        :verify => @transport_configuration.ssl_verification,
+        :ca_file => @transport_configuration.ssl_ca_file
+      )
+    end
+  end
+end

data/lib/sentry/transport/state.rb

@@ -0,0 +1,40 @@
+module Sentry
+  class Transport
+    class State
+      def initialize
+        reset
+      end
+
+      def should_try?
+        return true if @status == :online
+
+        interval = @retry_after || [@retry_number, 6].min**2
+        return true if Time.now - @last_check >= interval
+
+        false
+      end
+
+      def failure(retry_after = nil)
+        @status = :error
+        @retry_number += 1
+        @last_check = Time.now
+        @retry_after = retry_after
+      end
+
+      def success
+        reset
+      end
+
+      def reset
+        @status = :online
+        @retry_number = 0
+        @last_check = nil
+        @retry_after = nil
+      end
+
+      def failed?
+        @status == :error
+      end
+    end
+  end
+end