opbeat 2.0.0 → 3.0.0

data/lib/opbeat/configuration.rb

@@ -1,90 +1,77 @@
+require 'logger'
+
 module Opbeat
   class Configuration
+    DEFAULTS = {
+      server: "https://intake.opbeat.com".freeze,
+      logger: Logger.new(nil),
+      context_lines: 3,
+      enabled_environments: %w{production},
+      excluded_exceptions: [],
+      filter_parameters: [/(authorization|password|passwd|secret)/i],
+      timeout: 100,
+      open_timeout: 100,
+      backoff_multiplier: 2,
+      use_ssl: true,
+      current_user_method: :current_user,
+      environment: ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'default',
+      transaction_post_interval: 60,
+
+      disable_performance: false,
+      disable_errors: false,
+
+      debug_traces: false,
+
+      # for tests
+      disable_worker: false
+    }.freeze
 
-    # Base URL of the Opbeat server
-    attr_accessor :server
-
-    # Secret access token for authentication with Opbeat
     attr_accessor :secret_token
-
-    # Organization ID to use with Opbeat
     attr_accessor :organization_id
-
-    # App ID to use with Opbeat
     attr_accessor :app_id
 
-    # Logger to use internally
+    attr_accessor :server
     attr_accessor :logger
-
-    # Number of lines of code context to capture, or nil for none
     attr_accessor :context_lines
-
-    # Whitelist of environments that will send notifications to Opbeat
-    attr_accessor :environments
-
-    # Which exceptions should never be sent
+    attr_accessor :enabled_environments
     attr_accessor :excluded_exceptions
-
-    # An array of parameters whould should be filtered from the log
     attr_accessor :filter_parameters
-
-    # Timeout when waiting for the server to return data in seconds
     attr_accessor :timeout
-
-    # Timout when opening connection to the server
     attr_accessor :open_timeout
-
-    # Backoff multipler
     attr_accessor :backoff_multiplier
+    attr_accessor :use_ssl
+    attr_accessor :current_user_method
+    attr_accessor :environment
+    attr_accessor :transaction_post_interval
 
-    # Should the SSL certificate of the server be verified?
-    attr_accessor :ssl_verification
+    attr_accessor :disable_performance
+    attr_accessor :disable_errors
 
-    attr_reader :current_environment
+    attr_accessor :debug_traces
 
-    attr_accessor :user_controller_method
+    attr_accessor :disable_worker
 
-    # Optional Proc to be used to send events asynchronously
-    attr_reader :async
+    attr_accessor :view_paths
 
-    def initialize
-      self.server = ENV['OPBEAT_SERVER'] || "https://intake.opbeat.com"
-      self.secret_token = ENV['OPBEAT_SECRET_TOKEN'] if ENV['OPBEAT_SECRET_TOKEN']
-      self.organization_id = ENV['OPBEAT_ORGANIZATION_ID'] if ENV['OPBEAT_ORGANIZATION_ID']
-      self.app_id = ENV['OPBEAT_APP_ID'] if ENV['OPBEAT_APP_ID']
-      @context_lines = 3
-      self.environments = %w[ development production default ]
-      self.current_environment = (defined?(::Rails) && ::Rails.env) || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'default'
-      self.excluded_exceptions = []
-      self.timeout = 1
-      self.open_timeout = 1
-      self.backoff_multiplier = 2
-      self.ssl_verification = true
-      self.user_controller_method = 'current_user'
-      self.async = false
-    end
+    def initialize opts = {}
+      DEFAULTS.merge(opts).each do |k, v|
+        self.send("#{k}=", v)
+      end
 
-    # Allows config options to be read like a hash
-    #
-    # @param [Symbol] option Key for a given attribute
-    def [](option)
-      send(option)
+      if block_given?
+        yield self
+      end
     end
 
-    def current_environment=(environment)
-      @current_environment = environment.to_s
-    end
+    def validate!
+      %w{app_id secret_token organization_id}.each do |key|
+        raise Error.new("Configuration missing `#{key}'") unless self.send(key)
+      end
 
-    def send_in_current_environment?
-      environments.include? current_environment
+      true
+    rescue Error => e
+      logger.error e.message
+      false
     end
-
-    def async=(value)
-      raise ArgumentError.new("async must be callable (or false to disable)") unless (value == false || value.respond_to?(:call))
-      @async = value
-    end
-
-    alias_method :async?, :async
-
   end
 end

data/lib/opbeat/data_builders.rb

@@ -0,0 +1,16 @@
+module Opbeat
+  # @api private
+  module DataBuilders
+    class DataBuilder
+      def initialize config
+        @config = config
+      end
+
+      attr_reader :config
+    end
+
+    %w{transactions error}.each do |f|
+      require "opbeat/data_builders/#{f}"
+    end
+  end
+end

data/lib/opbeat/data_builders/error.rb

@@ -0,0 +1,27 @@
+require 'opbeat/filter'
+
+module Opbeat
+  module DataBuilders
+    class Error < DataBuilder
+      def build error_message
+        h = {
+          message: error_message.message,
+          timestamp: error_message.timestamp,
+          level: error_message.level,
+          logger: error_message.logger,
+          culprit: error_message.culprit,
+          machine: error_message.machine,
+          extra: error_message.extra,
+          param_message: error_message.param_message
+        }
+
+        h[:exception] = error_message.exception.to_h if error_message.exception
+        h[:stacktrace] = error_message.stacktrace.to_h if error_message.stacktrace
+        h[:http] = error_message.http.to_h if error_message.http
+        h[:user] = error_message.user.to_h if error_message.user
+
+        h
+      end
+    end
+  end
+end

data/lib/opbeat/data_builders/transactions.rb

@@ -0,0 +1,85 @@
+module Opbeat
+  module DataBuilders
+    class Transactions < DataBuilder
+      def build transactions
+        reduced = transactions.reduce({ transactions: {}, traces: {} }) do |data, transaction|
+          key = [transaction.endpoint, transaction.result, transaction.timestamp]
+
+          if data[:transactions][key].nil?
+            data[:transactions][key] = build_transaction(transaction)
+          else
+            data[:transactions][key][:durations] << ms(transaction.duration)
+          end
+
+          combine_traces transaction.traces, data[:traces]
+
+          data
+        end.reduce({}) do |data, kv|
+          key, collection = kv
+          data[key] = collection.values
+          data
+        end
+
+        reduced[:traces].each do |trace|
+          # traces' start time is average across collected
+          trace[:start_time] = trace[:start_time].reduce(0, :+) / trace[:start_time].length
+        end
+
+        # preserve root
+        root = reduced[:traces].shift
+        # re-add root
+        reduced[:traces].unshift root
+
+        reduced
+      end
+
+      private
+
+      def combine_traces traces, into
+        traces.each do |trace|
+          key = [trace.transaction.endpoint, trace.signature, trace.timestamp]
+
+          if into[key].nil?
+            into[key] = build_trace(trace)
+          else
+            into[key][:durations] << [
+              ms(trace.duration),
+              ms(trace.transaction.duration)
+            ]
+            into[key][:start_time] << ms(trace.relative_start)
+          end
+        end
+      end
+
+      def build_transaction transaction
+        {
+          transaction: transaction.endpoint,
+          result: transaction.result,
+          kind: transaction.kind,
+          timestamp: transaction.timestamp,
+          durations: [ms(transaction.duration)]
+        }
+      end
+
+      def build_trace trace
+        {
+          transaction: trace.transaction.endpoint,
+          signature: trace.signature,
+          durations: [[
+            ms(trace.duration),
+            ms(trace.transaction.duration)
+          ]],
+          start_time: [ms(trace.relative_start)],
+          kind: trace.kind,
+          timestamp: trace.timestamp,
+          parents: trace.parents && trace.parents.map(&:signature) || [],
+          extra: trace.extra
+        }
+      end
+
+      def ms nanos
+        nanos.to_f / 1_000_000
+      end
+    end
+  end
+end

data/lib/opbeat/error.rb

@@ -1,6 +1,5 @@
 module Opbeat
-
+  # @api private
   class Error < StandardError
   end
-
 end

data/lib/opbeat/error_message.rb

@@ -0,0 +1,71 @@
+require 'opbeat/line_cache'
+require 'opbeat/error_message/exception'
+require 'opbeat/error_message/stacktrace'
+require 'opbeat/error_message/http'
+require 'opbeat/error_message/user'
+
+module Opbeat
+  class ErrorMessage
+    extend Logging
+
+    DEFAULTS = {
+      level: :error,
+      logger: 'root'.freeze
+    }.freeze
+
+    def initialize config, message, attrs = {}
+      @config = config
+
+      @message = message
+      @timestamp = Time.now.utc.to_i
+      DEFAULTS.merge(attrs).each do |k,v|
+        send(:"#{k}=", v)
+      end
+      @filter = Filter.new config
+
+      yield self if block_given?
+    end
+
+    attr_reader :config
+    attr_accessor :message
+    attr_reader :timestamp
+    attr_accessor :level
+    attr_accessor :logger
+    attr_accessor :culprit
+    attr_accessor :machine
+    attr_accessor :extra
+    attr_accessor :param_message
+    attr_accessor :exception
+    attr_accessor :stacktrace
+    attr_accessor :http
+    attr_accessor :user
+
+    def self.from_exception config, exception, opts = {}
+      message = "#{exception.class}: #{exception.message}"
+
+      if config.excluded_exceptions.include? exception.class.to_s
+        info "Skipping excluded exception #{exception.class}"
+        return nil
+      end
+
+      error_message = new(config, message) do |msg|
+        msg.level = :error
+        msg.exception = Exception.from(exception)
+        msg.stacktrace = Stacktrace.from(config, exception)
+      end
+
+      if frames = error_message.stacktrace && error_message.stacktrace.frames
+        if first_frame = frames[0]
+          error_message.culprit = "#{first_frame.filename}:#{first_frame.lineno}:in `#{first_frame.function}'"
+        end
+      end
+
+      if env = opts[:rack_env]
+        error_message.http = HTTP.from_rack_env env, filter: @filter
+        error_message.user = User.from_rack_env config, env
+      end
+
+      error_message
+    end
+  end
+end

data/lib/opbeat/error_message/exception.rb

@@ -0,0 +1,12 @@
+module Opbeat
+  class ErrorMessage
+    class Exception < Struct.new(:type, :value, :module)
+      SPLIT = '::'.freeze
+
+      def self.from exception
+        new exception.class.to_s, exception.message,
+          exception.class.to_s.split(SPLIT)[0...-1].join(SPLIT)
+      end
+    end
+  end
+end

data/lib/opbeat/error_message/http.rb

@@ -0,0 +1,62 @@
+module Opbeat
+  class ErrorMessage
+    class HTTP < Struct.new(:url, :method, :data, :query_string, :cookies,
+                            :headers, :remote_host, :http_host, :user_agent,
+                            :secure, :env)
+
+      HTTP_ENV_KEY = /^HTTP_/.freeze
+      UNDERSCORE = "_".freeze
+      DASH = "-".freeze
+      QUESTION = "?".freeze
+
+      def self.from_rack_env env, opts = {}
+        req = Rack::Request.new env
+
+        http = new(
+          req.url.split(QUESTION).first,               # url
+          req.request_method,                          # method
+          nil,                                         # data
+          req.query_string,                            # query string
+          env['HTTP_COOKIE'],                          # cookies
+          {},                                          # headers
+          req.ip,                                      # remote host
+          req.host_with_port,                          # http host
+          req.user_agent,                              # user agent
+          req.scheme == 'https'.freeze ? true : false, # secure
+          {}                                           # env
+        )
+
+        env.each do |k, v|
+          next unless k.upcase == k # lower case stuff isn't relevant
+
+          if k.match(HTTP_ENV_KEY)
+            header = k.gsub(HTTP_ENV_KEY, '')
+              .split(UNDERSCORE).map(&:capitalize).join(DASH)
+            http.headers[header] = v.to_s
+          else
+            http.env[k] = v.to_s
+          end
+        end
+
+        if req.form_data?
+          http.data = req.POST
+        elsif req.body
+          http.data = req.body.read
+          req.body.rewind
+        end
+
+        if filter = opts[:filter]
+          http.apply_filter filter
+        end
+
+        http
+      end
+
+      def apply_filter filter
+        self.data = filter.apply data
+        self.query_string = filter.apply query_string
+        self.cookies = filter.apply cookies
+      end
+    end
+  end
+end

data/lib/opbeat/error_message/stacktrace.rb

@@ -0,0 +1,75 @@
+module Opbeat
+  class ErrorMessage
+    class Stacktrace
+
+      def initialize config, frames
+        @config, @frames = config, frames
+      end
+
+      attr_reader :frames
+
+      def self.from config, exception
+        return unless exception.backtrace
+
+        new(config, exception.backtrace.map do |line|
+          Frame.from_line config, line
+        end)
+      end
+
+      def to_h
+        { frames: frames.map(&:to_h) }
+      end
+
+      private
+
+      class Frame < Struct.new(:filename, :lineno, :abs_path, :function, :vars,
+                               :pre_context, :context_line, :post_context)
+
+        BACKTRACE_REGEX = /^(.+?):(\d+)(?::in `(.+?)')?$/.freeze
+
+        class << self
+          def from_line config, line
+            _, abs_path, lineno, function = line.match(BACKTRACE_REGEX).to_a
+            lineno = lineno.to_i
+            filename = strip_load_path(abs_path)
+
+            if lines = config.context_lines
+              pre_context, context_line, post_context =
+                get_contextlines(abs_path, lineno, lines)
+            end
+
+            new filename, lineno, abs_path, function, nil,
+              pre_context, context_line, post_context
+          end
+
+          private
+
+          def strip_load_path path
+            prefix = $:
+              .map(&:to_s)
+              .select { |s| path.start_with?(s) }
+              .sort_by { |s| s.length }
+              .last
+
+            return path unless prefix
+
+            path[prefix.chomp(File::SEPARATOR).length + 1..-1]
+          end
+
+          def get_contextlines path, line, context
+            lines = (2 * context + 1).times.map do |i|
+              LineCache.find(path, line - context + i)
+            end
+
+            pre =  lines[0..(context-1)]
+            line = lines[context]
+            post = lines[(context+1)..-1]
+
+            [pre, line, post]
+          end
+        end
+      end
+
+    end
+  end
+end