binnacle 0.4.8

data/lib/binnacle/logging/request_log_subscriber.rb

@@ -0,0 +1,120 @@
+require 'json'
+require 'action_pack'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/log_subscriber'
+
+module Binnacle
+  module Logging
+    class RequestLogSubscriber < ActiveSupport::LogSubscriber
+      def process_action(event)
+        return if Binnacle.configuration.ignore?(event)
+        payload = event.payload
+        data = extract_request(event, payload)
+        Binnacle.client.log_rails_event(data)
+      end
+
+      def redirect_to(event)
+        Thread.current[:binnacle_location] = event.payload[:location]
+      end
+
+      # TODO: Implement send_file and send_data
+      # def send_file(event)
+      #   info { "Sent data #{event.payload[:filename]} (#{event.duration.round(1)}ms)" }
+      # end
+      #
+      # def send_data(event)
+      #   info { "Sent data #{event.payload[:filename]} (#{event.duration.round(1)}ms)" }
+      # end
+
+      def unpermitted_parameters(event)
+        Thread.current[:binnacle_unpermitted_params] ||= []
+        Thread.current[:binnacle_unpermitted_params].concat(event.payload[:keys])
+      end
+
+      private
+
+      def extract_request(event, payload)
+        payload = event.payload
+        data = initial_data(payload)
+        data.merge!(extract_status(payload))
+        data.merge!(extract_runtimes(event, payload))
+        data.merge!(extract_location)
+        data.merge!(extract_unpermitted_params)
+        data.merge!(extract_event_details(event))
+        data.merge!({message: "#{data[:method]} #{data[:path]} AS #{data[:format]} (view: #{data[:view]}ms, db: #{data[:db]}ms)"})
+      end
+
+      def initial_data(payload)
+        path = extract_path(payload)
+        method = payload[:method]
+        format = extract_format(payload)
+        {
+          direction: :in,
+          method: method,
+          path: path,
+          format: format,
+          controller: payload[:params]['controller'],
+          action: payload[:params]['action'],
+          params: payload[:params],
+        }
+      end
+
+      def extract_path(payload)
+        path = payload[:path]
+        index = path.index('?')
+        index ? path[0, index] : path
+      end
+
+      def extract_event_details(event)
+        {
+          time: event.time,
+          transaction_id: event.transaction_id
+        }
+      end
+
+      def extract_format(payload)
+        (::ActionPack::VERSION::MAJOR == 3 && ::ActionPack::VERSION::MINOR == 0) ? payload[:formats].first : payload[:format]
+      end
+
+      def extract_status(payload)
+        if (status = payload[:status])
+          { status: status.to_i }
+        elsif (error = payload[:exception])
+          exception, message = error
+          { status: get_error_status_code(exception), error: "#{exception}: #{message}" }
+        else
+          { status: 0 }
+        end
+      end
+
+      def get_error_status_code(exception)
+        status = ActionDispatch::ExceptionWrapper.rescue_responses[exception]
+        Rack::Utils.status_code(status)
+      end
+
+      def extract_runtimes(event, payload)
+        data = { duration: event.duration.to_f.round(2) }
+        data[:view] = payload[:view_runtime].to_f.round(2) if payload.key?(:view_runtime)
+        data[:db] = payload[:db_runtime].to_f.round(2) if payload.key?(:db_runtime)
+        data
+      end
+
+      def extract_location
+        location = Thread.current[:binnacle_location]
+        return {} unless location
+
+        Thread.current[:binnacle_location] = nil
+        { location: location }
+      end
+
+      def extract_unpermitted_params
+        unpermitted_params = Thread.current[:binnacle_unpermitted_params]
+        return {} unless unpermitted_params
+
+        Thread.current[:binnacle_unpermitted_params] = nil
+        { unpermitted_params: unpermitted_params }
+      end
+
+    end
+  end
+end

data/lib/binnacle/resource.rb

@@ -0,0 +1,54 @@
+require 'json'
+
+module Binnacle
+  class Resource
+    attr_reader :route
+    attr_writer :connection
+
+    def post_asynch
+      Thread.new do
+        response = response_from_post(@connection, self.route, self.to_json)
+
+        if response.status == 401
+          Binnacle.binnacle_logger.error("Error communicating with Binnacle: #{response.body}")
+        end
+      end
+    end
+
+    def post
+      response = response_from_post(@connection, self.route, self.to_json)
+
+      if response.status == 401
+        Binnacle.binnacle_logger.error("Error communicating with Binnacle: #{response.body}")
+      else
+        JSON.parse(response.body)
+      end
+    end
+
+    def self.get(connection, path, query_params)
+      response = connection.get do |req|
+        req.url path
+        req.headers['Content-Type'] = 'application/json'
+        query_params.each do |n,v|
+          req.params[n] = v if v
+        end
+      end
+
+      if response.status == 401
+        Binnacle.binnacle_logger.error("Error communicating with Binnacle: #{response.body}")
+      else
+        JSON.parse(response.body).map { |r| self.from_hash(r) }
+      end
+    end
+
+    protected
+
+    def response_from_post(connection, route, body)
+      connection.post do |req|
+        req.url route
+        req.headers['Content-Type'] = 'application/json'
+        req.body = body
+      end
+    end
+  end
+end

data/lib/binnacle/resources/event.rb

@@ -0,0 +1,100 @@
+module Binnacle
+  class Event < Resource
+
+    attr_accessor :channel_id
+    attr_accessor :event_name
+    attr_accessor :client_id
+    attr_accessor :session_id
+    attr_accessor :client_event_time
+    attr_accessor :ip_address
+    attr_accessor :log_level
+    attr_accessor :tags
+    attr_accessor :json
+    attr_accessor :event_time
+
+    def configure(channel_id, event_name, client_id, session_id, log_level, ts = Time.now, tags = [], json = {})
+      self.channel_id = channel_id
+      self.event_name = event_name
+      self.client_id = client_id
+      self.session_id = session_id
+      self.timestamp = ts ? ts : Time.now
+      self.log_level = log_level
+      self.tags = tags
+      self.json = json
+    end
+
+    def configure_from_logging_progname(progname, channel_id, client_id, session_id, log_level, ts = Time.now, tags = [], json = {})
+      if progname.is_a?(Hash)
+        self.client_id = progname[:client_id] || client_id
+        self.session_id = progname[:session_id] || session_id
+        self.channel_id = progname[:channel_id] || channel_id
+        self.event_name =  progname[:event_name]
+        self.tags = progname[:tags] || tags
+        self.json = json
+        self.json.merge!(progname[:json]) if progname[:json]
+      elsif progname.is_a?(String)
+        self.client_id = client_id
+        self.session_id = session_id
+        self.channel_id = channel_id
+        self.event_name = progname
+        self.tags = tags
+        self.json = json
+      end
+
+      self.timestamp = ts ? ts : Time.now
+      self.log_level = log_level
+    end
+
+    def timestamp=(ts)
+      self.client_event_time = ts.strftime("%Y-%m-%dT%H:%M:%S%z")
+    end
+
+    def self.from_hash(h)
+      event = self.new()
+      event.channel_id = h['channelId']
+      event.event_name = h['eventName']
+      event.client_id = h['clientId']
+      event.session_id = h['sessionId']
+      event.ip_address = h['ipAddress']
+      event.log_level = h['logLevel']
+      event.event_time = Time.at(h['eventTime']/1000)
+      event.tags = h['tags']
+      event.json = h['json']
+
+      event
+    end
+
+    def to_json
+      {
+        "channelId" => channel_id,
+        "sessionId" => session_id,
+        "clientEventTime" => client_event_time,
+        "eventName" => event_name,
+        "clientId" => client_id,
+        "logLevel" => log_level,
+        "tags" => tags,
+        "json" => json
+      }.to_json
+    end
+
+    def route
+      "/api/events/#{channel_id}"
+    end
+
+    def self.route(channel)
+      "/api/events/#{channel}"
+    end
+
+    def self.recents(connection, lines, since, channel)
+      path = [route(channel), 'recents'].compact.join('/')
+
+      get(connection, path, {'limit' => lines, 'since' => since})
+    end
+
+    def self.events(connection, channel, date, start_hour, end_hour, lines)
+      path = [route(channel), date].compact.join('/')
+
+      get(connection, path, {'start_hour' => start_hour, 'end_hour' => end_hour, 'limit' => lines})
+    end
+  end
+end

data/lib/binnacle/trap/backtrace.rb

@@ -0,0 +1,130 @@
+module Binnacle
+  module Trap
+    # Front end to parsing the backtrace for each notice
+    class Backtrace
+      # --------------------------------------------------------------
+      # Attribution:
+      # Copied from Airbrake Gem. https://github.com/airbrake/airbrake
+      # --------------------------------------------------------------
+
+      # Handles backtrace parsing line by line
+      class Line
+
+        GEM_PATHS = (Gem.path | [Gem.default_dir]).map { |p| Regexp.escape(p) }
+        GEMS_REGEXP = %r{(#{GEM_PATHS.join('|')})/gems/([^/]+)-([\w.]+)/(.*)}
+        GEMS_RESULT = '\2 (\3) \4'.freeze
+
+        # regexp (optionnally allowing leading X: for windows support)
+        INPUT_FORMAT = %r{^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$}.freeze
+
+        # The file portion of the line (such as app/models/user.rb)
+        attr_reader :file
+
+        # The line number portion of the line
+        attr_reader :number
+
+        # The method_name of the line (such as index)
+        attr_reader :method_name
+
+        # Parses a single line of a given backtrace
+        # @param [String] unparsed_line The raw line from +caller+ or some backtrace
+        # @return [Line] The parsed backtrace line
+        def self.parse(unparsed_line)
+          _, file, number, method_name = unparsed_line.match(INPUT_FORMAT).to_a
+
+          # Remove Rails root from log lines
+          file = defined?(Rails) ? file.gsub(Rails.root.to_s, '') : file
+
+          if file
+            # Clean those ERB lines, we don't need the internal autogenerated
+            # ERB method, what we do need (line number in ERB file) is already there
+            file = file.sub /(\.erb:\d+)\:in `__.*$/, "\\1"
+
+            # Remove RubyGems root directories
+            file = file.sub(GEMS_REGEXP, GEMS_RESULT)
+          end
+
+          new(file, number, method_name)
+        end
+
+        def initialize(file, number, method_name)
+          @file   = file
+          @number = number
+          @method_name = method_name
+        end
+
+        # Reconstructs the line in a readable fashion
+        def to_s
+          "#{file}:#{number}:in `#{method_name}'"
+        end
+
+        def ==(other)
+          to_s == other.to_s
+        end
+
+        def inspect
+          "<Line:#{to_s}>"
+        end
+
+        def empty?
+          file.nil? && number.nil? && method_name.nil?
+        end
+      end
+
+      # holder for an Array of Backtrace::Line instances
+      attr_reader :lines
+
+      def self.parse(ruby_backtrace, opts = {})
+        ruby_lines = split_multiline_backtrace(ruby_backtrace)
+
+        filters = opts[:filters] || []
+        filtered_lines = ruby_lines.to_a.map do |line|
+          filters.inject(line) do |l, proc|
+            proc.call(l)
+          end
+        end.compact
+
+        lines = filtered_lines.collect do |unparsed_line|
+          Line.parse(unparsed_line)
+        end
+
+        new(lines.delete_if(&:empty?))
+      end
+
+      def initialize(lines)
+        @lines = lines
+      end
+
+      def inspect
+        "<Backtrace: " + lines.collect { |line| line.inspect }.join(", ") + ">"
+      end
+
+      def to_s
+        content = []
+        lines.each do |line|
+          content << line
+        end
+        content.join("\n")
+      end
+
+      def ==(other)
+        if other.respond_to?(:lines)
+          lines == other.lines
+        else
+          false
+        end
+      end
+
+      private
+
+      def self.split_multiline_backtrace(backtrace)
+        backtrace = [backtrace] unless backtrace.respond_to?(:to_a)
+        if backtrace.to_a.size == 1
+          backtrace.to_a.first.split(/\n\s*/)
+        else
+          backtrace
+        end
+      end
+    end
+  end
+end

data/lib/binnacle/trap/exception_event.rb

@@ -0,0 +1,176 @@
+require_relative 'backtrace'
+require 'json'
+
+module Binnacle
+  module Trap
+    HTTP_HEADER_PREFIXES = [
+      'HTTP_'.freeze,
+      'CONTENT_TYPE'.freeze,
+      'CONTENT_LENGTH'.freeze
+    ].freeze
+
+    HTTP_HEADER_SKIPS = [
+      'HTTP_COOKIE'.freeze,
+      'HTTP_X_CSRF_TOKEN'.freeze
+    ]
+
+    class ExceptionEvent < ::Binnacle::Event
+      attr_reader :exception
+      attr_reader :env
+      attr_reader :request
+      attr_reader :component
+      attr_reader :method
+      attr_reader :module
+      attr_reader :backtrace
+
+      def initialize(exception, env)
+        @exception = unwrap_exception(exception)
+        @env = env
+
+        if env["action_dispatch.request.parameters"] != nil
+          @component = env['action_dispatch.request.parameters'][:controller] || nil
+          @method = env['action_dispatch.request.parameters'][:action] || nil
+          @module = env['action_dispatch.request.parameters'][:module] || nil
+        end
+
+        @request = ::Rack::Request.new(env)
+
+        extract_event_name
+        extract_session_id
+        extract_client_id
+        extract_backtrace
+
+        self.log_level = "EXCEPTION"
+        self.tags = []
+        build_json_payload
+
+        configure(
+          Binnacle.configuration.error_channel,
+          self.event_name,
+          self.client_id,
+          self.session_id,
+          self.log_level,
+          nil,
+          self.tags,
+          self.json
+        )
+      end
+
+      private
+
+      def unwrap_exception(exception)
+        if exception.respond_to?(:original_exception)
+          exception.original_exception
+        elsif exception.respond_to?(:continued_exception)
+          exception.continued_exception
+        end || exception
+      end
+
+      # The root Exception class name
+      def extract_event_name
+        self.event_name = @exception.class.to_s
+      end
+
+      # The affected User or some identifier that can be used to determine
+      # who was affected by the exception (Warden, Devise, etc. should be used
+      # if available to get this information)
+      def extract_session_id
+        self.session_id = (@env["rack.session"] ? @env["rack.session"]["session_id"] : nil) || @request.ip
+      end
+
+      def extract_backtrace
+        backtrace = Backtrace.parse(@exception.backtrace)
+        @backtrace = backtrace.lines.map do |line|
+          { number: line.number, file: line.file, method: line.method_name }
+        end
+      end
+
+      def extract_headers
+        http_headers = {}
+
+        http_headers = @env.map.with_object({}) do |(key, value), headers|
+          if Binnacle::Trap::HTTP_HEADER_PREFIXES.any? { |prefix| key.to_s.start_with?(prefix) } && !HTTP_HEADER_SKIPS.include?(key.to_s)
+            headers[key] = value
+          end
+
+          headers
+        end
+
+        http_headers
+      end
+
+      def extract_framework
+        defined?(Rails) ? "Rails" : "unknown"
+      end
+
+      def extract_framework_version
+        defined?(Rails) ? Rails::VERSION::STRING : "unknown"
+      end
+
+      def extract_framework_params
+        {}
+      end
+
+      def extract_ruby_version
+        "#{RUBY_VERSION rescue '?.?.?'} p#{RUBY_PATCHLEVEL rescue '???'} #{RUBY_RELEASE_DATE rescue '????-??-??'} #{RUBY_PLATFORM rescue '????'}"
+      end
+
+      def extract_hostname
+        require 'socket' unless defined?(Socket)
+        Socket.gethostname
+      rescue
+        'UNKNOWN'
+      end
+
+      def extract_rails_environment_level
+        defined?(Rails) ? Rails.env : "UNKNOWN"
+      end
+
+      def extract_libraries_loaded
+        libraries = {}
+        begin
+          libraries = Hash[*Gem.loaded_specs.map{|name, gem_specification| [name, gem_specification.version.to_s]}.flatten]
+        rescue
+        end
+
+        libraries
+      end
+
+      def extract_http_params
+        @request.params rescue {}
+      end
+
+      def extract_client_id
+        session = @env["rack.session"] ? @env["rack.session"].to_hash : {}
+        warden_info = session.find { |k,v| k.start_with?('warden.') }
+        if warden_info
+          self.client_id = warden_info.last.first.first
+        else
+          self.client_id = ""
+        end
+      end
+
+      def build_json_payload
+        self.json = {
+          path: @request.path,
+          exception: event_name,
+          message: @exception.message,
+          component: @component,
+          method: @method,
+          environment_level: extract_rails_environment_level,
+          hostname: extract_hostname,
+          user_agent: @request.user_agent,
+          ruby_version: extract_ruby_version,
+          framework: extract_framework,
+          framework_version: extract_framework_version,
+          framework_params: extract_framework_params,
+          http_params: extract_http_params,
+          headers: extract_headers,
+          dependencies: extract_libraries_loaded,
+          backtrace: @backtrace
+        }
+      end
+
+    end
+  end
+end