chillout 0.2.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in chillout.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Michał Łomnicki
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,22 @@
+# Chillout
+
+## Installation
+
+Add this line to your Rails application's Gemfile:
+
+    gem 'chillout'
+
+And then execute:
+
+    $ bundle
+
+And configure in config/environments/production.rb:
+
+```ruby
+config.chillout = {
+  secret: '<YOUR_SECRET>',
+  ssl: true,
+  port: 443,
+  hostname: 'api.chillout.io'
+}
+```

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task :default => :test
+
+desc 'Run chillout unit tests.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end

data/chillout.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'chillout/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "chillout"
+  gem.version       = Chillout::VERSION
+  gem.authors       = ["Michał Łomnicki", "Jan Filipowski"]
+  gem.email         = ["michal.lomnicki@gmail.com", "jachuf@gmail.com", "dev@arkency.com"]
+  gem.description   = "Chillout.io Ruby client"
+  gem.summary       = "Chillout.io Ruby client"
+  gem.homepage      = "http://chillout.io/"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "minitest", "~>3.2.0"
+  gem.add_development_dependency "rake",  "~> 0.9.2"
+  gem.add_development_dependency "mocha", "~> 0.12.7"
+  gem.add_development_dependency "contest", "~> 0.1.3"
+  gem.add_development_dependency "rack-test", "~> 0.6.2"
+  gem.add_development_dependency "webmock", "~> 1.8.11"
+end

data/lib/chillout/client.rb

@@ -0,0 +1,52 @@
+require 'forwardable'
+require 'chillout/server_side'
+require 'chillout/http_client'
+require 'chillout/error_filter'
+require 'chillout/dispatcher'
+require 'chillout/config'
+require 'chillout/error'
+require 'chillout/event_data_builder'
+require 'chillout/prefixed_logger'
+
+module Chillout
+  class Client
+    extend Forwardable
+
+    def_delegators :@dispatcher, :dispatch_error, :send_error, :send_creations
+
+    attr_reader :config
+    attr_reader :logger
+
+    def initialize(config_or_api_key, options = {})
+      build_config(config_or_api_key, options)
+
+      yield @config if block_given?
+
+      @logger = PrefixedLogger.new("Chillout", @config.logger)
+
+      @http_client = HttpClient.new(@config, logger)
+      @event_data_builder = EventDataBuilder.new(@config)
+      @server_side = ServerSide.new(@event_data_builder, @http_client)
+      @filter      = ErrorFilter.new
+      @dispatcher  = Dispatcher.new(@filter, @server_side)
+    end
+
+    def send_exception(exception, environment = {})
+      send_error(Error.new(exception, environment))
+    end
+
+    private
+    def build_config(config_or_api_key, options)
+      case config_or_api_key
+      when Config
+        @config = config_or_api_key
+      when String
+        @config = Config.new(config_or_api_key)
+      else
+        raise ArgumentError.new("Invalid config passed")
+      end
+      @config.update(options)
+    end
+
+  end
+end

data/lib/chillout/config.rb

@@ -0,0 +1,55 @@
+require 'logger'
+require 'chillout/version'
+
+
+module Chillout
+  class Config
+
+    DEFAULT_HOSTNAME      = "api.chillout.io"
+    DEFAULT_PORT          = 80
+    DEFAULT_NOTIFIER_NAME = "Chillout"
+    DEFAULT_NOTIFIER_URL  = "http://github.com/chilloutio/chillout"
+    DEFAULT_SHELL_ENV     = ENV.to_hash
+
+    attr_accessor :environment
+    attr_accessor :shell_environment
+    attr_accessor :notifier_name
+    attr_accessor :notifier_url
+    attr_accessor :version
+    attr_accessor :platform
+    attr_accessor :hostname
+    attr_accessor :port
+    attr_accessor :api_key
+    attr_writer   :authentication_user
+    attr_writer   :authentication_password
+    attr_accessor :logger
+    attr_accessor :ssl
+
+    def initialize(api_key = nil)
+      @api_key = api_key
+      @hostname = DEFAULT_HOSTNAME
+      @port = DEFAULT_PORT
+      @notifier_name = DEFAULT_NOTIFIER_NAME
+      @notifier_url = DEFAULT_NOTIFIER_URL
+      @version = VERSION
+      @shell_environment = DEFAULT_SHELL_ENV
+      @logger = Logger.new(STDOUT)
+      @ssl = true
+    end
+
+    def update(options)
+      options.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+
+    def authentication_user
+      @authentication_user || api_key
+    end
+
+    def authentication_password
+      @authentication_password || api_key
+    end
+
+  end
+end

data/lib/chillout/creation_listener.rb

@@ -0,0 +1,15 @@
+require 'chillout/creations_container'
+
+module Chillout
+  module CreationListener
+    def inherited(subclass)
+      super
+      class_name = subclass.name
+      subclass.after_commit on: :create do
+        Thread.current[:creations] ||= CreationsContainer.new
+        creations = Thread.current[:creations]
+        creations.increment!(class_name)
+      end
+    end
+  end
+end

data/lib/chillout/creations_container.rb

@@ -0,0 +1,21 @@
+module Chillout
+  class CreationsContainer
+    def initialize
+      @container = Hash.new {|hash, key| hash[key] = 0}
+    end
+
+    def increment!(class_name)
+      key = class_name.to_sym
+      @container[key] += 1
+    end
+
+    def [](name)
+      key = name.to_sym
+      @container[key]
+    end
+
+    def resource_keys
+      @container.keys
+    end
+  end
+end

data/lib/chillout/dispatcher.rb

@@ -0,0 +1,25 @@
+module Chillout
+  class Dispatcher
+
+    def initialize(filter, server_side)
+      @filter      = filter
+      @server_side = server_side
+    end
+
+    def dispatch_error(error)
+      if @filter.deliver_error?(error)
+        send_error(error)
+      end
+    end
+
+    def send_error(error)
+      @server_side.send_error(error)
+    rescue HttpClient::NotSent
+    end
+
+    def send_creations(creations)
+      @server_side.send_creations(creations)
+    rescue HttpClient::NotSent
+    end
+  end
+end

data/lib/chillout/error.rb

@@ -0,0 +1,60 @@
+require 'ostruct'
+
+module Chillout
+  class Error
+
+    attr_reader :exception
+    attr_reader :environment
+
+    def initialize(exception, environment = {})
+      @exception   = exception
+      @environment = environment
+      @nullObject  = OpenStruct.new
+    end
+
+    def exception_class
+      exception.class.name
+    end
+
+    def message
+      exception.message
+    end
+
+    def backtrace
+      exception.backtrace
+    end
+
+    def file
+      backtrace.first.split(":").first rescue nil
+    end
+
+    def controller
+      environment['action_controller.instance'] || @nullObject
+    end
+
+    def controller_name
+      controller.controller_name
+    end
+
+    def controller_action
+      controller.action_name
+    end
+
+    def current_user
+      environment['current_user'] || @nullObject
+    end
+
+    def current_user_id
+      current_user.id if current_user.respond_to?(:id)
+    end
+
+    def current_user_email
+      current_user.email if current_user.respond_to?(:email)
+    end
+
+    def current_user_full_name
+      current_user.full_name if current_user.respond_to?(:full_name)
+    end
+
+  end
+end

data/lib/chillout/error_filter.rb

@@ -0,0 +1,9 @@
+module Chillout
+  class ErrorFilter
+
+    def deliver_error?(error)
+      true
+    end
+
+  end
+end

data/lib/chillout/event_data_builder.rb

@@ -0,0 +1,67 @@
+module Chillout
+  class EventDataBuilder
+    def initialize(config)
+      @config = config
+    end
+
+    def build_from_error(error, timestamp)
+      {
+        event: "exception",
+        timestamp: timestamp,
+        content: {
+          class: error.exception_class,
+          message: error.message,
+          backtrace: error.backtrace,
+          file: error.file,
+          environment: @config.environment,
+          context: {
+            platform: @config.platform,
+            controller: error.controller_name,
+            action: error.controller_action,
+            current_user: {
+              id: error.current_user_id,
+              email: error.current_user_email,
+              full_name: error.current_user_full_name
+            }
+          },
+          rack_environment: build_rack_environment(error),
+          shell_environment: @config.shell_environment
+        },
+        notifier: build_notifier
+      }
+    end
+
+    def build_from_creations_container(creations_container, timestamp)
+      {
+        metric: "creations",
+        timestamp: timestamp,
+        content: {
+          creations: build_creations_content(creations_container),
+          environment: @config.environment
+        },
+        notifier: build_notifier
+      }
+    end
+
+    def build_creations_content(creations_container)
+      creation_tuples = creations_container.resource_keys.map do |key|
+        [key, creations_container[key]]
+      end
+      Hash[creation_tuples]
+    end
+
+    def build_notifier
+      {
+        name: @config.notifier_name,
+        version: @config.version,
+        url: @config.notifier_url
+      }
+    end
+
+    def build_rack_environment(error)
+      Hash[error.environment.collect do |key, value|
+        [key, value.to_s]
+      end]
+    end
+  end
+end

data/lib/chillout/http_client.rb

@@ -0,0 +1,36 @@
+require 'net/http'
+require 'json'
+
+module Chillout
+  class HttpClient
+    class NotSent < StandardError
+      attr_reader :original_exception
+      def initialize(original_exception)
+        @original_exception = original_exception
+      end
+    end
+
+    MEDIA_TYPE = "application/vnd.chillout.v1+json"
+
+    def initialize(config, logger)
+      @config = config
+      @logger = logger
+    end
+
+    def post(path, data)
+      http = Net::HTTP.new(@config.hostname, @config.port)
+      http.use_ssl = @config.ssl
+      request_spec = Net::HTTP::Post.new(path)
+      request_spec.body = JSON.dump(data)
+      request_spec.content_type = MEDIA_TYPE
+      request_spec.basic_auth @config.authentication_user, @config.authentication_password
+      http.start do
+        http.request(request_spec)
+      end
+    rescue => e
+      @logger.error("#{e.class}: #{e.message}")
+      raise NotSent.new(e)
+    end
+
+  end
+end

data/lib/chillout/middleware/creations_monitor.rb

@@ -0,0 +1,19 @@
+module Chillout
+  module Middleware
+    class CreationsMonitor
+      def initialize(app, client)
+        @app = app
+        @client = client
+      end
+
+      def call(env)
+        response = @app.call(env)
+        if Thread.current[:creations]
+          @client.send_creations(Thread.current[:creations])
+          Thread.current[:creations] = nil
+        end
+        response
+      end
+    end
+  end
+end

data/lib/chillout/middleware/exception_monitor.rb

@@ -0,0 +1,25 @@
+module Chillout
+  module Middleware
+    class ExceptionMonitor
+      def initialize(app, client)
+        @app    = app
+        @client = client
+      end
+
+      def call(env)
+        begin
+          response = @app.call(env)
+        rescue Exception => exception
+          @client.dispatch_error(Chillout::Error.new(exception, env))
+          raise exception
+        end
+
+        if env['rack.exception']
+          @client.dispatch_error(Chillout::Error.new(env['rack.exception'], env))
+        end
+
+        response
+      end
+    end
+  end
+end

data/lib/chillout/prefixed_logger.rb

@@ -0,0 +1,16 @@
+module Chillout
+  class PrefixedLogger
+    attr_reader :prefix
+
+    def initialize(prefix, logger)
+      @prefix = prefix
+      @logger = logger
+    end
+
+    [:error, :fatal, :warn, :info, :debug].each do |method_name|
+      define_method method_name do |message|
+        @logger.send(method_name, "[Chillout] #{message}")
+      end
+    end
+  end
+end

data/lib/chillout/railtie.rb

@@ -0,0 +1,21 @@
+require 'chillout/creation_listener'
+
+module Chillout
+  class Railtie < Rails::Railtie
+    config.chillout = ActiveSupport::OrderedOptions.new
+    initializer "chillout.exceptions_listener_initialization" do |app|
+      if !app.config.chillout.empty?
+        existing_option_keys = [:port, :hostname, :ssl].select{|key| app.config.chillout.has_key?(key)}
+        options_list = existing_option_keys.map{|key| [key, app.config.chillout[key]]}
+        options = Hash[options_list].merge(logger: Rails.logger)
+
+        client = Client.new(app.config.chillout[:secret], options)
+
+        ActiveRecord::Base.extend(CreationListener)
+
+        app.middleware.use Middleware::ExceptionMonitor, client
+        app.middleware.use Middleware::CreationsMonitor, client
+      end
+    end
+  end
+end

data/lib/chillout/server_side.rb

@@ -0,0 +1,35 @@
+require 'time'
+require 'chillout/event_data_builder'
+
+module Chillout
+  class ServerSide
+
+    def initialize(event_data_builder, http_client)
+      @http_client = http_client
+      @event_data_builder = event_data_builder
+    end
+
+    def send_error(error)
+      event_data = @event_data_builder.build_from_error(error, timestamp)
+      send_event(event_data)
+    end
+
+    def send_event(data)
+      @http_client.post('/events', data)
+    end
+
+    def send_creations(creations_container)
+      event_data = @event_data_builder.build_from_creations_container(creations_container, timestamp)
+      send_metric(event_data)
+    end
+
+    def send_metric(data)
+      @http_client.post('/metrics', data)
+    end
+
+    private
+      def timestamp
+        Time.now.iso8601
+      end
+  end
+end

data/lib/chillout/version.rb

@@ -0,0 +1,3 @@
+module Chillout
+  VERSION = "0.2.0"
+end

data/lib/chillout.rb

@@ -0,0 +1,16 @@
+require "chillout/version"
+require "chillout/config"
+require "chillout/middleware/exception_monitor"
+require "chillout/middleware/creations_monitor"
+require "chillout/error"
+require "chillout/dispatcher"
+require "chillout/error_filter"
+require "chillout/server_side"
+require "chillout/http_client"
+require "chillout/client"
+
+module Chillout
+end
+
+require 'chillout/railtie' if defined?(Rails)
+

data/test/client_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class ClientTest < ChilloutTestCase
+
+  def test_initialize_with_config
+    config = Chillout::Config.new("xyz123")
+    client = Chillout::Client.new(config)
+    assert_equal config, client.config
+  end
+
+  def test_initialize_with_options_hash
+    client = Chillout::Client.new("xyz123", platform: 'rack')
+    assert_equal "xyz123", client.config.api_key
+    assert_equal "rack", client.config.platform
+  end
+
+  def test_initialize_with_block
+    client = Chillout::Client.new("xyz") do |config|
+      config.platform = "rack"
+    end
+    assert_equal "xyz", client.config.api_key
+    assert_equal "rack", client.config.platform
+  end
+
+  def test_initialize_with_options_hash_and_block
+    client = Chillout::Client.new("xyz", platform: 'rack') do |config|
+      config.port = 443
+    end
+    assert_equal "xyz", client.config.api_key
+    assert_equal "rack", client.config.platform
+    assert_equal 443, client.config.port
+  end
+
+  def test_initialize_with_unsupported_type_raises_an_error
+    assert_raises(ArgumentError) do
+      Chillout::Client.new(123)
+    end
+  end
+
+end

data/test/config_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class ConfigTest < ChilloutTestCase
+
+  def setup
+    @config = Chillout::Config.new("xyz123")
+  end
+
+  def test_api_key_is_set
+    assert_equal "xyz123", @config.api_key
+  end
+
+  def test_update_with_options_hash
+    @config.update(platform: 'rack')
+    assert_equal 'rack', @config.platform
+  end
+
+  def test_authentication_user_is_same_as_api_key
+    assert_equal @config.api_key, @config.authentication_user
+  end
+
+  def test_authentication_password_is_same_as_api_key
+    assert_equal @config.api_key, @config.authentication_password
+  end
+
+end

data/test/creations_container_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+require 'chillout/creations_container'
+
+module Chillout
+  class CreationsContainerTest < ChilloutTestCase
+    def test_increment_model
+      creations_container = CreationsContainer.new
+      creations_container.increment!("User")
+      assert_equal 1, creations_container[:User]
+    end
+  end
+end