yeller_ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 69148c3deef072819ef088784bbab18ba78499ff
+  data.tar.gz: dcb6d17d8c297cc968ea8915f562200498af1003
+SHA512:
+  metadata.gz: 1a5e13ea29a5fb9b3385f50201fe2776d8ca105b5f75ce4b0a589e176a24e339c21caa0015330bf7215e1a1ef9f4618a5ee39749efc3308cc5efd45b1aa1cd90
+  data.tar.gz: a63d64093d5e56edc5b773829e1024edc835fac1341bd213991c78b393323e9f65e8bb92e08cad52198b548b6b9d907f4c2cb7acd2bb1ecdd6462e69ef9bd63e

data/lib/yeller/client.rb

@@ -0,0 +1,43 @@
+module Yeller
+  class Client
+    def initialize(servers, token, startup_params, error_handler)
+      @servers = servers
+      @last_server = rand(servers.size)
+      @startup_params = startup_params
+      @token = token
+      @error_handler = error_handler
+    end
+
+    def report(exception, options={})
+      hash = ExceptionFormatter.format(exception, options)
+      serialized = JSON.dump(@startup_params.merge(hash))
+      report_with_roundtrip(serialized, 0)
+    end
+
+    def report_with_roundtrip(serialized, error_count)
+      next_server.client.post("/#{@token}", serialized, {"Content-Type" => "application/json"})
+    rescue StandardError => e
+      if error_count <= (@servers.size * 2)
+        report_with_roundtrip(serialized, error_count + 1)
+      else
+        @error_handler.handle(e)
+      end
+    end
+
+    def record_deploy(revision, user, environment)
+      post = Net::HTTP::Post.new("/#{@token}/deploys")
+      post.set_form_data('revision' => revision,
+                         'user' => user,
+                         'environment' => environment)
+      next_server.client.request(post)
+    end
+
+    private
+
+    def next_server
+      index = @last_server
+      @last_server = (index + 1) % @servers.size
+      @servers[index]
+    end
+  end
+end

data/lib/yeller/configuration.rb

@@ -0,0 +1,65 @@
+require_relative 'server'
+
+module Yeller
+  class Configuration
+    DEFAULT_SERVERS = [
+      Yeller::SecureServer.new("collector1.yellerapp.com", 443),
+      Yeller::SecureServer.new("collector2.yellerapp.com", 443),
+      Yeller::SecureServer.new("collector3.yellerapp.com", 443),
+      Yeller::SecureServer.new("collector4.yellerapp.com", 443),
+      Yeller::SecureServer.new("collector5.yellerapp.com", 443),
+    ]
+
+    def initialize
+      @servers = DEFAULT_SERVERS
+      @startup_params = {}
+      @error_handler = Yeller::LogErrorHandler.new
+    end
+
+    def remove_default_servers
+      @servers = []
+      self
+    end
+
+    def add_server(host, port=443)
+      @servers << Yeller::SecureServer.new(host, port)
+      self
+    end
+
+    def add_insecure_server(host, port=80)
+      @servers << Yeller::Server.new(host, port)
+    end
+
+    def environment=(new_environment)
+      @startup_params[:"application-environment"] = new_environment
+    end
+
+    def host=(new_host)
+      @startup_params[:host] = new_host
+    end
+
+    def token=(token)
+      @token = token
+    end
+
+    def token
+      @token
+    end
+
+    def servers
+      @servers
+    end
+
+    def startup_params
+      @startup_params
+    end
+
+    def error_handler
+      @error_handler
+    end
+
+    def error_handler=(new_error_handler)
+      @error_handler = new_error_handler
+    end
+  end
+end

data/lib/yeller/exception_formatter.rb

@@ -0,0 +1,44 @@
+module Yeller
+  class ExceptionFormatter
+    BACKTRACE_FORMAT = %r{^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$}.freeze
+
+    def self.format(exception, options={})
+      new(exception, options).to_hash
+    end
+
+    attr_reader :type, :options
+
+    def initialize(exception, options)
+      @type = exception.class.name
+      @message = exception.message
+      @backtrace = exception.backtrace
+      @options = options
+    end
+
+    def message
+      # If a message is not given, rubby will set message to the class name
+      @message == type ? nil : @message
+    end
+
+    def formatted_backtrace
+      return [] unless @backtrace
+
+      @backtrace.map do |line|
+        _, file, number, method = line.match(BACKTRACE_FORMAT).to_a
+        [file, number, method]
+      end
+    end
+
+    def to_hash
+      result = {
+        message: message,
+        stacktrace: formatted_backtrace,
+        type: type,
+        :"custom-data" => options.fetch(:custom_data, {})
+      }
+      result[:url] = options[:url] if options.key?(:url)
+      result[:location] = options[:location] if options.key?(:location)
+      result
+    end
+  end
+end

data/lib/yeller/log_error_handler.rb

@@ -0,0 +1,12 @@
+require 'logger'
+module Yeller
+  class LogErrorHandler
+    def initialize(logger=Logger.new(STDERR))
+      @logger = logger
+    end
+
+    def handle(e)
+      @logger.warn(e)
+    end
+  end
+end

data/lib/yeller/rack.rb

@@ -0,0 +1,40 @@
+require 'rack/request'
+require_relative '../yeller'
+
+module Yeller
+  class Rack
+    def self.configure(&block)
+      @client = Yeller.client(&block)
+    end
+
+    def self.report(exception, options={})
+      @client.report(exception, options)
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      begin
+        @app.call(env)
+      rescue Exception => exception
+        Yeller::Rack.rescue_rack_exception(exception, env)
+        raise exception
+      end
+    end
+
+    def self.rescue_rack_exception(exception, env)
+      ::Rails.logger.info("sending exception to yeller")
+      request = ::Rack::Request.new(env)
+      Yeller::Rack.report(
+        exception,
+        :url => request.url,
+        :custom_data => {
+        :params => request.params,
+        :session => env.fetch('rack.session', {}),
+      })
+      ::Rails.logger.info("sent exception to yeller")
+    end
+  end
+end

data/lib/yeller/rails.rb

@@ -0,0 +1,49 @@
+require 'rails'
+require 'yeller'
+require 'yeller/rack'
+
+module Yeller
+  class Rails
+    def self.configure(&block)
+      Yeller::Rack.configure do |config|
+        config.error_handler = Yeller::LogErrorHandler.new(::Rails.logger)
+        block.call(config)
+      end
+    end
+
+    module ActionControllerCatchingHooks
+      def self.included(base)
+        base.send(:alias_method, :render_exception_without_yeller, :render_exception)
+        base.send(:alias_method, :render_exception, :render_exception_with_yeller)
+      end
+
+      protected
+      def render_exception_with_yeller(env, exception)
+        ::Rails.logger.info("yeller: caught exception")
+        Yeller::Rack.rescue_rack_exception(exception, env)
+        render_exception_without_yeller(env, exception)
+      rescue Exception => e
+        ::Rails.logger.info("exception whilst handling exception: #{e} #{e.class} #{e.backtrace.join("\n")}")
+      end
+    end
+
+    class Railtie < ::Rails::Railtie
+      initializer "yeller.use_rack_middleware" do |app|
+        app.config.middleware.insert 0, "Yeller::Rack"
+      end
+
+      initializer "yeller.action_controller" do
+        ActiveSupport.on_load :action_controller do
+        end
+      end
+
+      config.after_initialize do
+        if defined?(::ActionDispatch::DebugExceptions)
+          ::ActionDispatch::DebugExceptions.send(:include, Yeller::Rails::ActionControllerCatchingHooks)
+        elsif defined(::ActionDispatch::ShowExceptions)
+          ::ActionDispatch::ShowExceptions.send(:include, Yeller::Rails::ActionControllerCatchingHooks)
+        end
+      end
+    end
+  end
+end

data/lib/yeller/server.rb

@@ -0,0 +1,22 @@
+require 'openssl'
+module Yeller
+  Server = Struct.new(:host, :port) do
+    def client
+      @client ||= Net::HTTP.new(host, port)
+    end
+  end
+
+  SecureServer = Struct.new(:host, :port) do
+    def client
+      @client ||= setup_client
+    end
+
+    def setup_client
+      http = Net::HTTP.new(host, port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      http.ciphers = "DEFAULT:!aNULL:!eNULL:!LOW:!EXPORT:!SSLv2"
+      http
+    end
+  end
+end

data/lib/yeller/startup_params.rb

@@ -0,0 +1,23 @@
+require_relative 'version'
+
+module Yeller
+  class StartupParams
+    PRODUCTION = 'production'.freeze
+    VERSION = "yeller_rubby: #{Yeller::VERSION}"
+
+    def self.defaults(options={})
+      {
+        :host => Socket.gethostname,
+        :"application-environment" => application_environment(options),
+        :"client-version" => VERSION,
+      }
+    end
+
+    def self.application_environment(options)
+      options[:"application-environment"] ||
+        ENV['RAILS_ENV'] ||
+        ENV['RACK_ENV'] ||
+        PRODUCTION
+    end
+  end
+end

data/lib/yeller/version.rb

@@ -0,0 +1,3 @@
+module Yeller
+  VERSION = "0.0.1"
+end

data/lib/yeller.rb

@@ -0,0 +1,27 @@
+require 'net/http'
+require 'yajl/json_gem'
+
+require_relative 'yeller/client'
+require_relative 'yeller/configuration'
+require_relative 'yeller/exception_formatter'
+require_relative 'yeller/server'
+require_relative 'yeller/version'
+require_relative 'yeller/startup_params'
+require_relative 'yeller/log_error_handler'
+
+module Yeller
+  def self.client(&block)
+    config = Yeller::Configuration.new
+    block.call(config)
+    build_client(config)
+  end
+
+  def self.build_client(config)
+    Yeller::Client.new(
+      config.servers,
+      config.token,
+      Yeller::StartupParams.defaults(config.startup_params),
+      config.error_handler
+    )
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: yeller_ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tom Crayford
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+description: A Ruby/Rack/Rails client for yellerapp.com
+email:
+- tcrayford@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/yeller.rb
+- lib/yeller/client.rb
+- lib/yeller/configuration.rb
+- lib/yeller/exception_formatter.rb
+- lib/yeller/log_error_handler.rb
+- lib/yeller/rack.rb
+- lib/yeller/rails.rb
+- lib/yeller/server.rb
+- lib/yeller/startup_params.rb
+- lib/yeller/version.rb
+homepage: https://github.com/tcrayford/yeller_rubby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: A Ruby/Rack/Rails client for yellerapp.com
+test_files: []