binnacle 0.4.8

data/Rakefile

@@ -0,0 +1,48 @@
+require 'bundler/gem_tasks'
+require 'bundler/cli'
+require 'fileutils'
+require 'optparse'
+
+namespace :binnacle do
+  desc "Pull JS assets from rails-assets-binnacle gem into vendo/assets/javascripts"
+  task :install_binnacle_js do
+
+    gems = [
+      'base64',
+      'moment',
+      'atmosphere',
+      'firebase',
+      'binnacle'
+    ]
+
+    rails_manifest = "#{Dir.pwd}/vendor/assets/javascripts/binnacle.js"
+
+    FileUtils.rm_rf(Dir.glob("{Dir.pwd}/vendor/assets/javascripts/*"))
+
+    File.open(rails_manifest, "w+") do |f|
+      gems.each do |gem_name|
+        puts "Processing asset gem #{gem_name}..."
+        rails_assets_name = "rails-assets-#{gem_name}"
+        gem_directory = Bundler.rubygems.find_name(rails_assets_name).first.full_gem_path
+        gem_manifest = "#{gem_directory}/app/assets/javascripts/#{gem_name}.js"
+        source_assets_directory = "#{gem_directory}/app/assets/javascripts/#{gem_name}"
+        target_assets_directory = "#{Dir.pwd}/vendor/assets/javascripts/#{gem_name}"
+
+        target = File.dirname(target_assets_directory)
+        unless File.directory?(target)
+          FileUtils.mkdir_p(target)
+          puts "> creating target assets directory #{target_assets_directory}"
+        end
+
+        puts "> copying JS assets from #{rails_assets_name} to /app/assets/javascripts/#{gem_name}"
+        FileUtils.cp_r "#{source_assets_directory}/.", target_assets_directory, :verbose => true
+
+        puts "> writing #{gem_name} manifest contents to binnacle manifest..."
+        File.open(gem_manifest, "rb") do |fm|
+          contents = fm.read
+          f.puts(contents)
+        end
+      end
+    end
+  end
+end

data/bin/binnacle

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'binnacle'
+
+BinnacleCommand.new.run(ARGV)

data/binnacle.gemspec

@@ -0,0 +1,49 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'binnacle/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "binnacle"
+  spec.version       = Binnacle::VERSION
+  spec.authors       = ["Brian Sam-Bodden"]
+  spec.email         = ["brian@binnacle.com"]
+  spec.summary       = %q{ Ruby client for the Binnacle API }
+  spec.description   = %q{ Binnacle Distributed Logging and Push Service. See http://binnacle.io }
+  spec.homepage      = "http://binnacle.io/api"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'httpclient', '~> 2.8', '>= 2.8.0'
+  spec.add_runtime_dependency 'faraday', '~> 0.11'
+  spec.add_runtime_dependency 'faye-websocket', '~> 0.10', '>= 0.10.4'
+  spec.add_runtime_dependency 'trollop', '~> 2.1', '>= 2.1.2'
+  spec.add_runtime_dependency 'rack-timeout', '~> 0.4', '>= 0.4.2'
+  spec.add_runtime_dependency 'addressable', '~> 2.5'
+  spec.add_runtime_dependency 'colorize', '~> 0.8.1'
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.5'
+  spec.add_development_dependency 'rspec', '~> 3.5', '>= 3.2.0'
+  spec.add_development_dependency 'rspec-collection_matchers', '~> 1.1', '>= 1.1.2'
+  spec.add_development_dependency 'rspec-wait', '~> 0.0.9'
+  spec.add_development_dependency 'codeclimate-test-reporter', '~> 1.0', '>= 1.0.7'
+  spec.add_development_dependency 'simplecov', '~> 0.14'
+  spec.add_development_dependency 'vcr', '~> 3.0'
+  spec.add_development_dependency 'webmock', '~> 2.3'
+  spec.add_development_dependency 'fivemat', '~> 1.3', '>= 1.3.2'
+  spec.add_development_dependency 'rack', '~> 2.0'
+
+  # For outgoing HTTP logging testing
+  spec.add_development_dependency 'httparty', '~> 0.14'
+  spec.add_development_dependency 'excon', '~> 0.55'
+  spec.add_development_dependency 'typhoeus', '~> 1.1'
+  spec.add_development_dependency 'ethon', '~> 0.10'
+  spec.add_development_dependency 'patron', '~> 0.8'
+  spec.add_development_dependency 'http', '~> 2.2'
+  spec.add_development_dependency 'thin', '~> 1.7'
+end

data/lib/binnacle.rb

@@ -0,0 +1,112 @@
+require 'forwardable'
+require 'binnacle/configuration'
+require 'binnacle/version'
+require 'binnacle/errors'
+require 'binnacle/connection'
+require 'binnacle/resource'
+require 'binnacle/client'
+require 'binnacle/logging/logging'
+require 'binnacle/commands/commands'
+
+require 'binnacle/http_logging/http_logger'
+require 'binnacle/http_logging/adapters/net_http'
+require 'binnacle/http_logging/adapters/httpclient'
+require 'binnacle/http_logging/adapters/excon'
+require 'binnacle/http_logging/adapters/ethon'
+require 'binnacle/http_logging/adapters/patron'
+require 'binnacle/http_logging/adapters/http'
+require 'binnacle/http_logging/adapters/typhoeus'
+
+require 'rack-timeout'
+
+module Binnacle
+  extend Forwardable
+  def_delegators :@client, :signal, :signal_asynch, :recents, :report_exception
+
+  [:signal, :signal_asynch, :recents, :report_exception].each do |m|
+    self.module_eval do
+      module_function(m)
+    end
+  end
+
+  LOCK = Mutex.new
+
+  def self.configuration
+    @configuration || LOCK.synchronize { @configuration ||= Binnacle::Configuration.new }
+  end
+
+  def self.configure(options = {})
+    set_options(options)
+
+    yield(configuration) if block_given?
+
+    configuration.prepare!
+
+    if configuration.ready?
+      create_client
+      setup_logger
+    end
+  end
+
+  def self.binnacle_logger
+    @internal_logger ||= defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+  end
+
+  def self.binnacle_logger=(logger)
+    @internal_logger = logger
+  end
+
+  def self.set_options(options)
+    options.each do |k,v|
+      configuration.send("#{k}=", v) rescue nil if configuration.respond_to?("#{k}=")
+    end
+  end
+
+  def self.create_client
+    binnacle_logger.info "Instantiating Binnacle Client..."
+    begin
+      @client = Client.new()
+    rescue Faraday::ConnectionFailed => fcf
+      binnacle_logger.error "Failed to connect to Binnacle. Check your settings!"
+    end
+  end
+
+  def self.setup_logger
+    if @client && configuration.can_setup_logger?
+      if defined?(Rails)
+        binnacle_logger.info "Configuring Binnacle Rails logger..."
+        @logger = Logging.new(@client, configuration.logging_channel)
+        @logger.level = Logger::INFO
+        if configuration.rails_verbose_logging?
+          Rails.logger.extend(ActiveSupport::Logger.broadcast(@logger))
+        end
+        Rack::Timeout.unregister_state_change_observer(:logger) if Rails.env.development?
+      else
+        binnacle_logger.info "Skipping Binnacle Rails logger configuration..."
+      end
+    end
+  end
+
+  def self.logger
+    @logger
+  end
+
+  def self.client
+    @client
+  end
+
+  #
+  # JS Assets Inclusion
+  #
+  if defined?(Rails)
+    class Engine < ::Rails::Engine
+      # Rails -> use app/assets directory.
+    end
+  end
+end
+
+if defined?(Rails::Railtie)
+  require 'binnacle/trap/middleware'
+  require 'binnacle/trap/railtie'
+  require 'binnacle/logging/request_log_subscriber'
+end

data/lib/binnacle/client.rb

@@ -0,0 +1,115 @@
+require 'binnacle/resources/event'
+require 'binnacle/trap/exception_event'
+require 'binnacle/logging/formatter'
+require 'socket'
+
+module Binnacle
+  class Client
+
+    attr_accessor :api_key, :api_secret
+    attr_accessor :connection
+    attr_accessor :logging_channel_id
+    attr_accessor :client_id
+    attr_accessor :session_id
+    attr_writer   :ready
+
+    def initialize(api_key = nil, api_secret = nil, endpoint = nil, logging_channel_id = nil)
+      self.api_key = api_key || Binnacle.configuration.api_key
+      self.api_secret = api_secret || Binnacle.configuration.api_secret
+      if endpoint
+        self.connection = Connection.new(self.api_key, self.api_secret, Binnacle.configuration.build_url(endpoint))
+      else
+        self.connection = Connection.new(self.api_key, self.api_secret)
+      end
+      self.logging_channel_id = logging_channel_id || Binnacle.configuration.logging_channel
+
+      self.client_id = ""
+      self.session_id = ""
+
+      @formatter = Binnacle::Logging::Formatter.new(self)
+    end
+
+    def signal(channel_id, event_name, client_id, session_id, log_level, tags = [], json = {}, asynch = false)
+      event = Binnacle::Event.new()
+      event.configure(channel_id, event_name, client_id, session_id, log_level, nil, tags, json)
+      event.connection = connection
+      asynch ? event.post_asynch : event.post
+    end
+
+    def signal_asynch(channel_id, event_name, client_id = '', session_id = '', log_level = 'INFO', tags = [], json = {})
+      signal(channel_id, event_name, client_id, session_id, log_level, tags, json, true)
+    end
+
+    def recents(lines, since, channel)
+      Binnacle::Event.recents(connection, lines, since, channel)
+    end
+
+    def events(channel, date, start_hour, end_hour, lines)
+      Binnacle::Event.events(connection, channel, date, start_hour, end_hour, lines)
+    end
+
+    def report_exception(exception, env, asynch = true)
+      event = Binnacle::Trap::ExceptionEvent.new(exception, env)
+      event.connection = connection
+      asynch ? event.post_asynch : event.post
+    end
+
+    #
+    # Ruby Logger Implementation
+    #
+
+    def formatter
+      @formatter
+    end
+
+    def write(event)
+      if event
+        event.connection = connection
+        Binnacle.configuration.asynch_logging ? event.post_asynch : event.post
+      end
+    end
+
+    def close
+      nil
+    end
+
+    def ready?
+      !connection.nil?
+    end
+
+    def log_rails_event(data)
+      session_id, client_id = session_and_client_ids
+      event_name = %[#{data[:method]} #{data[:path]}]
+
+      event = Binnacle::Event.new()
+      event.configure(logging_channel_id, event_name, client_id, session_id, 'log', data[:time], [], data)
+      write(event)
+    end
+
+    def log_http_event(data)
+      session_id, client_id = session_and_client_ids
+      event_name = %[#{data[:method]} #{data[:url]}]
+
+      event = Binnacle::Event.new()
+      event.configure(logging_channel_id, event_name, client_id, session_id, 'log', data[:time], [], data)
+      write(event)
+    end
+
+    def session_and_client_ids
+      if defined?(ActiveSupport::TaggedLogging) && Thread.current[:activesupport_tagged_logging_tags]
+        session_id, client_id = Thread.current[:activesupport_tagged_logging_tags].first(2)
+      else
+        session_id, client_id = self.session_id, self.client_id
+      end
+
+      unless client_id
+        # set it to the first non-loopback IP in the list
+        client_id = Socket.ip_address_list.find { |ai| ai.ipv4? && !ai.ipv4_loopback? }.ip_address
+      end
+
+      [ session_id, client_id ]
+    end
+
+  end
+
+end

data/lib/binnacle/commands/commands.rb

@@ -0,0 +1,20 @@
+require 'trollop'
+require_relative 'help'
+require_relative 'tail'
+
+class BinnacleCommand
+  def run(args)
+    ARGV.push(*args) if ENV["TEST_MODE"] == 'true' # testing cheat
+
+    subcommand = args[0].downcase.to_sym if args[0]
+    begin
+      if subcommand
+        Binnacle::Commands.send(subcommand)
+      else
+        Binnacle::Commands.send('help')
+      end
+    rescue NoMethodError => nme
+      puts "I don't know the subcommand command '#{subcommand}'"
+    end
+  end
+end

data/lib/binnacle/commands/help.rb

@@ -0,0 +1,21 @@
+module Binnacle::Commands
+
+  def self.help
+    opts = Trollop::options do
+      banner HELP_BANNER
+    end
+
+    Trollop::educate unless ENV["TEST_MODE"] == 'true'
+  end
+end
+
+HELP_BANNER = <<-EOS
+Usage:
+   binnacle 'subcommand'
+
+where [subcommands] are:
+  tail: tails signals on a Binnacle Application or Channel
+  help: shows this message
+
+options for 'binnacle'
+EOS

data/lib/binnacle/commands/tail.rb

@@ -0,0 +1,187 @@
+require 'faye/websocket'
+require 'addressable/uri'
+require 'eventmachine'
+require 'json'
+require 'colorize'
+
+module Binnacle::Commands
+
+  def self.tail
+    if ENV["TEST_MODE"] == 'true'
+      String.disable_colorization = true
+    end
+
+    opts = Trollop::options do
+      banner TAIL_BANNER
+      opt(:host, "Binnacle Host", type: :string, default: 'localhost')
+      opt(:channel, "Binnacle Channel", type: :string)
+      opt(:app, "Binnacle App",  type: :string)
+      opt(:api_key, "Binnacle API Key", type: :string, short: '-u')
+      opt(:api_secret, "Binnacle API Secret", type: :string, short: '-p')
+      opt(:follow, "Monitors a Binnacle Channel or App")
+      opt(:lines, "Get the last n events on the Channel", type: :int, short: '-n')
+      opt(:since, "Number of minutes in the past to search for events", type: :int)
+      opt(:encrypted, "Use SSL/HTTPS", default: true)
+    end
+
+    if (errors = validate(opts)).empty?
+      dispatch(opts)
+    else
+      puts "The following errors prevented the tail command from executing:"
+      errors.each { |e| puts "  - #{e}" }
+      puts "\nSUBCOMMAND"
+      puts "      tail -- listen to a Binnacle channel or app\n\n"
+      Trollop::educate unless ENV["TEST_MODE"] == 'true'
+    end
+  end
+
+  def self.validate(opts)
+    errors = []
+    errors << "No channel or app given" unless (opts[:channel_given] || opts[:app_given])
+    errors << "No authentication information given" unless (opts[:api_key_given] && opts[:api_secret_given])
+    errors << "Cannot use both 'follow' and 'lines'" if (opts[:follow_given] && opts[:lines_given])
+    errors << "Cannot use both 'app' and 'channel'" if (opts[:channel_given] && opts[:app_given])
+    errors << "Lines subcommand does not support montoring of Apps at this moment" if (opts[:lines_given] && opts[:app_given])
+    errors
+  end
+
+  def self.dispatch(opts)
+    # tail --follow
+    if opts[:follow_given] && opts[:app_given]
+      monitor(opts[:host], opts[:api_key], opts[:api_secret], opts[:app], true, opts[:encrypted])
+    elsif opts[:follow_given] && opts[:channel_given]
+      monitor(opts[:host], opts[:api_key], opts[:api_secret], opts[:channel], false, opts[:encrypted])
+    end
+
+    # tail --lines
+    lines(opts[:host], opts[:api_key], opts[:api_secret], opts[:channel], opts[:lines], opts[:since], opts[:encrypted_given] ? opts[:encrypted] : false) if opts[:lines_given]
+  end
+
+  #
+  # tail --follow --host=my_host --channel=my_channel
+  def self.monitor(host, api_key, api_secret, channel, is_app = false, encrypted = true)
+    EM.run do
+      Signal.trap("INT")  { EventMachine.stop }
+      Signal.trap("TERM") { EventMachine.stop }
+
+      ws_url = build_ws_url(host, api_key, api_secret, channel, is_app, encrypted)
+      ws = Faye::WebSocket::Client.new(ws_url)
+
+      ws.on :open do |event|
+        puts "Monitoring #{is_app ? 'App' : 'Channel'} #{channel} on #{host}..."
+      end
+
+      ws.on :message do |event|
+        if event.data !~ /\s/ && event.data != 'X'
+          print_event_from_json(event.data)
+        end
+      end
+
+      ws.on :close do |event|
+        ws = nil
+      end
+    end
+  end
+
+  #
+  # tail --lines=50 --since=10 --host=my_host --channel=my_channel
+  def self.lines(host, api_key, api_secret, channel, lines, since, encrypted = true)
+    puts "Retrieving last #{lines} lines since #{since} minutes ago from Channel #{channel} ..."
+    Binnacle.configuration.encrypted = encrypted
+    client = Binnacle::Client.new(api_key, api_secret, host)
+
+    client.recents(lines, since, channel).each do |e|
+      print_event(e)
+    end
+  end
+
+  protected
+
+  def self.build_ws_url(host, api_key, api_secret, channel, is_app = false, encrypted = true)
+    Addressable::URI.new(
+      host: host,
+      port: Binnacle::Configuration::DEFAULT_PORT,
+      scheme: encrypted ? 'wss' : 'ws',
+      path: ["/api/subscribe", is_app ? "app" : "channel", channel].join("/"),
+      query: build_ws_query(api_key, api_secret)
+    ).to_s
+  end
+
+  def self.build_ws_query(api_key, api_secret)
+    {
+      "Authorization" => %[Basic #{Base64.encode64("#{api_key}:#{api_secret}").strip}],
+      "X-Atmosphere-tracking-id" => "0",
+      "X-Atmosphere-Framework" => "2.3.2-javascript",
+      "X-Atmosphere-Transport" => "websocket",
+      "Content-Type" => "application/json",
+      "X-atmo-protocol" => "true"
+    }.map { |n,v| "#{n}=#{v}" }.join("&")
+  end
+
+  def self.print_event(event)
+    message = ""
+
+    level = '%-10.10s' % event.log_level
+
+    level = case
+    when ['INFO', 'EXPORT_JOB'].include?(level)
+      level.colorize(:blue)
+    when ['WARN', 'WARNING', 'OVERAGE'].include?(level)
+      level.colorize(:yellow)
+    when ['ERROR', 'FATAL', 'DELIVERY_FAILURE', 'EXCEPTION', 'OOPS', 'MYBAD'].include?(level)
+      level.colorize(:red)
+    when ['DEBUG'].include?(level)
+      level.colorize(:cyan)
+    when ['UNKNOWN'].include?(level)
+      level.colorize(:magenta)
+    else
+      level.colorize(:blue)
+    end.colorize(mode: :bold)
+
+    message << "#{level} [#{Time.at(event.event_time)}] "
+
+    message << ('%-10.10s' % event.event_name).colorize(color: :green, mode: :bold)
+
+    rest = []
+
+    unless event.client_id.nil? || event.client_id.empty?
+      rest << " #{'client_id'.colorize(mode: :bold)} = #{event.client_id}"
+    end
+
+    unless event.session_id.nil? || event.session_id.empty?
+      rest << "#{'session_id'.colorize(mode: :bold)} = #{event.session_id}"
+    end
+
+    unless event.ip_address.nil? || event.ip_address.empty?
+      rest << "#{'ip'.colorize(mode: :bold)} = #{('%-15.15s' % event.ip_address)}"
+    end
+
+    unless event.tags.empty?
+      tags = event.tags.join(',')
+      rest << "#{'tags'.colorize(mode: :bold)} = [#{event.tags}]"
+    end
+
+    message << " :: ".colorize(mode: :bold) + rest.join(", ") unless rest.empty?
+
+    puts message
+  end
+
+  def self.print_event_from_json(json)
+    begin
+      data = JSON.parse(json)
+      event = Binnacle::Event.from_hash(data)
+      print_event(event)
+    rescue JSON::ParserError => jpe
+      # do nothing!
+    end
+  end
+
+end
+
+TAIL_BANNER = <<-EOS
+Usage:
+   binnacle tail [options]
+
+where [options] are:
+
+EOS