logbook 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+tmp/*.log

data/.rvmrc

@@ -0,0 +1 @@
+rvm ree@logbook_gem

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,33 @@
+PATH
+  remote: .
+  specs:
+    logbook (0.0.1)
+      addressable
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.2)
+    diff-lcs (1.1.2)
+    fakeweb (1.3.0)
+    rspec (2.0.0)
+      rspec-core (= 2.0.0)
+      rspec-expectations (= 2.0.0)
+      rspec-mocks (= 2.0.0)
+    rspec-core (2.0.0)
+    rspec-expectations (2.0.0)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.0)
+      rspec-core (= 2.0.0)
+      rspec-expectations (= 2.0.0)
+    timecop (0.3.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  addressable
+  fakeweb
+  logbook!
+  rspec
+  timecop

data/README.rdoc

@@ -0,0 +1,27 @@
+= What's logbook?
+
+Logbook is a hosted service for collecting log entries from your application.
+
+= Requirements
+
+Works in Rails 3 only at the moment. Check back later for more framework / versions.
+
+= Getting started
+
+* Go to http://logbook.me and create an account
+* Download logbook.yml that it genereated for you to the config dir
+* Add this gem to your Gemfile:
+
+  gem 'logbook'
+
+= Usage
+
+Anywhere in your application:
+
+  Logbook.debug 'facility', { :my => 'data' }
+
+Logbook has a method for every severity supported by the standard Ruby logger (in order of priority: debug < info < warn < error < fatal < unknown). Thefirst parameter it takes specifies "facility". It's a linux syslog analogy and allows to have different "types" of log entries so that you could filter them in the web interface more easily later. The second parameter needs to be a hash with any data that you want to log. Passing a hash is good because it allows to log structured data, which again makes it possible to filter records in the web interface.
+
+= Authors
+
+We created this service and gem during Rails Rumble 2010: http://railsrumble.com/teams/48-hours-of-unpaid-work-and-5-cookies

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/logbook.rb

@@ -0,0 +1,34 @@
+require 'logbook/agent'
+require 'logbook/client'
+require 'logbook/railtie'
+
+module Logbook
+  class << self
+    attr_accessor :api_key
+    attr_accessor :logger
+    attr_accessor :delay_between_requests
+
+    def start
+      agent.start
+    end
+
+    def stop
+      agent.stop
+    end
+
+    %W(debug info warn error fatal unknown).each do |severity|
+      define_method severity do |facility, payload|
+        agent.add_entry(severity.to_sym, facility, payload)
+      end
+    end
+
+    private
+
+      def agent
+        @agent ||= Logbook::Agent.instance
+      end
+  end
+
+  # Default values
+  self.delay_between_requests = 5
+end

data/lib/logbook/agent.rb

@@ -0,0 +1,79 @@
+require 'singleton'
+
+require 'logger'
+class Logbook::Agent
+  include Singleton
+
+  attr_reader :client, :entries, :stop_processing
+
+  def initialize
+    @client = Logbook::Client.new(Logbook.api_key)
+    @entries = []
+    @semaphore = Mutex.new
+    Logbook.logger.info('Logbook agent started')
+  end
+
+  def start
+    @keep_running = true
+    @loop = Thread.new do
+      run_loop
+    end
+    @loop['label'] = 'Logbook loop'
+  end
+
+  def stop
+    Logbook.logger.info 'Stopping logbook agent. Checking if there is anything to send'
+    @keep_running = false
+    @loop.join
+  end
+
+  def reset
+    entries.clear
+  end
+
+  def run_loop
+    while keep_running?
+      process
+      sleep Logbook.delay_between_requests
+    end
+  end
+
+  def process
+    @semaphore.synchronize {
+      return if entries.empty?
+
+      # Copying the queue
+      @entries_to_send = entries.dup
+      Logbook.logger.info("Sending #{@entries_to_send.size} entries to the server")
+
+      begin
+        @client.send_entries(@entries_to_send)
+      rescue => e
+        Logbook.logger.error("Error when sending data to the server: #{e.message}")
+
+        case e
+          when Logbook::Client::NotAuthorized
+            @stop_processing = true
+        end
+      ensure
+        # Removing sent items from the queue anyway
+        entries.shift(@entries_to_send.size)
+      end
+    }
+  end
+
+  def add_entry(severity, facility, payload)
+    entries.push(
+      :severity  => severity,
+      :facility  => facility,
+      :payload   => payload,
+      :timestamp => Time.now.to_s
+    )
+  end
+
+  private
+
+    def keep_running?
+      @keep_running && !@stop_processing
+    end
+end

data/lib/logbook/client.rb

@@ -0,0 +1,49 @@
+require 'uri'
+require 'net/https'
+require 'addressable/uri'
+
+class Logbook::Client
+
+  API_URL = "https://logbook.me/entries"
+
+  class NotAuthorized < StandardError ; end
+  class ServerError < StandardError ; end
+
+  attr_reader :api_key
+
+  def initialize(key)
+    @api_key = key
+  end
+
+  def send_entries(entries)
+    uri = URI.parse API_URL
+
+    req = Net::HTTP::Post.new(uri.path)
+    req.content_type = 'application/x-www-form-urlencoded'
+    req.body = request_body(entries)
+
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+    response = http.start {|session| session.request(req) }
+
+    case response
+      when Net::HTTPSuccess
+        true
+      when Net::HTTPUnauthorized
+        raise NotAuthorized
+      else
+        raise ServerError
+    end
+  end
+
+  private
+
+    def request_body(entries)
+      hash = Addressable::URI.new
+      processed = entries.map { |entry| entry.inject({}) { |r, e| r[e.first] = e.last.to_s; r } }
+      hash.query_values = {:entries => processed, :api_key => @api_key}
+      hash.query
+    end
+end

data/lib/logbook/railtie.rb

@@ -0,0 +1,27 @@
+if defined?(Rails)
+  module Logbook
+    class Railtie < Rails::Railtie
+      initializer "logbook.start_agent" do
+        Logbook.logger = ActiveSupport::BufferedLogger.new(File.join(Rails.root, 'log', 'logbook.log'))
+
+        config_file = File.join(Rails.root, 'config', 'logbook.yml')
+
+        if !File.exists?(config_file)
+          Logbook.logger.error('config/logbook.yml does not exist, shutting down')
+          next
+        end
+
+        config = YAML.load_file(config_file)[Rails.env.to_s] || {}
+
+        if !config['enabled']
+          Logbook.logger.info("Logbook is not enabled in #{Rails.env}, shutting down")
+          next
+        end
+
+        Logbook.api_key = config['api_key']
+        Logbook.start
+        at_exit { Logbook.stop }
+      end
+    end
+  end
+end

data/lib/logbook/version.rb

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

data/logbook.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "logbook/version"
+
+Gem::Specification.new do |s|
+  s.name        = "logbook"
+  s.version     = Logbook::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["48 hours of unpaid work and 5 cookies Rails Rumble 2010 Team"]
+  s.email       = ["support@logbook.me"]
+  s.homepage    = "http://logbook.me"
+  s.summary     = %q{Logbook is a hosted service to collect log entries from your application}
+  s.description = %q{A gem to integrate your Rails 3 app with http://logbook.me}
+
+  s.rubyforge_project = "logbook"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'timecop'
+  s.add_development_dependency 'fakeweb'
+
+  s.add_dependency 'addressable'
+end

data/spec/agent_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Logbook::Agent do
+  subject { Logbook::Agent.instance }
+
+  before(:each) do
+    subject.client.stub!(:send_entries)
+  end
+
+  after(:each) do
+    subject.reset
+  end
+
+  def process
+    subject.start; subject.stop
+  end
+
+  it "should set api_key for the Client" do
+    subject.client.api_key.should == 'test_key'
+  end
+
+  context 'when adding a new entry to the queue' do
+    it 'should add a timestamp to every entry' do
+      time = Time.now
+      Timecop.freeze(time)
+      subject.add_entry :debug, :test, 'test'
+      subject.entries.first[:timestamp].should == time.to_s
+    end
+  end
+
+  context 'when processing the queue' do
+    it 'should empty the queue' do
+      subject.add_entry :debug, :test, 'test'
+      process
+      subject.entries.should be_empty
+    end
+
+    it 'should send each entry to the server' do
+      subject.add_entry :debug, :test, 'test'
+      subject.client.should_receive(:send_entries).with(subject.entries.dup)
+      process
+    end
+
+    context 'when server errors out' do
+      it 'should still clear the queue' do
+        subject.add_entry :debug, :test, 'test'
+        subject.client.stub!(:send_entries).and_raise(Logbook::Client::ServerError)
+        process
+        subject.entries.should be_empty
+      end
+
+      it 'should stop processing the queue if it gets a NotAuthorized exception' do
+        subject.client.stub!(:send_entries).and_raise(Logbook::Client::NotAuthorized)
+        subject.add_entry :debug, :test, 'test'
+        process
+        subject.stop_processing.should == true
+      end
+    end
+  end
+
+  it 'should clear the queue on reset' do
+    subject.add_entry :debug, :test, 'test'
+    subject.reset
+    subject.entries.should be_empty
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Logbook::Client do
+
+  subject { Logbook::Client.new('key') }
+
+  context "when making a request" do
+    let(:request) { FakeWeb.last_request }
+
+    before(:each) do
+      FakeWeb.register_uri(:post, Logbook::Client::API_URL, {})
+    end
+
+    it "should make a POST request" do
+      subject.send_entries([])
+      request.should_not be_nil
+    end
+
+    it "should set content_type to 'text/plain' " do
+      subject.send_entries([])
+      request.content_type.should == 'application/x-www-form-urlencoded'
+    end
+
+    it "should send entries in the request" do
+      entries = [{:params => 'params'}]
+      subject.send_entries(entries)
+      request.body.should include("entries[0][params]=params")
+    end
+
+    it 'should handle non-sting data' do
+      expect { subject.send_entries([{:time => Time.now}]) }.
+        to_not raise_error
+    end
+
+    it "should send api_key in the request" do
+      subject.send_entries([])
+      request.body.should  include("api_key=key")
+    end
+  end
+
+  context "when processing a response" do
+    it "should not raise anything if response status is 200" do
+      FakeWeb.register_uri(:post, Logbook::Client::API_URL, {:status => ['200', 'Ok']})
+      expect { subject.send_entries([]) }.to_not raise_error
+    end
+
+    it "should raise NotAuthorized exception if response status is 401" do
+      FakeWeb.register_uri(:post, Logbook::Client::API_URL, {:status => ['401', 'Not Authorized']})
+      expect { subject.send_entries([]) }.to raise_error(Logbook::Client::NotAuthorized)
+    end
+
+    it "should raise ServerError exception if response status is 500" do
+      FakeWeb.register_uri(:post, Logbook::Client::API_URL, {:status => ['500', 'Server Error']})
+      expect { subject.send_entries([]) }.to raise_error(Logbook::Client::ServerError)
+    end
+  end
+end

data/spec/logbook_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Logbook do
+  let(:agent) do
+    Logbook::Agent.instance
+  end
+
+  before(:each) do
+    agent.client.stub!(:send_entries)
+  end
+
+  context 'when starting' do
+    it 'should start the agent' do
+      agent.should_receive(:start)
+      Logbook.start
+    end
+  end
+
+  it 'should add an entry to the queue' do
+    expect { Logbook.debug :facility, :data => :value }.
+      to change { agent.entries.size }.by(1)
+  end
+
+  context 'when stopping' do
+    it 'should stop the agent' do
+      agent.should_receive(:stop)
+      Logbook.stop
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'logbook'
+require 'timecop'
+require 'fakeweb'
+
+FakeWeb.allow_net_connect = false
+
+# No need to wait in tests
+Logbook.delay_between_requests = 0
+Logbook.api_key = 'test_key'
+Logbook.logger = Logger.new(File.dirname(__FILE__) + '/../tmp/test.log')

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification 
+name: logbook
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- 48 hours of unpaid work and 5 cookies Rails Rumble 2010 Team
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-17 00:00:00 +04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: timecop
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: addressable
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+description: A gem to integrate your Rails 3 app with http://logbook.me
+email: 
+- support@logbook.me
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- README.rdoc
+- Rakefile
+- lib/logbook.rb
+- lib/logbook/agent.rb
+- lib/logbook/client.rb
+- lib/logbook/railtie.rb
+- lib/logbook/version.rb
+- logbook.gemspec
+- spec/agent_spec.rb
+- spec/client_spec.rb
+- spec/logbook_spec.rb
+- spec/spec_helper.rb
+- tmp/.keep
+has_rdoc: true
+homepage: http://logbook.me
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: logbook
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Logbook is a hosted service to collect log entries from your application
+test_files: []
+