binnacle 0.4.8

data/spec/configuration_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe Binnacle::Configuration do
+
+  describe 'initialize' do
+    before { reset_env }
+
+    it 'can be configured via ENV variables' do
+      ENV['BINNACLE_ENDPOINT'] = '127.0.0.1'
+      ENV['BINNACLE_PORT'] = '8080'
+      ENV['BINNACLE_APP_LOG_CHANNEL'] = 'icoc0tnol3obe8pas207'
+      ENV['BINNACLE_APP_ERR_CHANNEL'] = 'id0czm8eryfffcgp875c'
+      ENV['BINNACLE_API_KEY'] = 'vceth4xcwqfoowpz2esi'
+      ENV['BINNACLE_API_SECRET'] = '1grttyb8ozbe9axt88ji'
+      ENV['BINNACLE_RAILS_LOG'] = 'TRUE'
+      ENV['BINNACLE_REPORT_EXCEPTIONS'] = 'TRUE'
+      ENV['BINNACLE_IGNORED_EXCEPTIONS'] = 'ZeroDivisionError'
+      ENV['BINNACLE_RAILS_LOG_ASYNCH'] = 'TRUE'
+      ENV['BINNACLE_ENCRYPTED'] = 'TRUE'
+
+      config = Binnacle::Configuration.new
+
+      expect(config.endpoint).to eq '127.0.0.1'
+      expect(config.port).to eq '8080'
+      expect(config.logging_channel).to eq 'icoc0tnol3obe8pas207'
+      expect(config.error_channel).to eq 'id0czm8eryfffcgp875c'
+      expect(config.api_key).to eq 'vceth4xcwqfoowpz2esi'
+      expect(config.api_secret).to eq '1grttyb8ozbe9axt88ji'
+      expect(config.intercept_rails_logging).to be true
+      expect(config.report_exceptions).to be true
+      expect(config.ignored_exceptions).to include('ZeroDivisionError')
+      expect(config.encrypted).to be true
+      expect(config.asynch_logging).to be true
+    end
+  end
+
+  describe 'endpoint' do
+    before { reset_env }
+
+    it 'configures urls given one endpoint' do
+      config = Binnacle::Configuration.new
+      config.endpoint = '127.0.0.1'
+      config.encrypted = false
+
+      expect(config.url).to eq('http://127.0.0.1:8080')
+    end
+
+    it 'configures urls given multiple endpoints' do
+      config = Binnacle::Configuration.new
+      config.endpoint = ['127.0.0.1', 'localhost', '192.168.0.1']
+      config.encrypted = false
+
+      expect(config.urls).to include('http://127.0.0.1:8080', 'http://localhost:8080', 'http://192.168.0.1:8080')
+    end
+
+    it 'configures urls given multiple endpoints via ENV var' do
+      ENV['BINNACLE_ENDPOINT'] = 'api1.binnacle-api.io,api2.binnacle-api.io,api3.binnacle-api.io'
+      config = Binnacle::Configuration.new
+
+      expect(config.urls).to include('https://api1.binnacle-api.io', 'https://api2.binnacle-api.io', 'https://api3.binnacle-api.io')
+    end
+  end
+
+  describe 'encrypted' do
+    before { reset_env }
+
+    it 'uses HTTP protocol if the encrypted flag is false' do
+      config = Binnacle::Configuration.new
+      config.endpoint = '127.0.0.1'
+      config.encrypted = false
+
+      expect(config.url).to eq('http://127.0.0.1:8080')
+    end
+
+    it 'uses HTTPS protocol by default without a port' do
+      config = Binnacle::Configuration.new
+      config.endpoint = 'api1.binnacle-api.io'
+
+      expect(config.url).to eq('https://api1.binnacle-api.io')
+    end
+  end
+
+  describe '#can_setup_logger?' do
+    before { reset_env }
+
+    it 'returns true if logging channel is set' do
+      ENV['BINNACLE_APP_LOG_CHANNEL'] = 'icoc0tnol3obe8pas207'
+
+      config = Binnacle::Configuration.new
+      expect(config.can_setup_logger?).to be true
+    end
+  end
+
+  describe '#trap?' do
+    before { reset_env }
+
+    it 'return true is log interception and logging channel are set' do
+      ENV['BINNACLE_APP_ERR_CHANNEL'] = 'id0czm8eryfffcgp875c'
+      ENV['BINNACLE_REPORT_EXCEPTIONS'] = 'TRUE'
+
+      config = Binnacle::Configuration.new
+      expect(config.trap?).to be true
+    end
+  end
+
+  describe '#ignore_cascade_pass?' do
+
+    it 'is true by default' do
+      config = Binnacle::Configuration.new
+      expect(config.ignore_cascade_pass?).to be true
+    end
+  end
+
+  describe '#to_s' do
+    before { reset_env }
+
+    it 'returns a representation of the config object' do
+      ENV['BINNACLE_ENDPOINT'] = '127.0.0.1'
+      ENV['BINNACLE_APP_LOG_CHANNEL'] = 'icoc0tnol3obe8pas207'
+      ENV['BINNACLE_APP_ERR_CHANNEL'] = 'id0czm8eryfffcgp875c'
+      ENV['BINNACLE_API_KEY'] = 'vceth4xcwqfoowpz2esi'
+      ENV['BINNACLE_API_SECRET'] = '1grttyb8ozbe9axt88ji'
+      ENV['BINNACLE_ENCRYPTED'] = 'FALSE'
+
+      config = Binnacle::Configuration.new
+      expect(config.to_s).to eq("endpoint: 127.0.0.1,"\
+                                " logging_channel: icoc0tnol3obe8pas207,"\
+                                " error_channel: id0czm8eryfffcgp875c,"\
+                                " api_key: vceth4xcwqfoowpz2esi,"\
+                                " api_secret: 1grttyb8ozbe9axt88ji,"\
+                                " intercept_rails_logging: false,"\
+                                " report_exceptions: false,"\
+                                " ignore_cascade_pass: true,"\
+                                " encrypted: false,"\
+                                " asynch_logging: true")
+    end
+  end
+
+end

data/spec/connection_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Binnacle::Connection do
+
+  describe 'initialize', :vcr do
+    before { Binnacle.binnacle_logger = TestLogger.new }
+
+    it 'fails with incorrect credentials', :vcr do
+      expected_output = "ERROR -- : Error communicating with Binnacle (/api/endpoints): Credentials are required to access this resource."
+      connection = Binnacle::Connection.new('vceth4xcwqfoowpz2esi', '1grttyb8ozbe9axt88ji', 'http://104.131.46.61:8080')
+      expect(a_request(:get, 'http://104.131.46.61:8080/api/endpoints'))
+      expect(Binnacle.binnacle_logger.messages).to include(expected_output)
+    end
+
+    it 'retrieves available endpoints upon successful connection', :vcr do
+      connection = Binnacle::Connection.new('863u7fzchvjx2oiclasx', '33lrt5aiizizhu5z7f3b', 'http://104.131.46.61:8080')
+      expect(a_request(:get, 'http://104.131.46.61:8080/api/endpoints'))
+      expect(Binnacle.configuration.urls).to include('http://104.131.41.123:8080',
+                                                     'http://104.236.110.41:8080',
+                                                     'http://104.131.46.61:8080',
+                                                     'http://104.131.106.113:8080',
+                                                     'http://45.55.141.159:8080',
+                                                     'http://104.131.75.74:8080')
+    end
+
+    it 'fails with bad endpoint', :vcr do
+      expected_output = %[ERROR -- : Error communicating with Binnacle (/api/endpoints): Connection refused - Connection refused - connect(2) for "localhost" port 8888 (localhost:8888)]
+      connection = Binnacle::Connection.new('vceth4xcwqfoowpz2esi', '1grttyb8ozbe9axt88ji', 'http://localhost:8888')
+      expect(a_request(:get, 'http://localhost:8888/api/endpoints'))
+      expect(Binnacle.binnacle_logger.messages).to include(expected_output)
+    end
+  end
+
+end

data/spec/exception_event_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Binnacle::Trap::ExceptionEvent do
+  describe 'initialize' do
+    it 'extracts Rails expection information from Action Dispatch request parameters' do
+      exception = ZeroDivisionError.new
+      env = {}
+      env['action_dispatch.request.parameters'] = {}
+      env['action_dispatch.request.parameters'][:controller] = 'dashboard'
+      env['action_dispatch.request.parameters'][:action] = 'analytics'
+      env['action_dispatch.request.parameters'][:module] = 'dashboard'
+
+      exception_event = Binnacle::Trap::ExceptionEvent.new(exception, env)
+
+      expect(exception_event.component).to eq('dashboard')
+      expect(exception_event.method).to eq('analytics')
+      expect(exception_event.module).to eq('dashboard')
+    end
+
+    it 'unwraps original_exception' do
+      class MyWrappedError < StandardError
+        attr_reader :original_exception
+        def initialize(msg, original=$!)
+          super(msg)
+          @original_exception = original
+        end
+      end
+      original_exception = ZeroDivisionError.new
+      exception = MyWrappedError.new("Boom!", original_exception)
+      exception_event = Binnacle::Trap::ExceptionEvent.new(exception, {})
+
+      expect(exception_event.exception).to be(original_exception)
+    end
+
+    it 'unwraps continous_exception' do
+      class MyContinuedError < StandardError
+        attr_reader :continued_exception
+        def initialize(msg, continous=$!)
+          super(msg)
+          @continued_exception = continous
+        end
+      end
+      continued_exception = ZeroDivisionError.new
+      exception = MyContinuedError.new("Boom!", continued_exception)
+      exception_event = Binnacle::Trap::ExceptionEvent.new(exception, {})
+
+      expect(exception_event.exception).to be(continued_exception)
+    end
+  end
+
+  describe 'build_json_payload' do
+    it 'creates a valid JSON payload' do
+      exception = ZeroDivisionError.new
+      env = {}
+      env['action_dispatch.request.parameters'] = {}
+      env['action_dispatch.request.parameters'][:controller] = 'dashboard'
+      env['action_dispatch.request.parameters'][:action] = 'analytics'
+      env['action_dispatch.request.parameters'][:module] = 'dashboard'
+
+      exception_event = Binnacle::Trap::ExceptionEvent.new(exception, env)
+
+      json = {
+        :exception=>"ZeroDivisionError",
+        :message=>"ZeroDivisionError",
+        :component=>"dashboard",
+        :method=>"analytics"
+      }
+
+      expect(exception_event.json).to match(a_hash_including(json))
+    end
+  end
+end

data/spec/http_logger_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Binnacle::HttpLogger do
+  before do
+    reset_env
+    Binnacle.configure do |config|
+      config.endpoint = 'localhost'
+      config.api_key = 'vceth4xcwqfoowpz2esi'
+      config.api_secret = '1grttyb8ozbe9axt88ji'
+      config.logging_channel = 'icoc0tnol3obe8pas207'
+      config.encrypted = false
+      config.asynch_logging = false
+    end
+  end
+
+  let(:host) { 'localhost' }
+  let(:port) { 9292 }
+  let(:path) { "/index.html" }
+  let(:headers) { { "accept" => "*/*", "foo" => "bar" } }
+  let(:data) { {'foo' => 'bar', 'bar' => 'foo'} }
+  let(:params) { {'foo' => 'bar:form-data', 'bar' => 'foo'} }
+
+  ADAPTERS = [
+    NetHTTPAdapter,
+    OpenUriAdapter,
+    HTTPClientAdapter,
+    HTTPartyAdapter,
+    FaradayAdapter,
+    ExconAdapter,
+    ENV['SERVE_TEST_ASSETS'] == 'true' ? EthonAdapter : nil,
+    TyphoeusAdapter,
+    PatronAdapter,
+    HTTPAdapter
+  ].compact
+
+  ADAPTERS.each do |adapter_class|
+    context adapter_class, adapter: adapter_class.to_s do
+      let(:adapter) { adapter_class.new(host, port, path, headers, data, params) }
+
+      connection_test_method = adapter_class.is_libcurl? ? :to_not : :to
+
+      if adapter_class.method_defined? :send_get_request
+        it "should log GET requests", :vcr do
+          res = adapter.send_get_request
+
+          expect(a_request(:get, 'http://localhost:8080/api/endpoints'))
+          expect(a_request(:get, 'http://localhost:9292/index.html'))
+
+          expect(
+            a_request(:post, "http://localhost:8080/api/events/icoc0tnol3obe8pas207").
+              with do |request|
+                body_as_json = JSON.parse(request.body)
+                body_as_json["channelId"] == "icoc0tnol3obe8pas207" &&
+                body_as_json["sessionId"] == "" &&
+                body_as_json["clientId"] == "" &&
+                body_as_json["eventName"] == "GET http://localhost:9292/index.html" &&
+                body_as_json["logLevel"] == "log" &&
+                body_as_json["tags"] == [] &&
+                body_as_json["json"]["url"] == "http://localhost:9292/index.html" &&
+                body_as_json["json"]["method"] == "GET" &&
+                body_as_json["json"]["host"] == "localhost" &&
+                body_as_json["json"]["port"] == 9292 &&
+                body_as_json["json"]["path"] == "/index.html" &&
+                body_as_json["json"]["query"] == "foo=bar&bar=foo" &&
+                body_as_json["json"]["format"] == "text/html" &&
+                body_as_json["json"]["status"] == "200" &&
+                body_as_json["json"]["duration"] > 0.0 &&
+                body_as_json["json"]["body"] == "<html>\n  <head>\n    <title>Test Page</title>\n  </head>\n  <body>\n    <h1>This is the test page.</h1>\n  </body>\n</html>" &&
+                body_as_json["json"]["data"] == ""
+                body_as_json["json"]["message"] =~ /GET http:\/\/localhost:9292\/index.html AS text\/html \(duration:(.*)/
+              end
+          ).to(have_been_made.times(1))
+        end
+      end
+    end
+  end
+end

data/spec/logger_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Binnacle::Logging do
+  before { Binnacle.configuration.asynch_logging = false }
+
+  let(:logger) {
+    Binnacle::Logging.build('vceth4xcwqfoowpz2esi', '1grttyb8ozbe9axt88ji', 'localhost', 'icoc0tnol3obe8pas207')
+  }
+
+  describe 'logging' do
+    it 'invokes the events api signal', :vcr do
+      logger.info("This is an info message")
+
+      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",
+          "eventName": "log",
+          "logLevel": "INFO",
+          "json": { "message": "This is an info message" }
+          })
+        )
+      ).to(have_been_made.times(1))
+    end
+
+    it 'respects the logger severity', :vcr do
+      logger.debug("This is an debug message")
+
+      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",
+          "eventName": "log",
+          "logLevel": "DEBUG",
+          "json": { "message": "This is an debug message" }
+          })
+        )
+      ).to(have_been_made.times(1))
+    end
+
+    it 'allows passing other parameters using a hash', :vcr do
+      logger.info(session_id: '8675309', event_name: 'failed_transfer') { 'transfer failed, bad RTN' }
+
+      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": "8675309",
+          "eventName": "failed_transfer",
+          "logLevel": "INFO",
+          "json": { "message": "transfer failed, bad RTN" }
+          })
+        )
+      ).to(have_been_made.times(1))
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,117 @@
+ENV['BINNACLE_RB_ENVIRONMENT'] ||= 'test'
+require 'simplecov'
+SimpleCov.start
+
+require 'webmock/rspec'
+require 'httpclient'
+require 'excon'
+require 'typhoeus'
+require 'ethon'
+require 'patron'
+require 'http'
+require 'vcr'
+require 'binnacle'
+require 'rspec/collection_matchers'
+require 'rspec/wait'
+require 'rack'
+require 'logger'
+
+require 'adapters/http_base_adapter'
+Dir["#{File.dirname(__FILE__)}/adapters/*.rb"].each { |f| require f }
+Dir["./spec/support/**/*.rb"].each { |f| require f }
+
+# Start a local rack server to serve up test pages.
+if ENV['SERVE_TEST_ASSETS'] == 'true'
+  @server_thread = Thread.new do
+    Rack::Handler::Thin.run HttpLogger::Test::Server.new, :Port => 9292
+  end
+  sleep(3) # wait a moment for the server to be booted
+end
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'spec/vcr'
+  c.hook_into :webmock
+  c.ignore_localhost = false
+  c.ignore_hosts 'codeclimate.com'
+  c.allow_http_connections_when_no_cassette = false
+end
+
+RSpec.configure do |config|
+  config.around(:each, :vcr) do |example|
+    name = example.metadata[:full_description].gsub(/\A(\S*)([\.])/, '\1 ').split(/\s+/, 2).join("/").underscore.gsub(/[^\w\/]+/, "_")
+    options = example.metadata.slice(:record, :match_requests_on).except(:example_group)
+    VCR.use_cassette(name, options) { example.call }
+  end
+
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+end
+
+# Some Monkey Patching since we're not in Rails
+
+class String
+  def underscore
+    return self.downcase if self =~ /^[A-Z]+$/
+    self.gsub(/([A-Z]+)(?=[A-Z][a-z]?)|\B[A-Z]/, '_\&') =~ /_*(.*)/
+    return $+.downcase
+  end
+end
+
+class Hash
+  def except(*keys)
+    dup.except!(*keys)
+  end
+
+  # Replaces the hash without the given keys.
+  def except!(*keys)
+    keys.each { |key| delete(key) }
+    self
+  end
+
+  def slice(*keys)
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    keys.each_with_object(self.class.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
+  end
+end
+
+
+
+class Logger
+  def pause
+    @_logdev, @logdev = @logdev, nil
+  end
+
+  def continue
+    @logdev = @_logdev
+  end
+end
+
+class TestLogger < Logger
+  def initialize
+    @strio = StringIO.new
+    super(@strio)
+  end
+
+  def messages
+    @strio.string
+  end
+end
+
+def reset_env
+ [ 'BINNACLE_ENDPOINT',
+   'BINNACLE_PORT',
+   'BINNACLE_APP_LOG_CHANNEL',
+   'BINNACLE_APP_ERR_CHANNEL',
+   'BINNACLE_API_KEY',
+   'BINNACLE_API_SECRET',
+   'BINNACLE_RAILS_LOG',
+   'BINNACLE_REPORT_EXCEPTIONS',
+   'BINNACLE_IGNORED_EXCEPTIONS',
+   'BINNACLE_RAILS_LOG_ASYNCH',
+   'BINNACLE_ENCRYPTED' ].each { |key| ENV[key] = nil }
+end