loggr-rb 1.0.5

data/bin/loggr

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+args = ARGV.dup
+ARGV.clear
+command = args.shift.strip rescue 'help'
+
+case command
+  when 'help'
+    puts <<USAGE
+help						# Show this usage.
+test						# Send a test exception to Loggr.
+install <log_key> <api_key>	# Create config/loggr.yml with your api_key. Overrites existing one.
+
+USAGE
+  when 'test'
+    if defined?(RAILS_ROOT)
+      puts "Loading Rails environment."
+      require(File.join('config', 'boot'))
+      require(File.join(RAILS_ROOT, 'config', 'environment')) if defined?(RAILS_ROOT)
+      require "loggr-rb/integration/tester"
+    else 
+      require 'loggr-rb'    
+      require "loggr-rb/integration/tester"      
+      Loggr::Config.load('config/loggr.yml')
+    end    
+    if Loggr::Config.api_key
+      Loggr::Integration.test
+    else
+      puts 'API key not configured'
+    end
+  when 'install'
+    log_key = args[0]
+    api_key = args[1]
+    environments = args[2]
+    
+	if (log_key.nil?)
+	  puts 'Missing required paramater <log-key>. Check your app configuration at http://loggr.net.'
+	else
+      if (api_key.nil?)
+        puts 'Missing required paramater <api-key>. Check your app configuration at http://loggr.net.'
+      else
+        if (defined?(RAILS_ROOT) && !File.file?('config/environment.rb'))
+          puts "Run this command from the root of your rails application." and exit
+        else
+          Dir.mkdir('config') unless File.exists?('config')        
+        end
+      end   
+	end     
+    config_file = File.open('config/loggr.yml', 'w')
+	config_file.puts("log-key: #{log_key}\n")
+    config_file.puts("api-key: #{api_key}\n")
+	config_file.puts("\n")
+	config_file.puts("development:\n")
+	config_file.puts("  enabled: true\n")
+
+    unless(environments.nil?)
+      environments.split(',').each do |envo|
+        config_file.puts("#{envo}:\n")
+        config_file.puts("  enabled: true\n")
+      end
+    end
+    
+    config_file.close
+    puts "Config file written as config/loggr.yml.";
+    puts "----------------------------------------------";
+    File.open('config/loggr.yml').readlines.each do |line|
+      puts line
+    end
+    puts "----------------------------------------------";
+end

data/init.rb

@@ -0,0 +1,38 @@
+require 'loggr-rb'
+
+# If old plugin still installed then we don't want to install this one.
+# In production environments we should continue to work as before, but in development/test we should
+# advise how to correct the problem and exit
+if (defined?(Loggr::VERSION::STRING) rescue nil) && %w(development test).include?(RAILS_ENV)
+  message = %Q(
+  ***********************************************************************
+  You seem to still have an old version of the Loggr plugin installed.
+  Remove it from /vendor/plugins and try again.
+  ***********************************************************************
+  )
+  puts message
+  exit -1
+else
+  begin
+    if (Rails::VERSION::MAJOR < 3)    
+      Loggr::Config.load(File.join(RAILS_ROOT, "/config/loggr.yml"))
+      if Loggr::Config.should_send_to_api?
+        Loggr.logger.info("Loading Loggr #{Loggr::VERSION} for #{Rails::VERSION::STRING}")      
+        require File.join('loggr-rb', 'integration', 'rails')    
+        require File.join('loggr-rb', 'integration', 'dj') if defined?(Delayed::Job)
+      end
+    else
+      Loggr::Config.load(File.join(Rails.root, "/config/loggr.yml"))
+      
+      if Loggr::Config.should_send_to_api?
+        Loggr.logger.info("Loading Loggr #{Loggr::VERSION} for #{Rails::VERSION::STRING}")      
+        Rails.configuration.middleware.use "Rack::RailsLoggr"
+        require File.join('loggr-rb', 'integration', 'dj') if defined?(Delayed::Job)
+      end      
+    end
+  rescue => e
+    STDERR.puts "Problem starting Loggr Plugin. Your app will run as normal. #{e.message}"
+    Loggr.logger.error(e.message)
+    Loggr.logger.error(e.backtrace)
+  end
+end

data/install.rb

@@ -0,0 +1,19 @@
+# This is the post install hook for when Loggr is installed as a plugin.
+require 'fileutils'
+  
+# puts IO.read(File.join(File.dirname(__FILE__), 'README'))
+
+config_file = File.expand_path("#{File.dirname(__FILE__)}/../../../config/loggr.yml")
+example_config_file = "#{File.dirname(__FILE__)}/loggr.yml"
+
+if File::exists? config_file
+  puts "Loggr config file already exists. Please ensure it is up-to-date with the current format."
+  puts "See #{example_config_file}"
+else  
+  puts "Installing default Loggr config."
+  puts "  From #{example_config_file}"
+  puts "For loggr to work you need to configure your API key."
+  puts "  See #{example_config_file}"
+  puts "If you don't have an API key, get one at http://loggr.net/."
+  FileUtils.copy example_config_file, config_file
+end

data/lib/loggr-rb.rb

@@ -0,0 +1,64 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'loggr-rb/catcher'
+require 'loggr-rb/logfactory'
+require 'loggr-rb/config'
+require 'loggr-rb/exceptiondata'
+require 'loggr-rb/integration/rack'    
+require 'loggr-rb/integration/rack_rails'
+require 'loggr-rb/logclient'
+require 'loggr-rb/events'
+
+require 'loggr-rb/version' if !defined?(Loggr::VERSION)
+require 'loggr-rb/railtie' if defined?(Rails::Railtie)
+
+module Loggr
+  PROTOCOL_VERSION = 5
+  CLIENT_NAME = 'loggr-rb-gem'
+  ENVIRONMENT_FILTER = []
+
+  def self.logger
+    ::Loggr::LogFactory.logger
+  end
+
+  def self.configure(api_key)
+    Loggr::Config.api_key = api_key
+  end
+
+  def self.handle(exception, request=nil)
+    Loggr::Catcher.handle(exception, request)
+  end
+  
+  def self.rescue(name=nil, context=nil, &block)
+    begin
+      self.context(context) unless context.nil?
+      block.call
+    rescue Exception => e
+      Loggr::Catcher.handle(e,name)
+    ensure
+      self.clear!
+    end
+  end
+
+  def self.rescue_and_reraise(name=nil, context=nil, &block)
+    begin
+      self.context(context) unless context.nil?
+      block.call
+    rescue Exception => e
+      Loggr::Catcher.handle(e,name)
+      raise(e)
+    ensure
+      self.clear!      
+    end
+  end
+
+  def self.clear!
+    Thread.current[:loggr_context] = nil
+  end
+
+  def self.context(hash = {})
+    Thread.current[:loggr_context] ||= {}
+    Thread.current[:loggr_context].merge!(hash)
+    self
+  end
+end

data/lib/loggr-rb/catcher.rb

@@ -0,0 +1,23 @@
+module Loggr
+  class Catcher
+    class << self
+      def handle_with_controller(exception, controller=nil, request=nil)
+        if Config.should_send_to_api?
+		  Loggr::Events.create_from_exception(exception, request).post()
+        end
+      end
+      
+      def handle_with_rack(exception, environment, request) 
+        if Config.should_send_to_api?
+		  Loggr::Events.create_from_exception(exception, request).post()
+        end
+      end
+
+      def handle(exception, request=nil)
+        if Config.should_send_to_api?
+          Loggr::Events.create_from_exception(exception, request).post()
+        end
+      end
+    end
+  end
+end

data/lib/loggr-rb/config.rb

@@ -0,0 +1,93 @@
+require 'yaml'
+
+module Loggr
+  class Config
+    class ConfigurationException < StandardError; end
+
+    class << self
+      DEFAULTS = {
+        :ssl => false,
+        :remote_host_http => 'plugin.getloggr.com',
+        :http_open_timeout => 2,
+        :http_read_timeout => 4,
+        :disabled_by_default => %w(development test)
+      }
+
+      attr_accessor :log_key, :api_key, :enabled
+      attr_accessor :http_proxy_host, :http_proxy_port, :http_proxy_username, :http_proxy_password
+      attr_writer :ssl
+
+      def load(config_file=nil)
+        if (config_file && File.file?(config_file))
+          begin
+            config = YAML::load_file(config_file)
+            env_config = config[application_environment] || {}
+			@log_key = config['log-key'] || env_config['log-key']
+            @api_key = config['api-key'] || env_config['api-key']
+
+            @http_proxy_host = config['http-proxy-host']
+            @http_proxy_port = config['http-proxy-port']
+            @http_proxy_username = config['http-proxy-username']
+            @http_proxy_password = config['http-proxy-password']
+            @http_open_timeout = config['http-open-timeout']
+            @http_read_timeout = config['http-read-timeout'] 
+
+            @ssl = config['ssl'] || env_config['ssl']
+            @enabled = env_config['enabled']
+            @remote_port = config['remote-port'].to_i unless config['remote-port'].nil?
+            @remote_host = config['remote-host'] unless config['remote-host'].nil?
+          rescue Exception => e
+            raise ConfigurationException.new("Unable to load configuration #{config_file} for environment #{application_environment} : #{e.message}")
+          end
+        end
+      end
+
+      def log_key
+        return @log_key unless @log_key.nil?
+        @log_key ||= ENV['LOGGR_LOG_KEY'] unless ENV['LOGGR_LOG_KEY'].nil?
+      end
+
+      def api_key
+        return @api_key unless @api_key.nil?
+        @api_key ||= ENV['LOGGR_API_KEY'] unless ENV['LOGGR_API_KEY'].nil?
+      end
+
+      def application_environment
+        ENV['RACK_ENV'] || ENV['RAILS_ENV']|| 'development'
+      end
+
+      def should_send_to_api?
+        return @enabled unless @enabled.nil?
+        @enabled = !(DEFAULTS[:disabled_by_default].include?(application_environment))
+      end
+
+      def application_root
+        (defined?(Rails) && Rails.respond_to?(:root)) ? Rails.root : Dir.pwd
+      end
+
+      def ssl?
+        @ssl ||= DEFAULTS[:ssl]
+      end
+
+      def remote_host
+        @remote_host ||= DEFAULTS[:remote_host_http]
+      end
+
+      def remote_port
+        @remote_port ||= ssl? ? 443 : 80
+      end
+
+      def reset
+        @enabled = @ssl = @remote_host = @remote_port = @api_key = nil
+      end
+
+      def http_open_timeout
+        @http_open_timeout ||= DEFAULTS[:http_open_timeout]
+      end
+
+      def http_read_timeout
+        @http_read_timeout ||= DEFAULTS[:http_read_timeout]
+      end
+    end
+  end
+end

data/lib/loggr-rb/events.rb

@@ -0,0 +1,169 @@
+module Loggr
+  class Events
+    def self.create(callback=nil)
+      return FluentEvent.new(callback)
+    end
+
+    def self.create_from_exception(ex, request=nil, callback=nil)
+	  source = ""
+	  begin
+        if !request.nil?
+	      if !request.parameters.nil?
+            controller = request.params['controller'].camelize
+	        action = request.params['action']
+	        if !controller.nil?
+	          source = controller.camelize + "Controller"
+              if !action.nil?
+                source = source + "#" + action.camelize
+              end
+            end
+	      end
+	    end
+	  rescue
+	  # no source
+	  end
+	  ip = ""
+	  if !request.nil?
+	    ip = (request.respond_to?(:remote_ip) ? request.remote_ip : request.ip)
+	  end
+	  ev = self.create(callback)
+      ev.text("Exception '#{ex.message}'")
+      ev.tags("error")
+      ev.add_tags(ex.class)
+      ev.data(Loggr::ExceptionData.format_exception(ex, request))
+      ev.datatype(DataType::HTML)
+      ev.source(source)
+	  ev.geo_ip(ip)
+      return ev
+    end
+  end
+
+  class DataType
+    HTML = 0
+    PLAINTEXT = 1
+  end
+
+  class Event
+    attr_accessor :text, :source, :link, :data, :value, :tags, :geo, :datatype
+  end
+
+  class FluentEvent
+
+    def initialize(callback=nil)
+	  @callback = callback
+      @event = Event.new()
+    end
+
+    def post(async=true)
+	  if !@callback.nil?
+	    @callback.call(self)
+	  end
+      client = LogClient.new()
+      client.post(@event, async)
+    end
+
+    def text(text)
+      @event.text = self.assign_w_macros(text, @event.text)
+      return self
+    end
+
+    def textf(fmt, *args)
+      self.text(sprintf(fmt, args))
+      return self
+    end
+
+    def add_text(text)
+      @event.text = sprintf("%s%s", @event.text, text)
+      return self
+    end
+
+    def add_textf(fmt, *args)
+      self.add_text(sprintf(fmt, args))
+      return self
+    end
+
+    def source(text)
+      @event.source = self.assign_w_macros(text, @event.source)
+      return self
+    end
+
+    def sourcef(fmt, *args)
+      self.source(sprintf(fmt, args))
+    end
+
+    def link(text)
+      @event.link = self.assign_w_macros(text, @event.link)
+      return self
+    end
+
+    def linkf(fmt, *args)
+      self.link(sprintf(fmt, args))
+    end
+
+    def data(text)
+      @event.data = self.assign_w_macros(text, @event.data)
+      return self
+    end
+
+    def dataf(fmt, *args)
+      self.data(sprintf(fmt, args))
+    end
+
+    def add_data(text)
+      @event.data = sprintf("%s%s", @event.data, text)
+      return self
+    end
+
+    def add_dataf(fmt, *args)
+      self.add_data(sprintf(fmt, args))
+      return self
+    end
+
+    def value(val)
+      @event.value = val
+      return self
+    end
+
+    def value_clear()
+      @event.value = nil
+      return self
+    end
+
+    def tags(tags)
+      @event.tags = tags
+      return self
+    end
+
+    def add_tags(tags)
+      @event.tags = sprintf("%s %s", @event.tags, tags)
+      return self
+    end
+
+    def datatype(t)
+      @event.datatype = t
+      return self
+    end
+
+    def geo(lat, lon)
+      @event.geo = sprintf("%d,%d", lat, lon)
+      return self
+    end
+
+    def geo_ip(ip)
+      @event.geo = sprintf("ip:%s", ip)
+      return self
+    end
+
+    def geo_clear()
+      @event.geo = nil
+      return self
+    end
+
+    def assign_w_macros(input, base)
+      if base.nil?
+        base = ""
+      end
+      return input.gsub("$$", base)
+    end
+  end
+end

data/lib/loggr-rb/exceptiondata.rb

@@ -0,0 +1,49 @@
+require 'digest/md5'
+
+module Loggr
+  class ExceptionData
+    def self.format_exception(ex, request=nil)
+	  res = ""
+
+	  # basic info
+      res = res + sprintf("<b>Exception</b>: %s<br />", ex.message)
+      res = res + sprintf("<b>Type</b>: %s<br />", ex.class)
+      res = res + sprintf("<b>Machine</b>: %s<br />", get_hostname)
+      res = res + sprintf("<b>Language</b>: ruby %s<br />", language_version_string)
+      res = res + "<br />"
+
+	  # web details
+	  if !request.nil?
+	    res = res + sprintf("<b>Request URL</b>: %s<br />", (request.respond_to?(:url) ? request.url : "#{request.protocol}#{request.host}#{request.request_uri}"))
+	    res = res + sprintf("<b>User</b>: %s<br />", get_username)
+	    res = res + sprintf("<b>User host address</b>: %s<br />", (request.respond_to?(:remote_ip) ? request.remote_ip : request.ip))
+	    res = res + sprintf("<b>Request Method</b>: %s<br />", request.request_method.to_s)
+	    res = res + sprintf("<b>User Agent</b>: %s<br />", request.env['HTTP_USER_AGENT'] || '')
+	    res = res + sprintf("<b>Referer</b>: %s<br />", request.env['HTTP_REFERER'] || '')
+	    res = res + sprintf("<b>Script Name</b>: %s<br />", request.env['SCRIPT_NAME'] || '')
+	    res = res + "<br />"
+	  end
+
+	  # stack
+      res = res + "<b>Stack Trace</b><br />"
+	  res = res + (ex.backtrace || []).join("<br/>")
+
+	  return res
+	end
+
+    def self.get_hostname
+      require 'socket' unless defined?(Socket)
+      Socket.gethostname
+    rescue
+      'UNKNOWN'
+    end
+
+    def self.language_version_string
+      "#{RUBY_VERSION rescue '?.?.?'} p#{RUBY_PATCHLEVEL rescue '???'} #{RUBY_RELEASE_DATE rescue '????-??-??'} #{RUBY_PLATFORM rescue '????'}"
+    end
+
+    def self.get_username
+      ENV['LOGNAME'] || ENV['USER'] || ENV['USERNAME'] || ENV['APACHE_RUN_USER'] || 'UNKNOWN'
+    end
+  end
+end

data/lib/loggr-rb/http.rb

@@ -0,0 +1,32 @@
+require 'net/http'
+
+module Net
+  class HTTP < Protocol
+    # pasted first half of HTTP.request that writes the request to the server,
+    # does not return HTTPResponse and does not take a block
+    def request_async(req, body = nil)
+      if proxy_user()
+        unless use_ssl?
+          req.proxy_basic_auth proxy_user(), proxy_pass()
+        end
+      end
+
+      req.set_body_internal body
+      begin_transport req
+      req.exec @socket, @curr_http_version, edit_path(req.path)
+    end
+
+    # second half of HTTP.request that yields or returns the response
+    def read_response(req, body = nil, &block)  # :yield: +response+
+      begin
+        res = HTTPResponse.read_new(@socket)
+      end while res.kind_of?(HTTPContinue)
+      res.reading_body(@socket, req.response_body_permitted?) {
+        yield res if block_given?
+      }
+      end_transport req, res
+
+      res
+    end
+  end
+end

data/lib/loggr-rb/integration/dj.rb

@@ -0,0 +1,12 @@
+begin
+  class Delayed::Job
+    def log_exception_with_loggr(e)
+      Loggr.handle(e, "Delayed::Job #{self.name}")
+      log_exception_without_loggr(e)
+      Loggr.context.clear!
+    end
+    alias_method_chain :log_exception, :loggr
+    Loggr.logger.info "DJ integration enabled"
+  end
+rescue
+end

data/lib/loggr-rb/integration/rack.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'rack'
+
+module Rack  
+  class Loggr    
+
+    def initialize(app, api_key = nil)
+      @app = app
+      if api_key.nil?
+        loggr_config = "config/loggr.yml"
+        ::Loggr::Config.load(loggr_config)
+      else
+        ::Loggr.configure(api_key)
+        ::Loggr::Config.enabled = true
+        ::Loggr.logger.info "Enabling Loggr for Rack"
+      end
+    end    
+    
+    def call(env)
+      begin
+        status, headers, body =  @app.call(env)
+      rescue Exception => e
+        ::Loggr::Catcher.handle_with_rack(e,env, Rack::Request.new(env))
+        raise(e)
+      end
+    end
+  end
+end

data/lib/loggr-rb/integration/rack_rails.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'rack'
+
+module Rack  
+  class RailsLoggr    
+
+    def initialize(app)
+      @app = app
+    end    
+    
+    def call(env)
+      begin
+        body = @app.call(env)
+      rescue Exception => e
+        ::Loggr::Catcher.handle_with_controller(e,env['action_controller.instance'], Rack::Request.new(env))
+        raise
+      end
+
+      if env['rack.exception']
+        ::Loggr::Catcher.handle_with_controller(env['rack.exception'],env['action_controller.instance'], Rack::Request.new(env))
+      end
+
+      body
+    end      
+  end
+end

data/lib/loggr-rb/integration/rails.rb

@@ -0,0 +1,27 @@
+# force Rails < 2.0 to use quote keys as per the JSON standard...
+if defined?(ActiveSupport) && defined?(ActiveSupport::JSON) && ActiveSupport::JSON.respond_to?(:unquote_hash_key_identifiers)
+  ActiveSupport::JSON.unquote_hash_key_identifiers = false
+end
+
+if defined? ActionController
+  module ActionController
+    class Base
+      def rescue_action_with_loggr(exception)
+        unless exception_handled_by_rescue_from?(exception)
+          Loggr::Catcher.handle_with_controller(exception, self, request)
+          Loggr.context.clear!
+        end
+        rescue_action_without_loggr exception
+      end
+
+      alias_method :rescue_action_without_loggr, :rescue_action
+      alias_method :rescue_action, :rescue_action_with_loggr
+      protected :rescue_action
+
+      private
+      def exception_handled_by_rescue_from?(exception)
+        respond_to?(:handler_for_rescue) && handler_for_rescue(exception)
+      end
+    end
+  end
+end

data/lib/loggr-rb/integration/sinatra.rb

@@ -0,0 +1,6 @@
+if defined? Sinatra::Request
+  error do
+    Loggr::Catcher.handle_with_rack(request.env['sinatra.error'], request.env, request)
+    raise request.env['sinatra.error']
+  end
+end

data/lib/loggr-rb/integration/tester.rb

@@ -0,0 +1,13 @@
+module Loggr
+  module Integration
+    class LoggrTestException <StandardError;
+    end
+
+    def self.test
+	  Loggr::Events.create().text("Test event").tags("test").source("loggr-rb-#{Loggr::VERSION}").post()
+	  puts "Test Event sent. Please login to http://loggr.net to see it!"
+    end
+  end
+end
+
+

data/lib/loggr-rb/logclient.rb

@@ -0,0 +1,63 @@
+require 'loggr-rb/http'
+require 'uri'
+
+module Loggr
+  class LogClient
+    def post(e, async=true)
+      logkey = ::Loggr::Config.log_key
+	  if async == true
+	    call_remote_async("post.loggr.net", "/1/logs/#{logkey}/events", create_params(e))
+	  else
+	    call_remote("post.loggr.net", "/1/logs/#{logkey}/events", create_params(e))
+      end
+    end
+
+	def create_params(e)
+      apikey = ::Loggr::Config.api_key
+	  params = {"apikey" => apikey, "text" => e.text}
+	  params = params.merge({"link" => e.link}) if !e.link.nil?
+	  params = params.merge({"tags" => e.tags}) if !e.tags.nil?
+	  params = params.merge({"source" => e.source}) if !e.source.nil?
+	  params = params.merge({"geo" => e.geo}) if !e.geo.nil?
+	  params = params.merge({"value" => e.value}) if !e.value.nil?
+	  if e.datatype == DataType::HTML
+	    params = params.merge({"data" => sprintf("@html\r\n%s", e.data)}) if !e.data.nil?
+	  else
+	    params = params.merge({"data" => e.data}) if !e.data.nil?
+	  end
+	  return params
+	end
+
+    def call_remote(host, path, params)
+      http = Net::HTTP.new(host)
+      req = Net::HTTP::Get.new(path)
+      data = params.collect { |k, v| "#{k}=#{v}&" }.join
+      http.start
+      begin
+        http.request_async(req, data)
+		res = http.read_response(req)
+      rescue Exception => e
+        Loggr.logger.error('Problem notifying Loggr about the event')
+        Loggr.logger.error(e)
+      ensure
+        http.finish
+      end
+      res.value # raise if error
+    end
+
+    def call_remote_async(host, path, params)
+      http = Net::HTTP.new(host)
+      req = Net::HTTP::Get.new(path)
+      data = params.collect { |k, v| "#{k}=#{v}&" }.join
+      http.start
+      begin
+        http.request_async(req, data)
+      rescue Exception => e
+        Loggr.logger.error('Problem notifying Loggr about the event')
+        Loggr.logger.error(e)
+      ensure
+        http.finish
+      end
+    end
+  end
+end

data/lib/loggr-rb/logfactory.rb

@@ -0,0 +1,39 @@
+require 'logger'
+
+module Loggr
+  class LogFactory
+    def self.logger
+      @logger ||= create_logger_with_fallback
+    end
+
+    private
+    def self.create_logger_with_fallback
+      begin
+        log_dir = File.join(Config.application_root, 'log')
+        Dir.mkdir(log_dir) unless File.directory?(log_dir)
+        log_path = File.join(log_dir, "/loggr.log")
+        log = Logger.new(log_path)
+        log.level = Logger::INFO
+        def log.format_message(severity, timestamp, progname, msg)
+          "[#{severity.upcase}] (#{[Kernel.caller[2].split('/').last]}) #{timestamp.utc.to_s} - #{msg2str(msg).gsub(/\n/, '').lstrip}\n"
+        end
+        def log.msg2str(msg)
+          case msg
+            when ::String
+              msg
+            when ::Exception
+              "#{ msg.message } (#{ msg.class }): " <<
+                (msg.backtrace || []).join(" | ")
+            else
+              msg.inspect
+          end
+        end
+        log
+      rescue
+        return Rails.logger if defined?(Rails) && defined?(Rails.logger)
+        return RAILS_DEFAULT_LOGGER if defined?(RAILS_DEFAULT_LOGGER)
+        return Logger.new(STDERR)
+      end
+    end
+  end
+end

data/lib/loggr-rb/railtie.rb

@@ -0,0 +1,19 @@
+require 'loggr-rb'
+require 'rails'
+
+module Loggr
+  class Railtie < Rails::Railtie
+
+    initializer "loggr.middleware" do |app|
+
+      config_file = File.join(Rails.root, "/config/loggr.yml")
+      Loggr::Config.load config_file if File.exist?(config_file)
+      # On Heroku config is loaded via the ENV so no need to load it from the file
+
+      if Loggr::Config.should_send_to_api?
+        Loggr.logger.info("Loading Loggr #{Loggr::VERSION} for #{Rails::VERSION::STRING}")
+        app.config.middleware.use "Rack::RailsLoggr"
+      end
+    end
+  end
+end

data/lib/loggr-rb/version.rb

@@ -0,0 +1,3 @@
+module Loggr
+  VERSION = '1.0.5'
+end

data/lib/tasks/exceptional_tasks.rake

@@ -0,0 +1,11 @@
+namespace :exceptional do
+  desc 'Send a test exception to Exceptional.'
+  task :test => :environment do
+    unless Exceptional::Config.api_key.blank?
+      puts "Sending test exception to Exceptional."
+      require "exceptional/integration/tester"
+      Exceptional::Integration.test
+      puts "Done."
+    end
+  end
+end

data/lib/tasks/loggr_tasks.rake

@@ -0,0 +1,11 @@
+namespace :loggr do
+  desc 'Send a test event to Loggr.'
+  task :test => :environment do
+    unless Loggr::Config.api_key.blank?
+      puts "Sending test exception to Loggr."
+      require "loggr-rb/integration/tester"
+      Loggr::Integration.test
+      puts "Done."
+    end
+  end
+end

data/loggr-rb.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/loggr-rb/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name = %q{loggr-rb}
+  gem.version = Loggr::VERSION
+  gem.authors = ["Loggr.net"]
+  gem.summary = %q{ loggr.net is a hosted service for logging events in your Ruby/Rails/Rack apps }
+  gem.description = %q{loggr-rb is the Ruby gem for communicating with http://loggr.net (hosted logging service).}
+  gem.email = %q{info@loggr.net}
+  gem.files =  Dir['lib/**/*'] + Dir['rails/**/*'] + Dir['tasks/**/*'] + Dir['*.rb'] + ["loggr-rb.gemspec"]
+  gem.homepage = %q{http://loggr.net/}
+  gem.require_paths = ["lib"]
+  gem.executables << 'loggr'
+  gem.requirements << ""
+  gem.add_dependency 'rack'
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__) , '../init.rb')

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: loggr-rb
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 5
+  version: 1.0.5
+platform: ruby
+authors: 
+- Loggr.net
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-23 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: loggr-rb is the Ruby gem for communicating with http://loggr.net (hosted logging service).
+email: info@loggr.net
+executables: 
+- loggr
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/loggr-rb.rb
+- lib/loggr-rb/integration/tester.rb
+- lib/loggr-rb/integration/dj.rb
+- lib/loggr-rb/integration/rails.rb
+- lib/loggr-rb/integration/sinatra.rb
+- lib/loggr-rb/integration/rack_rails.rb
+- lib/loggr-rb/integration/rack.rb
+- lib/loggr-rb/config.rb
+- lib/loggr-rb/version.rb
+- lib/loggr-rb/logclient.rb
+- lib/loggr-rb/logfactory.rb
+- lib/loggr-rb/exceptiondata.rb
+- lib/loggr-rb/railtie.rb
+- lib/loggr-rb/events.rb
+- lib/loggr-rb/http.rb
+- lib/loggr-rb/catcher.rb
+- lib/tasks/loggr_tasks.rake
+- lib/tasks/exceptional_tasks.rake
+- rails/init.rb
+- init.rb
+- install.rb
+- loggr-rb.gemspec
+has_rdoc: true
+homepage: http://loggr.net/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: 
+- ""
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: loggr.net is a hosted service for logging events in your Ruby/Rails/Rack apps
+test_files: []
+