opbeat 2.0.0 → 3.0.0

data/lib/opbeat/error_message/user.rb

@@ -0,0 +1,23 @@
+module Opbeat
+  class ErrorMessage
+    class User < Struct.new(:is_authenticated, :id, :username, :email)
+      CONTROLLER_KEY = 'action_controller.instance'.freeze
+
+      def self.from_rack_env config, env
+        controller = env[CONTROLLER_KEY]
+        method = config.current_user_method.to_sym
+
+        return unless controller && controller.respond_to?(method)
+
+        user = controller.send method
+
+        new(
+          true,
+          user.respond_to?(:id) ? user.id : nil,
+          user.respond_to?(:username) ? user.username : nil,
+          user.respond_to?(:email) ? user.email : nil
+        )
+      end
+    end
+  end
+end

data/lib/opbeat/filter.rb

@@ -1,63 +1,73 @@
 module Opbeat
+  # @api private
   class Filter
-    MASK = '[FILTERED]'
-    DEFAULT_FILTER = [/(authorization|password|passwd|secret)/i]
 
-    def initialize(filters=nil)
-      if defined?(::Rails)
-        rails_filters = ::Rails.application.config.filter_parameters
-        rails_filters = nil if rails_filters.count == 0
-      end
-      @filters = filters || rails_filters || DEFAULT_FILTER
+    MASK = '[FILTERED]'.freeze
+
+    def initialize config
+      @config = config
+      @params = rails_filters || config.filter_parameters
     end
 
-    def apply(value, key=nil, &block)
-      if value.is_a?(Hash)
-        value.each.inject({}) do |memo, (k, v)|
-          memo[k] = apply(v, k, &block)
-          memo
-        end
-      elsif value.is_a?(Array)
-        value.map do |value|
-          apply(value, key, &block)
-        end
-      else
-        block.call(key, value)
+    attr_reader :config
+
+    def apply data, opts = {}
+      case data
+      when String
+        apply_to_string data, opts = {}
+      when Hash
+        apply_to_hash data
       end
     end
 
-    def sanitize(key, value)
-      if !value.is_a?(String) || value.empty?
-        value
-      elsif @filters.any? { |filter| filter.is_a?(Regexp) ? filter.match(key) : filter.to_s == key.to_s }
-        MASK
-      else
-        value
-      end
+    def apply_to_string str, opts = {}
+      sep = opts[:separator] || '&'.freeze
+      kv_sep = opts[:kv_separator] || '='.freeze
+
+      str.split(sep).map do |kv|
+        key, value = kv.split(kv_sep)
+        [key, kv_sep, sanitize(key, value)].join
+      end.join(sep)
     end
 
-    def process_event_hash(data)
-      return data unless data.has_key? 'http'
-      if data['http'].has_key? 'data'
-        data['http']['data'] = process_hash(data['http']['data'])
+    def apply_to_hash hsh
+      hsh.inject({}) do |filtered, kv|
+        key, value = kv
+        filtered[key] = sanitize(key, value)
+        filtered
       end
-      if data['http'].has_key? 'query_string'
-        data['http']['query_string'] = process_string(data['http']['query_string'], '&')
-      end
-      if data['http'].has_key? 'cookies'
-        data['http']['cookies'] = process_string(data['http']['cookies'], ';')
+    end
+
+    def sanitize key, value
+      return value unless value.is_a?(String)
+
+      if should_filter?(key)
+        return MASK
       end
-      data
+
+      value
     end
 
-    def process_hash(data)
-      apply(data) do |key, value|
-        sanitize(key, value)
+    private
+
+    def should_filter? key
+      @params.any? do |param|
+        case param
+        when String
+          key.to_s == param.to_s
+        when Regexp
+          param.match(key)
+        end
       end
     end
 
-    def process_string(str, separator='&')
-      str.split(separator).map { |s| s.split('=') }.map { |a| a[0]+'='+sanitize(a[0], a[1]) }.join(separator)
+    def rails_filters
+      if defined?(::Rails) && Rails.application
+        if filters = ::Rails.application.config.filter_parameters
+          filters.any? ? filters : nil
+        end
+      end
     end
+
   end
 end

data/lib/opbeat/http_client.rb

@@ -0,0 +1,141 @@
+require 'uri'
+require 'net/http'
+require 'json'
+
+module Opbeat
+  # @api private
+  class HttpClient
+    include Logging
+
+    USER_AGENT = "opbeat-ruby/#{Opbeat::VERSION}".freeze
+
+    attr_reader :state
+    attr_reader :adapter
+
+    def initialize(config)
+      @config = config
+      @adapter = HTTPAdapter.new(config)
+      @state = ClientState.new config
+    end
+
+    attr_reader :config
+
+    def post(resource, body)
+      path = abs_path(resource)
+      debug "POST #{resource}"
+
+      unless state.should_try?
+        info "Temporarily skipping sending to Opbeat due to previous failure."
+        return
+      end
+
+      if body.is_a?(Hash) || body.is_a?(Array)
+        body = JSON.dump(body)
+      end
+
+      request = adapter.post path do |req|
+        req['Authorization'] = auth_header
+        req['Content-Type'] = 'application/json'.freeze
+        req['Content-Length'] = body.bytesize.to_s
+        req['User-Agent'] = USER_AGENT
+        req.body = body
+      end
+
+      begin
+        response = adapter.perform_request request
+        unless response.code.to_i.between?(200, 299)
+          raise Error.new("Error from Opbeat server (#{response.code}): #{response.body}")
+        end
+      rescue
+        debug { JSON.parse(body).inspect }
+        @state.fail!
+        raise
+      end
+
+      @state.success!
+
+      response
+    end
+
+    private
+
+    def auth_header
+      "Bearer #{@config.secret_token}"
+    end
+
+    def abs_path path
+      "/api/v1/organizations/#{@config.organization_id}" +
+        "/apps/#{@config.app_id}#{path}"
+    end
+
+    def encode(event)
+      event_hash = @filter.process_event_hash(event.to_hash)
+      event_hash.to_json
+    end
+
+    class HTTPAdapter
+      def initialize conf
+        @config = conf
+      end
+
+      def post path
+        req = Net::HTTP::Post.new path
+        yield req if block_given?
+        req
+      end
+
+      def perform_request req
+        http.start do |http|
+          http.request req
+        end
+      end
+
+      private
+
+      def http
+        return @http if @http
+
+        http = Net::HTTP.new server_uri.host, server_uri.port
+        http.use_ssl = @config.use_ssl
+        http.read_timeout = @config.timeout
+        http.open_timeout = @config.open_timeout
+
+        @http = http
+      end
+
+      def server_uri
+        @uri ||= URI(@config.server)
+      end
+    end
+
+    class ClientState
+      def initialize(config)
+        @config = config
+        @retry_number = 0
+        @last_check = Time.now.utc
+      end
+
+      def should_try?
+        return true if @status == :online
+
+        interval = ([@retry_number, 6].min() ** 2) * @config.backoff_multiplier
+        return true if Time.now.utc - @last_check > interval
+
+        false
+      end
+
+      def fail!
+        @status = :error
+        @retry_number += 1
+        @last_check = Time.now.utc
+      end
+
+      def success!
+        @status = :online
+        @retry_number = 0
+        @last_check = nil
+      end
+    end
+  end
+
+end

data/lib/opbeat/injections.rb

@@ -0,0 +1,83 @@
+require 'opbeat/util/constantize'
+
+module Opbeat
+  # @api private
+  module Injections
+    class Registration
+      def initialize const_name, require_paths, injector
+        @const_name = const_name
+        @require_paths = Array(require_paths)
+        @injector = injector
+      end
+
+      attr_reader :const_name, :require_paths, :injector
+
+      def install
+        injector.install
+      end
+    end
+
+    def self.require_hooks
+      @require_hooks ||= {}
+    end
+
+    def self.installed
+      @installed ||= {}
+    end
+
+    def self.register(*args)
+      registration = Registration.new(*args)
+
+      if const_defined?(registration.const_name)
+        installed[registration.const_name] = registration
+        registration.install
+      else
+        register_require_hook registration
+      end
+    end
+
+    def self.register_require_hook registration
+      registration.require_paths.each do |p|
+        require_hooks[p] = registration
+      end
+    end
+
+    def self.hook_into name
+      return unless registration = lookup(name)
+
+      if const_defined?(registration.const_name)
+        installed[registration.const_name] = registration
+        registration.install
+
+        registration.require_paths.each do |p|
+          require_hooks.delete p
+        end
+      end
+    end
+
+    def self.lookup require_path
+      require_hooks[require_path]
+    end
+
+    def self.const_defined? const_name
+      const = Util.constantize(const_name) rescue nil
+      !!const
+    end
+  end
+end
+
+# @api private
+module ::Kernel
+  alias require_without_op require
+
+  def require name
+    res = require_without_op name
+
+    begin
+      Opbeat::Injections.hook_into name
+    rescue Exception
+    end
+
+    res
+  end
+end

data/lib/opbeat/injections/json.rb

@@ -0,0 +1,19 @@
+module Opbeat
+  module Injections
+    module JSON
+      class Injector
+        def install
+          ::JSON.class_eval do
+            include TraceHelpers
+
+            trace_class_method :parse, 'JSON#parse', 'json.parse'
+            trace_class_method :parse!, 'JSON#parse!', 'json.parse'
+            trace_class_method :generate, 'JSON#generate', 'json.generate'
+          end
+        end
+      end
+    end
+
+    register 'JSON', 'json', JSON::Injector.new
+  end
+end

data/lib/opbeat/injections/net_http.rb

@@ -0,0 +1,43 @@
+module Opbeat
+  module Injections
+    module NetHTTP
+      class Injector
+        def install
+          Net::HTTP.class_eval do
+            alias request_without_opb request
+
+            def request req, body = nil, &block
+              unless Opbeat.started?
+                return request_without_opb req, body, &block
+              end
+
+              host, port = req['host'] && req['host'].split(':')
+              method = req.method
+              path = req.path
+              scheme = use_ssl? ? 'https' : 'http'
+
+              # inside a session
+              host ||= self.address
+              port ||= self.port
+
+              extra = {
+                scheme: scheme,
+                port: port,
+                path: path
+              }
+
+              signature = "#{method} #{host}".freeze
+              kind = "ext.net_http.#{method}".freeze
+
+              Opbeat.trace signature, kind, extra do
+                request_without_opb(req, body, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    register 'Net::HTTP', 'net/http', NetHTTP::Injector.new
+  end
+end

data/lib/opbeat/injections/redis.rb

@@ -0,0 +1,23 @@
+module Opbeat
+  module Injections
+    module Redis
+      class Injector
+        def install
+          ::Redis::Client.class_eval do
+            alias call_without_opbeat call
+
+            def call(command, &block)
+              signature = command[0]
+
+              Opbeat.trace signature.to_s, 'cache.redis'.freeze do
+                call_without_opbeat(command, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    register 'Redis', 'redis', Redis::Injector.new
+  end
+end