opbeat 2.0.0 → 3.0.0

data/lib/opbeat/util.rb

@@ -0,0 +1,26 @@
+module Opbeat
+  # @api private
+  module Util
+    def self.nearest_minute
+      now = Time.now.utc
+      now - now.to_i % 60
+    end
+
+    def self.nanos
+      now = Time.now.utc
+      now.to_i * 1_000_000_000 + now.usec * 1_000
+    end
+  end
+
+  require 'opbeat/util/inspector'
+end
+
+# TODO: Maybe move this some place more explicit as we're extending
+# a pretty widely used class. Or maybe don't extend at all.
+if RUBY_VERSION.to_i <= 1
+  class Struct
+    def to_h
+      Hash[self.each_pair.to_a]
+    end
+  end
+end

data/lib/opbeat/util/constantize.rb

@@ -0,0 +1,54 @@
+module Opbeat
+  module Util
+    # From https://github.com/rails/rails/blob/861b70e92f4a1fc0e465ffcf2ee62680519c8f6f/activesupport/lib/active_support/inflector/methods.rb#L249
+    #
+    # Tries to find a constant with the name specified in the argument string.
+    #
+    #   'Module'.constantize     # => Module
+    #   'Test::Unit'.constantize # => Test::Unit
+    #
+    # The name is assumed to be the one of a top-level constant, no matter
+    # whether it starts with "::" or not. No lexical context is taken into
+    # account:
+    #
+    #   C = 'outside'
+    #   module M
+    #     C = 'inside'
+    #     C               # => 'inside'
+    #     'C'.constantize # => 'outside', same as ::C
+    #   end
+    #
+    # NameError is raised when the name is not in CamelCase or the constant is
+    # unknown.
+    def self.constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
+
+      # Trigger a built-in NameError exception including the ill-formed constant in the message.
+      Object.const_get(camel_cased_word) if names.empty?
+
+      # Remove the first blank element in case of '::ClassName' notation.
+      names.shift if names.size > 1 && names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant == Object
+          constant.const_get(name)
+        else
+          candidate = constant.const_get(name)
+          next candidate if constant.const_defined?(name, false)
+          next candidate unless Object.const_defined?(name)
+
+          # Go down the ancestors to check if it is owned directly. The check
+          # stops when we reach Object or the end of ancestors tree.
+          constant = constant.ancestors.inject do |const, ancestor|
+            break const    if ancestor == Object
+            break ancestor if ancestor.const_defined?(name, false)
+            const
+          end
+
+          # owner is in Object, so raise
+          constant.const_get(name, false)
+        end
+      end
+    end
+  end
+end

data/lib/opbeat/util/inspector.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+module Opbeat
+  module Util
+    class Inspector
+
+      DEFAULTS = {
+        width: 120
+      }.freeze
+
+      NEWLINE = "\n".freeze
+      SPACE = " ".freeze
+
+      def initialize config = {}
+        @config = DEFAULTS.merge(config)
+      end
+
+      def ms nanos
+        nanos.to_f / 1_000_000
+      end
+
+      def transaction transaction, opts = {}
+        w = @config[:width].to_f
+        f = w / ms(transaction.duration)
+
+        traces = transaction.traces
+
+        traces = traces.reduce([]) do |state, trace|
+          descriptions = [
+            "#{trace.signature} - #{trace.kind}",
+            "transaction:#{trace.transaction.endpoint}"
+          ]
+
+          if opts[:include_parents]
+            descriptions << "parents:#{trace.parents.map(&:signature).join(',')}"
+          end
+
+          descriptions << "duration:#{ms trace.duration}ms - rel:#{ms trace.relative_start}ms"
+
+          start_diff = ms(trace.start_time) - ms(transaction.start_time)
+          indent = (start_diff.floor * f).to_i
+
+          longest_desc_length = descriptions.map(&:length).max
+          desc_indent = [[indent, w - longest_desc_length].min, 0].max
+
+          lines = descriptions.map do |desc|
+            "#{SPACE * desc_indent}#{desc}"
+          end
+
+          if trace.duration
+            span = (ms(trace.duration) * f).ceil.to_i
+            lines << "#{SPACE * indent}+#{"-" * [(span - 2), 0].max}+"
+          else
+            lines << "#{SPACE * indent}UNFINISHED"
+          end
+
+          state << lines.join("\n")
+          state
+        end.join("\n")
+
+        <<-STR.gsub(/^\s{8}/, '')
+        \n#{"=" * (w.to_i)}
+        #{transaction.endpoint} - kind:#{transaction.kind} - #{transaction.duration.to_f / 1_000_000}ms
+        +#{"-" * (w.to_i - 2)}+
+        #{traces}
+        STR
+      rescue => e
+        puts e
+        puts e.backtrace.join("\n")
+        transaction.inspect
+      end
+
+    end
+  end
+end

data/lib/opbeat/version.rb

@@ -1,3 +1,3 @@
 module Opbeat
-  VERSION = "2.0.0"
+  VERSION = "3.0.0"
 end

data/lib/opbeat/worker.rb

@@ -0,0 +1,55 @@
+module Opbeat
+  # @api private
+  class Worker
+    include Logging
+
+    class PostRequest < Struct.new(:path, :data)
+      # require all parameters
+      def initialize path, data
+        super(path, data)
+      end
+    end
+
+    class StopMessage; end
+
+    def initialize config, queue, http_client
+      @config = config
+      @queue = queue
+      @http_client = http_client
+    end
+
+    attr_reader :config
+
+    def run
+      loop do
+        while action = @queue.pop
+          case action
+          when PostRequest
+            process_request action
+          when StopMessage
+            Thread.exit
+          else
+            raise Error.new("Unknown entity in worker queue: #{action.inspect}")
+          end
+        end
+      end
+    end
+
+    private
+
+    def process_request req
+      unless config.validate!
+        info "Invalid config - Skipping posting to Opbeat"
+        return
+      end
+
+      begin
+        @http_client.post(req.path, req.data)
+      rescue => e
+        fatal "Failed POST: #{e.inspect}"
+        debug e.backtrace.join("\n")
+      end
+    end
+
+  end
+end

data/opbeat.gemspec

@@ -1,28 +1,20 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$:.unshift(lib) unless $:.include?(lib)
 require 'opbeat/version'
 
 Gem::Specification.new do |gem|
   gem.name             = "opbeat"
   gem.version          = Opbeat::VERSION
-  gem.authors          = ["Thomas Watson Steen", "Ron Cohen", "Noah Kantrowitz"]
+  gem.authors          = ["Mikkel Malmberg"]
   gem.email            = "support@opbeat.com"
-  gem.summary          = "The official Opbeat Ruby client"
-  gem.homepage         = "https://github.com/opbeat/opbeat_ruby"
-  gem.license          = "Apache-2.0"
+  gem.summary          = "The official Opbeat Ruby client library"
+  gem.homepage         = "https://github.com/opbeat/opbeat-ruby"
+  gem.license          = "BSD-3-Clause"
 
   gem.files            = `git ls-files -z`.split("\x0")
   gem.require_paths    = ["lib"]
   gem.extra_rdoc_files = ["README.md", "LICENSE"]
 
-  gem.add_dependency "faraday", [">= 0.7.6", "< 0.10"]
-  gem.add_dependency "multi_json", "~> 1.0"
-
-  gem.add_development_dependency "bundler", "~> 1.7"
-  gem.add_development_dependency "rake", "~> 10.0"
-  gem.add_development_dependency "rspec", ">= 2.14"
-  gem.add_development_dependency "simplecov"
-  gem.add_development_dependency "delayed_job"
-  gem.add_development_dependency "sidekiq", "~> 2.17.0"
+  gem.add_dependency('activesupport', '>= 3.0.0')
 end

data/spec/opbeat/client_spec.rb

@@ -1,35 +1,222 @@
-require File::expand_path('../../spec_helper', __FILE__)
-require 'opbeat'
-require 'faraday'
+require 'spec_helper'
 
-http = Faraday.new do |builder|
-  builder.adapter :test do |stub|
-    stub.get('/') { |env| [ 200, {}, 'foo' ]}
-  end
-end
+module Opbeat
+  RSpec.describe Client do
 
-describe Opbeat::Client do
-  before do
-    @configuration = Opbeat::Configuration.new
-    @configuration.environments = ["test"]
-    @configuration.current_environment = :test
-    @configuration.secret_token = 'test'
-    @configuration.organization_id = 'test'
-    @configuration.app_id = 'test'
-    @client = Opbeat::Client.new(@configuration)
-    allow(@client).to receive(:send)
-  end
+    let(:config) { Configuration.new app_id: 'x', organization_id: 'y', secret_token: 'z' }
 
-  it 'send_release should send' do
-    message = "Test message"
-    expect(@client).to receive(:send).with("/releases/", message)
-    @client.send_release(message)
-  end
+    describe ".start!" do
+      it "set's up an instance and only one" do
+        first_instance = Client.start! config
+        expect(Client.inst).to_not be_nil
+        expect(Client.start! config).to be first_instance
+      end
+    end
+
+    describe ".stop!" do
+      it "kills the instance but flushes before" do
+        Client.start! config
+        Client.inst.submit_transaction Transaction.new(Client.inst, 'Test').done(200)
+        Client.stop!
+        expect(WebMock).to have_requested(:post, %r{/transactions/$})
+        expect(Client.inst).to be_nil
+      end
+    end
+
+    context "without worker spec setting", start_without_worker: true do
+      it "doesn't start a Worker" do
+        expect(Thread).to_not receive(:new)
+        Client.start! config
+        expect(Client.inst).to_not be_nil
+      end
+    end
+
+    context "with a running client", start_without_worker: true do
+      subject { Client.inst }
+
+      describe "#transaction" do
+        it "returns a new transaction and sets it as current" do
+          transaction = subject.transaction 'Test'
+          expect(transaction).to_not be_nil
+          expect(subject.current_transaction).to be transaction
+        end
+        it "returns the current transaction if present" do
+          transaction = subject.transaction 'Test'
+          expect(subject.transaction 'Test').to eq transaction
+        end
+        context "with a block" do
+          it "yields transaction" do
+            blck = lambda { |*args| }
+            allow(blck).to receive(:call)
+            subject.transaction('Test') { |t| blck.(t) }
+            expect(blck).to have_received(:call).with(Transaction)
+          end
+          it "returns transaction" do
+            result = subject.transaction('Test') { "DON'T RETURN ME" }
+            expect(result).to be_a Transaction
+          end
+        end
+      end
+
+      describe "#trace" do
+        it "delegates to current transaction" do
+          subject.current_transaction = double('transaction', trace: true)
+          subject.trace 1, 2, 3
+          expect(subject.current_transaction).to have_received(:trace).with(1, 2, 3)
+          subject.current_transaction = nil
+        end
+
+        it "ignores when outside transaction" do
+          blk = Proc.new {}
+          allow(blk).to receive(:call)
+          subject.trace { blk.call }
+          expect(blk).to have_received(:call)
+        end
+      end
+
+      describe "#submit_transaction" do
+        it "doesn't send right away" do
+          transaction = Transaction.new(subject, 'test')
+
+          subject.submit_transaction transaction
+
+          expect(subject.queue.length).to be 0
+          expect(WebMock).to_not have_requested(:post, %r{/transactions/$})
+        end
+
+        it "sends if it's long enough ago that we sent last" do
+          transaction = Transaction.new(subject, 'test')
+          subject.instance_variable_set :@last_sent_transactions, Time.now.utc - 61
+
+          subject.submit_transaction transaction
+
+          expect(subject.queue.length).to be 1
+          expect(subject.queue.pop).to be_a Worker::PostRequest
+        end
+
+        it "sends if interval is disabled" do
+          transaction = Transaction.new(subject, 'test')
+          subject.config.transaction_post_interval = nil
+          subject.submit_transaction transaction
+          expect(subject.queue.length).to be 1
+        end
+      end
+
+      describe "#report" do
+        it "builds and posts an exception" do
+          exception = Exception.new('BOOM')
+
+          subject.report exception
+
+          expect(subject.queue.length).to be 1
+          expect(subject.queue.pop).to be_a Worker::PostRequest
+        end
+
+        it "skips nil exceptions" do
+          subject.report nil
+          expect(WebMock).to_not have_requested(:post, %r{/errors/$})
+        end
+      end
+
+      describe "#report_message" do
+        it "builds and posts an exception" do
+          subject.report_message "Massage message"
+
+          expect(subject.queue.length).to be 1
+          expect(subject.queue.pop).to be_a Worker::PostRequest
+        end
+      end
+
+      describe "#capture" do
+        it "captures exceptions and sends them off then raises them again" do
+          exception = Exception.new("BOOM")
+
+          expect do
+            subject.capture do
+              raise exception
+            end
+          end.to raise_exception(Exception)
+
+          expect(subject.queue.length).to be 1
+          expect(subject.queue.pop).to be_a Worker::PostRequest
+        end
+      end
+
+      describe "#release" do
+        it "notifies Opbeat of a release" do
+          release = { rev: "abc123", status: 'completed' }
+
+          subject.release release
+
+          expect(subject.queue.length).to be 1
+          expect(subject.queue.pop).to be_a Worker::PostRequest
+        end
+
+        it "may send inline" do
+          release = { rev: "abc123", status: 'completed' }
+
+          subject.release release, inline: true
+
+          expect(WebMock).to have_requested(:post, %r{/releases/$}).with(body: release)
+        end
+      end
+    end
+
+    context "with performance disabled" do
+      subject do
+        Opbeat::Client.inst
+      end
+
+      before do
+        config.disable_performance = true
+        Opbeat.start! config
+      end
+      after { Opbeat.stop! }
+
+      describe "#transaction" do
+        it "yields" do
+          block = lambda { }
+          expect(block).to receive(:call)
+          Client.inst.transaction('Test') { block.call }
+        end
+        it "returns nil" do
+          expect(Client.inst.transaction 'Test').to be_nil
+        end
+      end
+
+      describe "#trace" do
+        it "yields" do
+          block = lambda { }
+          expect(block).to receive(:call)
+          Client.inst.trace('Test', 'trace') { block.call }
+        end
+        it "returns nil" do
+          expect(Client.inst.trace 'Test', 'test').to be_nil
+        end
+      end
+    end
+
+    context "with errors disabled" do
+      subject do
+        Opbeat::Client.inst
+      end
+
+      before do
+        config.disable_errors = true
+        Opbeat.start! config
+      end
+      after { Opbeat.stop! }
+
+      describe "#report" do
+        it "doesn't do anything" do
+          exception = Exception.new('BOOM')
+
+          Client.inst.report exception
+
+          expect(Client.inst.queue.length).to be 0
+        end
+      end
+    end
 
-  it 'send_message should send' do
-    event = Opbeat::Event.new :message => "my message"
-    req = http.get '/'
-    expect(@client).to receive(:send).with("/errors/", event).and_return(req)
-    @client.send_event(event)
   end
 end