opbeat 2.0.0 → 3.0.0

data/lib/opbeat/normalizers.rb

@@ -0,0 +1,65 @@
+module Opbeat
+  # @api private
+  module Normalizers
+
+    class Normalizer
+      def self.register name
+        Normalizers.register name, self
+      end
+
+      def initialize config
+        @config = config
+      end
+
+      attr_reader :config
+    end
+
+    class Default < Normalizer
+      def normalize transaction, name, payload
+        :skip
+      end
+    end
+
+    DEFAULT = Default.new nil
+
+    def self.register name, cls
+      (@registered ||= {})[name] = cls
+    end
+
+    def self.build config
+      normalizers = @registered.reduce({}) do |coll, kv|
+        name, cls = kv
+        coll[name] = cls.new config
+        coll
+      end
+
+      Container.new(normalizers)
+    end
+
+    class Container
+      def initialize normalizers
+        @normalizers = normalizers
+      end
+
+      def keys
+        @normalizers.keys
+      end
+
+      def normalizer_for name
+        @normalizers[name] || DEFAULT
+      end
+
+      def normalize transaction, name, payload
+        normalizer_for(name).normalize transaction, name, payload
+      end
+    end
+
+    %w{
+      action_controller
+      active_record
+      action_view
+    }.each do |f|
+      require "opbeat/normalizers/#{f}"
+    end
+  end
+end

data/lib/opbeat/normalizers/action_controller.rb

@@ -0,0 +1,21 @@
+module Opbeat
+  module Normalizers
+    module ActionController
+      class ProcessAction < Normalizer
+        register 'process_action.action_controller'
+        KIND = 'app.controller.action'.freeze
+
+        def normalize transaction, name, payload
+          transaction.endpoint = endpoint(payload)
+          [transaction.endpoint, KIND, nil]
+        end
+
+        private
+
+        def endpoint payload
+          "#{payload[:controller]}##{payload[:action]}"
+        end
+      end
+    end
+  end
+end

data/lib/opbeat/normalizers/action_view.rb

@@ -0,0 +1,71 @@
+module Opbeat
+  module Normalizers
+    module ActionView
+
+      class RenderNormalizer < Normalizer
+        def normalize_render payload, kind
+          signature = path_for(payload[:identifier])
+
+          [signature, kind, nil]
+        end
+
+        private
+
+        def path_for identifier
+          return "Unknown template".freeze unless path = identifier
+          return path unless path.start_with?("/")
+
+          path && relative_path(path)
+        end
+
+        def relative_path path
+          root = config.view_paths.find { |p| path.start_with? p }
+          type = :app
+
+          unless root
+            root = Gem.path.find { |p| path.start_with? p }
+            type = :gem
+          end
+
+          return "Absolute path".freeze unless root
+
+          start = root.length
+          start += 1 if path[root.length] == "/".freeze
+
+          if type == :gem
+            "$GEM_PATH/#{path[start, path.length]}"
+          else
+            path[start, path.length]
+          end
+        end
+      end
+
+      class RenderTemplate < RenderNormalizer
+        register 'render_template.action_view'
+        KIND = 'template.view'.freeze
+
+        def normalize transaction, name, payload
+          normalize_render(payload, KIND)
+        end
+      end
+
+      class RenderPartial < RenderNormalizer
+        register 'render_partial.action_view'
+        KIND = 'template.view.partial'.freeze
+
+        def normalize transaction, name, payload
+          normalize_render(payload, KIND)
+        end
+      end
+
+      class RenderCollection < RenderNormalizer
+        register 'render_collection.action_view'
+        KIND = 'template.view.collection'.freeze
+
+        def normalize transaction, name, payload
+          normalize_render(payload, KIND)
+        end
+      end
+    end
+  end
+end

data/lib/opbeat/normalizers/active_record.rb

@@ -0,0 +1,41 @@
+require 'opbeat/sql_summarizer'
+
+module Opbeat
+  module Normalizers
+    module ActiveRecord
+      class SQL < Normalizer
+        register 'sql.active_record'
+
+        def initialize *args
+          super(*args)
+          adapter = ::ActiveRecord::Base.connection.adapter_name.downcase rescue nil
+          @kind = "db.#{adapter || 'unknown'}.sql".freeze
+          @sql_parser = SqlSummarizer.new config
+        end
+
+        def normalize transaction, name, payload
+          if %w{SCHEMA CACHE}.include? payload[:name]
+            return :skip
+          end
+
+          signature =
+            signature_for(payload[:sql]) || # SELECT FROM "users"
+            payload[:name] ||               # Users load
+            "SQL".freeze
+
+          if signature == 'SELECT FROM "schema_migrations"'
+            return :skip
+          end
+
+          [signature, @kind, { sql: payload[:sql] }]
+        end
+
+        private
+
+        def signature_for sql
+          @sql_parser.signature_for(sql)
+        end
+      end
+    end
+  end
+end

data/lib/opbeat/sql_summarizer.rb

@@ -0,0 +1,27 @@
+module Opbeat
+  # @api private
+  class SqlSummarizer
+    CACHE = {}
+    TBL = "[^ ]+".freeze
+    REGEXES = {
+      /^SELECT .* FROM (#{TBL})/i => "SELECT FROM ".freeze,
+      /^INSERT INTO (#{TBL})/i => "INSERT INTO ".freeze,
+      /^UPDATE (#{TBL})/i => "UPDATE ".freeze,
+      /^DELETE FROM (#{TBL})/i => "DELETE FROM ".freeze
+    }.freeze
+
+    def initialize config
+      @config = config
+    end
+
+    def signature_for sql
+      return CACHE[sql] if CACHE[sql]
+
+      REGEXES.find do |regex, sig|
+        if match = sql.match(regex)
+          break sig + match[1]
+        end
+      end
+    end
+  end
+end

data/lib/opbeat/subscriber.rb

@@ -0,0 +1,80 @@
+require 'active_support/notifications'
+require 'opbeat/normalizers'
+
+module Opbeat
+  # @api private
+  class Subscriber
+    include Logging
+
+    def initialize config, client
+      @config = config
+      @client = client
+      @normalizers = Normalizers.build config
+    end
+
+    attr_reader :config
+
+    def register!
+      unregister! if @subscription
+      @subscription = ActiveSupport::Notifications.subscribe actions_regex, self
+    end
+
+    def unregister!
+      ActiveSupport::Notifications.unsubscribe @subscription
+      @subscription = nil
+    end
+
+    # AS::Notifications API
+
+    class Notification
+      def initialize id, trace
+        @id = id
+        @trace = trace
+      end
+      attr_reader :id, :trace
+    end
+
+    def start name, id, payload
+      return unless transaction = @client.current_transaction
+
+      normalized = @normalizers.normalize(transaction, name, payload)
+
+      trace = nil
+
+      unless normalized == :skip
+        sig, kind, extra = normalized
+
+        trace = Trace.new(transaction, sig, kind, transaction.running_traces, extra)
+        offset = transaction.current_offset
+
+        transaction.traces << trace
+
+        trace.start offset
+      end
+
+      transaction.notifications << Notification.new(id, trace)
+    end
+
+    def finish name, id, payload
+      return unless transaction = @client.current_transaction
+
+      while notification = transaction.notifications.pop
+        if notification.id == id
+          if trace = notification.trace
+            trace.done
+          end
+          return
+        end
+      end
+    end
+
+    private
+
+    def actions_regex
+      @actions_regex ||= Regexp.new(
+        "(".freeze + @normalizers.keys.join("|".freeze) + ")".freeze
+      )
+    end
+
+  end
+end

data/lib/opbeat/tasks.rb

@@ -1,24 +1,26 @@
-# Capistrano tasks for notifying Opbeat of deploys
 namespace :opbeat do
-  desc "Notify Opbeat of a new deploy."
-  task :deployment do
-    if defined?(::Rails.root)
-      initializer_file = ::Rails.root.join('config', 'initializers','opbeat.rb')
-
-      if initializer_file.exist?
-        load initializer_file
-      else
-        Rake::Task[:environment].invoke
-      end
+  desc "Notify Opbeat of a release"
+  task :release => :environment do
+    unless rev = ENV["REV"]
+      puts "Please specify a revision in an env variable\n" +
+        "eg. REV=abc123 rake opbeat:release"
+      exit 1
     end
-    rev = ENV['REV']
 
-    unless rev
-      puts "No revision given. Set environment variable REV."
-    else
-      data = {'rev' => ENV['REV'], 'branch' => ENV['BRANCH'], 'status' => 'completed'}
-      Opbeat::client.send_release(data)
+    # empty env means dev
+    ENV["RAILS_ENV"] ||= 'development'
+
+    # log to STDOUT
+    Opbeat::Client.inst.config.logger = Logger.new STDOUT
+
+    unless Opbeat.release({
+        rev: rev,
+        branch: ENV['BRANCH'],
+        status: 'completed'
+    }, inline: true)
+      exit 1 # release returned nil
     end
   end
-end
 
+  task :deployment => :release
+end

data/lib/opbeat/trace.rb

@@ -0,0 +1,47 @@
+require 'opbeat/util'
+
+module Opbeat
+  class Trace
+
+    DEFAULT_KIND = 'code.custom'.freeze
+
+    def initialize transaction, signature, kind = nil, parents = [], extra = nil
+      @transaction = transaction
+      @signature = signature
+      @kind = kind || DEFAULT_KIND
+      @parents = parents || []
+      @extra = extra
+
+      @timestamp = Util.nearest_minute.to_i
+    end
+
+    attr_accessor :signature, :kind, :parents, :extra
+    attr_reader :transaction, :timestamp, :duration, :relative_start, :start_time
+
+    def start relative_to
+      @start_time = Util.nanos
+      @relative_start = start_time - relative_to
+
+      self
+    end
+
+    def done ms = Util.nanos
+      @duration = ms - start_time
+
+      self
+    end
+
+    def done?
+      !!duration
+    end
+
+    def running?
+      !done?
+    end
+
+    def inspect
+      info = %w{signature kind parents extra timestamp duration relative_start}
+      "<Trace #{info.map { |m| "#{m}:#{send(m).inspect}" }.join(' ')}>"
+    end
+  end
+end

data/lib/opbeat/trace_helpers.rb

@@ -0,0 +1,29 @@
+module Opbeat
+  module TraceHelpers
+    module ClassMethods
+      def trace_class_method method, signature, kind
+        __trace_method_on(singleton_class, method, signature, kind)
+      end
+
+      private
+
+      def __trace_method_on(klass, method, signature, kind)
+        klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          alias :"__without_opb_#{method}" :"#{method}"
+
+          def #{method}(*args, &block)
+            Opbeat.trace "#{signature}", "#{kind}" do
+              __without_opb_#{method}(*args, &block)
+            end
+          end
+        RUBY
+      end
+    end
+
+    def self.included(kls)
+      kls.class_eval do
+        extend ClassMethods
+      end
+    end
+  end
+end

data/lib/opbeat/transaction.rb

@@ -0,0 +1,99 @@
+require 'opbeat/util'
+
+module Opbeat
+  class Transaction
+
+    ROOT_TRACE_NAME = 'transaction'.freeze
+
+    def initialize client, endpoint, kind = 'code.custom', result = nil
+      @client = client
+      @endpoint = endpoint
+      @kind = kind
+      @result = result
+
+      @timestamp = Util.nearest_minute.to_i
+
+      @root_trace = Trace.new(self, ROOT_TRACE_NAME, ROOT_TRACE_NAME)
+      @traces = [@root_trace]
+      @notifications = []
+
+      @start_time = Util.nanos
+      @root_trace.start @start_time
+    end
+
+    attr_accessor :endpoint, :kind, :result, :duration
+    attr_reader :timestamp, :start_time, :traces, :notifications, :root_trace
+
+    def release
+      @client.current_transaction = nil
+    end
+
+    def done result = nil
+      @result = result
+
+      @root_trace.done Util.nanos
+      @duration = @root_trace.duration
+
+      self
+    end
+
+    def done?
+      @root_trace.done?
+    end
+
+    def submit result = nil
+      done result
+
+      release
+
+      @client.submit_transaction self
+
+      self
+    end
+
+    def trace signature, kind = nil, extra = nil, &block
+      trace = Trace.new(self, signature, kind, running_traces, extra)
+
+      rel_time = current_offset
+
+      traces << trace
+
+      trace.start rel_time
+
+      return trace unless block_given?
+
+      begin
+        result = yield trace
+      ensure
+        trace.done
+      end
+
+      result
+    end
+
+    def running_traces
+      traces.select(&:running?)
+    end
+
+    def current_trace
+      traces.reverse.find(&:running?)
+    end
+
+    def current_offset
+      if curr = current_trace
+        return curr.start_time
+      end
+
+      start_time
+    end
+
+    def inspect
+      info = %w{endpoint kind result duration timestamp start_time}
+      <<-TEXT
+<Transaction #{info.map { |m| "#{m}:#{send(m).inspect}" }.join(' ')}>
+  #{traces.map(&:inspect).join("\n  ")}"
+      TEXT
+    end
+
+  end
+end