binnacle 0.4.8

data/spec/backtrace_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+describe Binnacle::Trap::Backtrace do
+  describe Binnacle::Trap::Backtrace::Line do
+
+    describe 'inspect' do
+      it 'returns a representation of the line' do
+        array = [
+          "app/models/user.rb:13:in `magic'"
+        ]
+        backtrace = Binnacle::Trap::Backtrace.parse(array)
+
+        expect(backtrace.lines.first.inspect).to eq(%[<Line:app/models/user.rb:13:in `magic'>])
+      end
+    end
+  end
+
+  describe 'inspect' do
+    it 'returns a representation of the backtrace`' do
+      array = [
+        "app/models/user.rb:13:in `magic'",
+        "app/controllers/users_controller.rb:8:in `index'"
+      ]
+
+      backtrace = Binnacle::Trap::Backtrace.parse(array)
+
+      expect(backtrace.inspect).to eq(%[<Backtrace: <Line:app/models/user.rb:13:in `magic'>, <Line:app/controllers/users_controller.rb:8:in `index'>>])
+    end
+  end
+
+  describe 'to_s' do
+    it 'returns a representation of the backtrace`' do
+      array = [
+        "app/models/user.rb:13:in `magic'",
+        "app/controllers/users_controller.rb:8:in `index'"
+      ]
+
+      backtrace = Binnacle::Trap::Backtrace.parse(array)
+
+      expect(backtrace.to_s).to eq(%[app/models/user.rb:13:in `magic'\napp/controllers/users_controller.rb:8:in `index'])
+    end
+  end
+
+  describe '==' do
+    it 'is true for equivalent backtraces' do
+      original_backtrace = Binnacle::Trap::Backtrace.parse(["one:1:in `one'"])
+      expected_backtrace = Binnacle::Trap::Backtrace.parse(["one:1:in `one'"])
+
+      expect(original_backtrace == expected_backtrace).to be true
+    end
+
+    it 'is false if one of the object does not respond to #lines' do
+      backtrace = Binnacle::Trap::Backtrace.parse(["one:1:in `one'"])
+      not_a_backtrace = 8675309
+
+      expect(backtrace == not_a_backtrace).to be false
+    end
+  end
+
+  describe 'parse' do
+
+    it "should parse a backtrace into lines" do
+      array = [
+        "app/models/user.rb:13:in `magic'",
+        "app/controllers/users_controller.rb:8:in `index'"
+      ]
+
+      backtrace = Binnacle::Trap::Backtrace.parse(array)
+
+      line = backtrace.lines.first
+      expect(line.number).to eq('13')
+      expect(line.file).to eq('app/models/user.rb')
+      expect(line.method_name).to eq('magic')
+
+      line = backtrace.lines.last
+      expect(line.number).to eq('8')
+      expect(line.file).to eq('app/controllers/users_controller.rb')
+      expect(line.method_name).to eq('index')
+    end
+
+    it "should parse a string backtrace" do
+      string = [
+        "app/models/user.rb:13:in `magic'",
+        "app/controllers/users_controller.rb:8:in `index'"
+      ].join("\n")
+
+      backtrace = Binnacle::Trap::Backtrace.parse(string)
+
+      line = backtrace.lines.first
+      expect(line.number).to eq('13')
+      expect(line.file).to eq('app/models/user.rb')
+      expect(line.method_name).to eq('magic')
+
+      line = backtrace.lines.last
+      expect(line.number).to eq('8')
+      expect(line.file).to eq('app/controllers/users_controller.rb')
+      expect(line.method_name).to eq('index')
+    end
+
+    it "should parse a windows backtrace into lines" do
+      array = [
+        "C:/Program Files/Server/app/models/user.rb:13:in `magic'",
+        "C:/Program Files/Server/app/controllers/users_controller.rb:8:in `index'"
+      ]
+
+      backtrace = Binnacle::Trap::Backtrace.parse(array)
+
+      line = backtrace.lines.first
+      expect(line.number).to eq('13')
+      expect(line.file).to eq('C:/Program Files/Server/app/models/user.rb')
+      expect(line.method_name).to eq('magic')
+
+      line = backtrace.lines.last
+      expect(line.number).to eq('8')
+      expect(line.file).to eq('C:/Program Files/Server/app/controllers/users_controller.rb')
+      expect(line.method_name).to eq('index')
+    end
+
+    it "should be equal with equal lines" do
+      one = ["app/models/user.rb:13:in `magic'",
+        "app/controllers/users_controller.rb:8:in `index'"]
+      two = one.dup
+
+      expect(Binnacle::Trap::Backtrace.parse(one)).to eq(Binnacle::Trap::Backtrace.parse(two))
+    end
+
+    it "should parse massive one-line exceptions into multiple lines" do
+      original_backtrace = Binnacle::Trap::Backtrace.parse(["one:1:in `one'\n   two:2:in `two'\n      three:3:in `three`"])
+      expected_backtrace = Binnacle::Trap::Backtrace.parse(["one:1:in `one'", "two:2:in `two'", "three:3:in `three`"])
+
+      expect(original_backtrace).to eq(expected_backtrace)
+    end
+
+    context "with a gem root" do
+      before do
+        @gem_root = '/root/to/gem'
+        Gem.path << @gem_root
+      end
+
+      it "should filter out the gem root" do
+        backtrace_with_gem_root = Binnacle::Trap::Backtrace.parse(
+          ["#{@gem_root}/some/gem.rb:9:in `test'",
+           "#{@gem_root}/path/to/awesome_gem.rb:13:in `awesome'",
+           "/test/something.rb:55:in `hack'"],
+          :filters => Binnacle::Configuration::DEFAULT_BACKTRACE_FILTERS)
+        backtrace_without_gem_root = Binnacle::Trap::Backtrace.parse(
+          ["[GEM_ROOT]/some/gem.rb:9:in `test'",
+           "[GEM_ROOT]/path/to/awesome_gem.rb:13:in `awesome'",
+           "/test/something.rb:55:in `hack'"])
+
+        expect(backtrace_with_gem_root).to eq(backtrace_without_gem_root)
+      end
+
+      it "should ignore empty gem paths" do
+        Gem.path << ""
+        backtrace_with_gem_root = Binnacle::Trap::Backtrace.parse(
+          ["#{@gem_root}/some/gem.rb:9:in `test'",
+           "/test/something.rb:55:in `hack'"],
+          :filters => Binnacle::Configuration::DEFAULT_BACKTRACE_FILTERS)
+        backtrace_without_gem_root = Binnacle::Trap::Backtrace.parse(
+          ["[GEM_ROOT]/some/gem.rb:9:in `test'",
+           "/test/something.rb:55:in `hack'"])
+
+        expect(backtrace_with_gem_root).to eq(backtrace_without_gem_root)
+      end
+    end
+
+    it "should remove notifier trace" do
+      inside_notifier = [
+        "app/models/user.rb:13:in `magic'",
+        "app/controllers/users_controller.rb:8:in `index'",
+        "lib/binnacle/somewhere.rb:20:in `foobar'"
+      ]
+      outside_notifier = [
+        "app/models/user.rb:13:in `magic'",
+        "app/controllers/users_controller.rb:8:in `index'"
+      ]
+
+      without_inside = Binnacle::Trap::Backtrace.parse(outside_notifier)
+      with_inside    = Binnacle::Trap::Backtrace.parse(inside_notifier,
+                         :filters => Binnacle::Configuration::DEFAULT_BACKTRACE_FILTERS
+                       )
+
+      expect(without_inside).to eq(with_inside)
+    end
+
+    it "should run filters on the backtrace" do
+      filters = [lambda { |line| line.sub('foo', 'bar') }]
+      input = Binnacle::Trap::Backtrace.parse(["foo:13:in `one'", "baz:14:in `two'"],
+                                               :filters => filters)
+      expected = Binnacle::Trap::Backtrace.parse(["bar:13:in `one'", "baz:14:in `two'"])
+
+      expect(expected).to eq(input)
+    end
+
+  end
+end

data/spec/binnacle_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Binnacle do
+  describe 'configure' do
+    before do
+      reset_env
+      Binnacle.binnacle_logger.pause
+    end
+
+    after { Binnacle.binnacle_logger.continue }
+
+    it 'creates a module-level instance of a binnacle client', :vcr do
+      Binnacle.configure do |config|
+        config.endpoint = 'localhost'
+        config.api_key = 'vceth4xcwqfoowpz2esi'
+        config.api_secret = '1grttyb8ozbe9axt88ji'
+        config.encrypted = false
+      end
+
+      expect(a_request(:get, 'http://localhost:8080/api/endpoints'))
+      expect(Binnacle.client).to_not be_nil
+    end
+
+    it 'can be configured via a hash of options', :vcr do
+      Binnacle.configure(endpoint: 'localhost',
+                         api_key: 'vceth4xcwqfoowpz2esi',
+                         api_secret: '1grttyb8ozbe9axt88ji')
+
+      expect(a_request(:get, 'http://localhost:8080/api/endpoints'))
+      expect(Binnacle.client).to_not be_nil
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Binnacle::Client do
+  before { reset_env }
+  let(:client) { Binnacle::Client.new('vceth4xcwqfoowpz2esi', '1grttyb8ozbe9axt88ji', 'localhost') }
+
+  describe 'signal' do
+    it 'invokes the events api signal', :vcr do
+      client.signal('icoc0tnol3obe8pas207', 'TEST_EVT', 'binnacle-rb', 'My Sess', 'INFO')
+
+      expect(a_request(:get, 'http://localhost:8080/api/endpoints'))
+      expect(
+        a_request(:post, "http://localhost:8080/api/events/icoc0tnol3obe8pas207").
+        with(body: hash_including({
+          "channelId": "icoc0tnol3obe8pas207",
+          "sessionId": "My Sess",
+          "eventName": "TEST_EVT",
+          "clientId": "binnacle-rb",
+          "logLevel": "INFO",
+          "tags": [],
+          "json": {}
+          })
+        )
+      ).to(have_been_made.times(1))
+    end
+  end
+
+  describe '#ready?' do
+    before { Binnacle.binnacle_logger.pause }
+    after  { Binnacle.binnacle_logger.continue }
+
+    it 'returns true if a connection has been successfully established', :vcr do
+      Binnacle.configure do |config|
+        config.endpoint = 'localhost'
+        config.api_key = 'vceth4xcwqfoowpz2esi'
+        config.api_secret = '1grttyb8ozbe9axt88ji'
+      end
+
+      expect(Binnacle.client.ready?).to be true
+    end
+  end
+
+  describe 'signal_asynch' do
+    it 'invokes the events api signal', :vcr do
+      client.signal_asynch('icoc0tnol3obe8pas207', 'ASYNCH_TEST_EVT', 'binnacle-rb', 'My Sess', 'INFO')
+
+      expect(a_request(:get, 'http://localhost:8080/api/endpoints'))
+      wait_for(
+        a_request(:post, "http://localhost:8080/api/events/icoc0tnol3obe8pas207").
+        with(body: hash_including({
+          "channelId": "icoc0tnol3obe8pas207",
+          "sessionId": "My Sess",
+          "eventName": "ASYNCH_TEST_EVT",
+          "clientId": "binnacle-rb",
+          "logLevel": "INFO",
+          "tags": [],
+          "json": {}
+          })
+        )
+      ).to(have_been_made.times(1))
+    end
+  end
+
+  describe 'recents' do
+    before { @recents = client.recents(10, 500, 'icoc0tnol3obe8pas207') }
+
+    it 'invokes the events api recents', :vcr do
+      expect(a_request(:get, 'http://localhost:8080/api/endpoints'))
+      expect(
+        a_request(:get, "http://localhost:8080/api/events/icoc0tnol3obe8pas207/recents?limit=10&since=500")
+      ).to(have_been_made.times(1))
+    end
+
+    it 'returns a collection of event objects', :vcr do
+      expect(@recents).to have(10).events
+    end
+  end
+
+  describe 'events' do
+    before { @events = client.events('icoc0tnol3obe8pas207', '2015-12-29', 8, 9, 500) }
+
+    it 'invokes the events api', :vcr do
+      expect(a_request(:get, 'http://localhost:8080/api/endpoints'))
+      expect(
+        a_request(:get, "http://localhost:8080/api/events/icoc0tnol3obe8pas207/2015-12-29?end_hour=9&limit=500&start_hour=8")
+      ).to(have_been_made.times(1))
+    end
+
+    it 'returns a collection of event objects', :vcr do
+      expect(@events).to have(40).events
+      expect(@events).to all(satisfy { |e| e.event_time.strftime("%Y-%m-%d") == '2015-12-29' })
+    end
+
+  end
+
+  describe 'report_exception' do
+    before { Binnacle.binnacle_logger.pause }
+    after  { Binnacle.binnacle_logger.continue }
+
+    it 'invokes the events api signal', :vcr do
+
+      Binnacle.configure do |config|
+        config.error_channel = 'id0czm8eryfffcgp875c'
+        config.encrypted = false
+      end
+
+      exception = ZeroDivisionError.new
+      env = Rack::MockRequest.env_for(client.connection.active_url)
+      client.report_exception(exception, env, false)
+
+      expect(a_request(:get, 'http://localhost:8080/api/endpoints'))
+      expect(
+        a_request(:post, "http://localhost:8080/api/events/id0czm8eryfffcgp875c").
+        with(body: hash_including({
+          "channelId": "id0czm8eryfffcgp875c",
+          "eventName":"ZeroDivisionError",
+          "logLevel":"EXCEPTION"
+        }))
+      ).to(have_been_made.times(1))
+
+      # TODO: need a way to check nested partial hash in the body for:
+      # "json": hash_including({
+      #   "exception":"ZeroDivisionError",
+      #   "message":"ZeroDivisionError"
+      # })
+    end
+  end
+end

data/spec/commands_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+require 'open3'
+
+describe "binnacle command" do
+  it 'requires a subcommand' do
+    expect(`binnacle`).to eq(NO_SUBCOMMAND_GIVEN)
+  end
+
+  it 'returns an error message for unknown subcommands' do
+    expect(`binnacle foo`).to eq("I don't know the subcommand command 'foo'\n")
+  end
+
+  it 'returns the help for the binnacle tail sub command' do
+    expect(`binnacle tail --help`).to eq(BINNACLE_TAIL_HELP)
+  end
+end
+
+describe BinnacleCommand do
+  before { ENV["TEST_MODE"] = 'true' }
+
+  it 'requires a known subcommand argument' do
+    expect { BinnacleCommand.new.run(['foobar'])}.to output("I don't know the subcommand command 'foobar'\n").to_stdout
+  end
+
+  describe 'tail command' do
+    it 'validates the passed params before executing' do
+      expected_output = [
+        %[The following errors prevented the tail command from executing:],
+        %[  - No channel or app given],
+        %[  - No authentication information given\n],
+        %[SUBCOMMAND],
+        %[      tail -- listen to a Binnacle channel or app\n\n]
+      ].join("\n")
+      expect {
+      BinnacleCommand.new.run(["tail"])
+      }.to output(expected_output).to_stdout
+    end
+
+    unless ENV["CI"] == "true"
+      it 'with -n flag returns recent events', :vcr do
+        args = ["tail", "-n", "10", "-s", "60", "--host=localhost", "--channel=ylhcn28x7skv6av8q93m", "--api-key=jzr5d5kgj4j3l8fm90tr", "--api-secret=bz3e3w44o3323dypp8d7", "--no-encrypted"]
+
+        expect { BinnacleCommand.new.run(args) }.to output(TAIL_DASH_L).to_stdout
+
+        expect(a_request(:get, 'http://localhost:8080/api/endpoints'))
+        expect(
+          a_request(:get, "http://localhost:8080/api/events/ylhcn28x7skv6av8q93m/recents?limit=10&since=60")
+        ).to(have_been_made.times(1))
+      end
+    end
+  end
+end
+
+NO_SUBCOMMAND_GIVEN = <<-EOS
+Usage:
+   binnacle 'subcommand'
+
+where [subcommands] are:
+  tail: tails signals on a Binnacle Application or Channel
+  help: shows this message
+
+options for 'binnacle'
+  -h, --help    Show this message
+EOS
+
+BINNACLE_TAIL_HELP = <<-EOS
+Usage:
+   binnacle tail [options]
+
+where [options] are:
+  -h, --host=<s>                     Binnacle Host (default: localhost)
+  -c, --channel=<s>                  Binnacle Channel
+  -a, --app=<s>                      Binnacle App
+  -u, --api-key=<s>                  Binnacle API Key
+  -p, --api-secret=<s>               Binnacle API Secret
+  -f, --follow                       Monitors a Binnacle Channel or App
+  -n, --lines=<i>                    Get the last n events on the Channel
+  -s, --since=<i>                    Number of minutes in the past to search
+                                     for events
+  -e, --encrypted, --no-encrypted    Use SSL/HTTPS (default: true)
+  -l, --help                         Show this message
+EOS
+
+TAIL_DASH_L = <<-EOS
+Retrieving last 10 lines since 60 minutes ago from Channel ylhcn28x7skv6av8q93m ...
+INFO       [2015-10-22 13:37:28 -0700] TEST_EVT2  ::  client_id = io, session_id = SESS_01, ip = 0:0:0:0:0:0:0:1, tags = [["account", "upgrade"]]
+INFO       [2015-10-22 13:37:32 -0700] TEST_EVT2  ::  client_id = io, session_id = SESS_01, ip = 0:0:0:0:0:0:0:1, tags = [["account", "upgrade"]]
+INFO       [2015-10-22 13:37:32 -0700] TEST_EVT2  ::  client_id = io, session_id = SESS_01, ip = 0:0:0:0:0:0:0:1, tags = [["account", "upgrade"]]
+INFO       [2015-10-22 13:37:33 -0700] TEST_EVT2  ::  client_id = io, session_id = SESS_01, ip = 0:0:0:0:0:0:0:1, tags = [["account", "upgrade"]]
+INFO       [2015-10-22 13:37:36 -0700] TEST_EVT2  ::  client_id = io, session_id = SESS_01, ip = 0:0:0:0:0:0:0:1, tags = [["account", "upgrade"]]
+EOS