ramon 0.1.1 → 0.2.0

data/init.rb

@@ -1 +1,7 @@
+# Load the exception handler
+# Aplicable only for Rails apps
 require 'ramon'
+
+require File.join('amon', 'integration', 'rails')   
+
+Rails.configuration.middleware.use "Rack::RailsAmonException"

data/lib/ramon.rb

@@ -5,12 +5,19 @@ end
 require_local "version"
 require_local "logger"
 require_local "remote"
-require_local "exception_data"
+require_local "catcher"
+require_local  "exception_data"
+require_local  "controller_exception_data"
+require_local  "enviroment_data"
 
 module Ramon
 	def self.log(message, level=nil)
 		log_hash = Log.log(message, level)
 		Remote.post('log', log_hash)
 	end
+
+	def self.post(type, data)
+		Remote.post(type, data)
+	end
 end
 

data/lib/ramon/catcher.rb

@@ -0,0 +1,20 @@
+module Ramon
+class Catcher
+	class << self
+	  
+	  def handle_with_controller(exception, controller=nil, request=nil)
+		  data = ControllerExceptionData.new(exception, controller, request)
+		  Ramon.post('exception', data)
+	  end
+	  
+	  def handle_with_rack(exception, environment, request) 
+		  data = RackExceptionData.new(exception, environment, request)
+	  end
+
+	  def handle(exception, name=nil)
+		  data = ExceptionData.new(exception, name)
+	  end
+
+	end
+end # class end
+end # module end

data/lib/ramon/config.rb

@@ -1,44 +1,44 @@
 require 'json'
 
 module Ramon
-	class Config
-		class ConfigurationException < StandardError; end
-		
-		class << self
-			DEFAULTS = {
-				:host => 'http://127.0.0.1',
-				:port => 2464
-			}
+class Config
+class ConfigurationException < StandardError; end
+	
+	class << self
+		DEFAULTS = {
+			:host => 'http://127.0.0.1',
+			:port => 2464
+		}
 
-			def load
-				config_file ||= "/etc/amon.conf"
+		def load
+			config_file ||= "/etc/amon.conf"
 
-				if File.file?(config_file)
-					begin
-						f = File.read(config_file)
-						config = JSON.parse(f)
+			if File.file?(config_file)
+				begin
+					f = File.read(config_file)
+					config = JSON.parse(f)
 
-						@app_key = config['application_key'] unless config['application_key'].nil?
-						@port = config['web_app']['port'].to_i unless config['web_app']['port'].nil?
-						@host = config['web_app']['host'].to_s unless config['web_app']['host'].nil?
+					@app_key = config['application_key'] unless config['application_key'].nil?
+					@port = config['web_app']['port'].to_i unless config['web_app']['port'].nil?
+					@host = config['web_app']['host'].to_s unless config['web_app']['host'].nil?
 
-					  rescue Exception => e
-						raise ConfigurationException.new("Unable to load configuration file: #{config_file}")
-					  end
-				else
-				  puts "Amon::Config.load - /etc/amon.conf not found"
-				end
+				  rescue Exception => e
+					raise ConfigurationException.new("Unable to load configuration file: #{config_file}")
+				  end
+			else
+			  puts "Amon::Config.load - /etc/amon.conf not found"
 			end
+		end
 
-			def port
-				@port ||= DEFAULTS[:port]
-			end
-			
-			def host
-				@host ||= DEFAULTS[:host]
-			end
+		def port
+			@port ||= DEFAULTS[:port]
+		end
+		
+		def host
+			@host ||= DEFAULTS[:host]
+		end
 
-		end # self end
-		load
-	end # Config end 
+	end # self end
+	load
+end # Config end 
 end # Module end

data/lib/ramon/controller_exception_data.rb

@@ -0,0 +1,59 @@
+require 'digest/md5'
+
+module Ramon
+class ControllerExceptionData < ExceptionData
+	def initialize(exception, controller=nil, request=nil)
+	  super(exception)
+	  @request = request
+	  @controller = controller
+	end
+
+	def framework
+	  "rails"
+	end
+
+	def additional_data                                                                                               
+	  return {} if @request.nil?
+	  {
+		'request' => {
+		  'url' => (@request.respond_to?(:url) ? @request.url : "#{@request.protocol}#{@request.host}#{@request.request_uri}"),
+		  'controller' => @controller.class.to_s,
+		  'action' => (@request.respond_to?(:parameters) ? @request.parameters['action'] : @request.params['action']),
+		  'parameters' => filter_paramaters(@request.respond_to?(:parameters) ? @request.parameters : @request.params),
+		  'request_method' => @request.request_method.to_s,
+		  'remote_ip' => (@request.respond_to?(:remote_ip) ? @request.remote_ip : @request.ip),
+		  #'headers' => extract_http_headers(@request.env),
+		  'session' => self.class.sanitize_session(@request)
+		 }
+	 }
+	end
+
+	def filter_hash(keys_to_filter, hash)
+	  if keys_to_filter.is_a?(Array) && !keys_to_filter.empty?
+		hash.each do |key, value|
+		  if value.respond_to?(:to_hash)
+			filter_hash(keys_to_filter, hash[key])
+		  elsif key_match?(key, keys_to_filter)
+			hash[key] = "[FILTERED]"
+		  end
+		end
+	  end
+	  hash
+	end
+
+	def key_match?(key, keys_to_filter)
+	  keys_to_filter.map {|k| k.to_s}.include?(key.to_s)
+	end
+
+	def filter_paramaters(hash)                                                                                       
+	  if @request.respond_to?(:env) && @request.env["action_dispatch.parameter_filter"]
+		filter_hash(@request.env["action_dispatch.parameter_filter"], hash)
+	  elsif @controller.respond_to?(:filter_parameters)
+		@controller.send(:filter_parameters, hash)
+	  else
+		hash
+	  end
+	end
+
+end # class end
+end # module end

data/lib/ramon/enviroment_data.rb

@@ -0,0 +1,39 @@
+require 'digest/md5'
+
+module Ramon
+class ApplicationEnvironment
+    def self.to_hash(framework)
+      {
+          'language' => 'ruby',
+          'language_version' => language_version_string,
+          'framework' => framework,
+          #'libraries_loaded' => libraries_loaded
+      }
+    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
+
+    def self.libraries_loaded
+      begin
+        return Hash[*Gem.loaded_specs.map{|name, gem_specification| [name, gem_specification.version.to_s]}.flatten]
+      rescue
+      end
+      {}
+    end
+
+end # class end
+end # module end

data/lib/ramon/exception_data.rb

@@ -0,0 +1,99 @@
+module Ramon
+class ExceptionData 
+	
+	def initialize(exception, name=nil)
+	  @exception = exception
+	  @name = name
+	end
+
+	def to_hash
+	  hash = {}
+	  # We need the url before the main exception info
+	  hash['data'] = additional_data
+
+	  hash.merge!({  
+		  'exception_class' => @exception.class.to_s,
+		  'message' => @exception.message,
+		  'backtrace' => @exception.backtrace, 
+		  'url' => hash['data']['request']['url']
+	  })
+
+	  hash['data'].merge!(ApplicationEnvironment.to_hash(framework))
+	  hash['data'].merge!(context_stuff)
+	  hash['data'].merge!(extra_stuff)
+	  self.class.sanitize_hash(hash)
+	end
+
+	def extra_stuff
+	  if @name
+		 {'name' => @name}
+	  else
+		  {}
+	  end
+	end
+
+	def context_stuff
+	  context = Thread.current[:exceptional_context]
+	  (context.nil? || context.empty?) ? {} : {'context' => context}
+	end
+
+	def framework
+	  nil
+	end    
+	
+	
+	def self.sanitize_hash(hash)
+			
+	  case hash
+		when Hash
+		  hash.inject({}) do |result, (key, value)|            
+			result.update(key => sanitize_hash(value))
+		  end
+		when Array
+		  hash.collect{|value| sanitize_hash(value)}
+		when Fixnum, String, Bignum
+		  hash
+		else
+		  hash.to_s
+	  end
+	rescue Exception => e
+	  {}
+	end
+
+	def extract_http_headers(env)
+	  headers = {}
+	  env.select{|k, v| k =~ /^HTTP_/}.each do |name, value|
+		proper_name = name.sub(/^HTTP_/, '').split('_').map{|upper_case| upper_case.capitalize}.join('-')
+		headers[proper_name] = value
+	  end
+	  unless headers['Cookie'].nil?
+		headers['Cookie'] = headers['Cookie'].sub(/_session=\S+/, '_session=[FILTERED]')
+	  end
+	  headers
+	end  
+  
+	def self.sanitize_session(request)
+	  
+	  session_hash = {'session_id' => "", 'data' => {}}
+
+	  if request.respond_to?(:session)      
+		
+		session = request.session
+		session_hash['session_id'] = request.session_options ? request.session_options[:id] : nil
+		session_hash['session_id'] ||= session.respond_to?(:session_id) ? session.session_id : session.instance_variable_get("@session_id")
+		session_hash['data'] = session.respond_to?(:to_hash) ? session.to_hash : session.instance_variable_get("@data") || {}
+		session_hash['session_id'] ||= session_hash['data'][:session_id]
+		session_hash['data'].delete(:session_id)
+	  end
+	
+	  # Don't return the session hash if there is nothing in it
+	  if session_hash['session_id'].nil? && session_hash['data'].empty?
+		  {}
+	  else
+		self.sanitize_hash(session_hash)
+	  end 
+
+	end  
+
+end # class end
+end # module end

data/lib/ramon/integration/rails.rb

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

data/lib/ramon/logger.rb

@@ -1,13 +1,13 @@
 module Ramon
-	class Log
-		def self.log(message, level)
-			level ||= 'notset'
-			log = {"message" => message, "level" => level}
-			
-			log
-		end
+class Log
+	def self.log(message, level)
+		level ||= 'notset'
+		log = {"message" => message, "level" => level}
+		
+		log
 	end
-end
+end # class end
+end # module end
 
 
 

data/lib/ramon/remote.rb

@@ -4,20 +4,20 @@ require 'zlib'
 require "#{File.dirname(__FILE__)}/config"
 
 module Ramon
-	class Remote
-		def self.post(type, data)
+class Remote
+	def self.post(type, data)
 
-			if type == 'log':
-				@url = '/api/log'
-			else
-				@url = '/api/exception'
-			end
-
-			req = Net::HTTP::Post.new(@url, initheader = {'Content-Type' =>'application/json'})
-			#req.body = Zlib::Deflate.deflate(data.to_json, Zlib::BEST_SPEED)
-			req.body = data.to_json
-			response = Net::HTTP.new(Config::host, Config::port).start {|http| http.request(req) }
-			#puts "Response #{response.code} #{response.message}: #{response.body}"
+		if type == 'log':
+			@url = '/api/log'
+		else
+			@url = '/api/exception'
 		end
-	end # class end
+
+		req = Net::HTTP::Post.new(@url, initheader = {'Content-Type' =>'application/json'})
+		#req.body = Zlib::Deflate.deflate(data.to_json, Zlib::BEST_SPEED)
+		req.body = data.to_json
+		response = Net::HTTP.new(Config::host, Config::port).start {|http| http.request(req) }
+		#puts "Response #{response.code} #{response.message}: #{response.body}"
+	end
+end # class end
 end # module end 

data/lib/ramon/version.rb

@@ -1,3 +1,3 @@
 module Ramon
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/rails/init.rb

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

data/ramon.gemspec

@@ -1,15 +1,14 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "ramon/version"
+require File.expand_path('../lib/ramon/version', __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "ramon"
   s.version     = Ramon::VERSION
   s.authors     = ["martinrusev"]
-  s.email       = ["martinrusev@zoho.com"]
+  s.email       = ["martin@amon.cx"]
   s.homepage    = "http://amon.cx"
   s.summary     = %q{Ruby binding for Amon}
-  s.description = %q{Amon client that provides logging and exception handling}
+  s.description = %q{Amon client for Ruby that provides logging and exception handling for web applications}
 
   s.rubyforge_project = "ramon"
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ramon
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - martinrusev
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-09 00:00:00 +00:00
+date: 2011-11-14 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,9 +32,9 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id001
-description: Amon client that provides logging and exception handling
+description: Amon client for Ruby that provides logging and exception handling for web applications
 email: 
-- martinrusev@zoho.com
+- martin@amon.cx
 executables: []
 
 extensions: []
@@ -47,11 +47,16 @@ files:
 - Rakefile
 - init.rb
 - lib/ramon.rb
+- lib/ramon/catcher.rb
 - lib/ramon/config.rb
+- lib/ramon/controller_exception_data.rb
+- lib/ramon/enviroment_data.rb
 - lib/ramon/exception_data.rb
+- lib/ramon/integration/rails.rb
 - lib/ramon/logger.rb
 - lib/ramon/remote.rb
 - lib/ramon/version.rb
+- rails/init.rb
 - ramon.gemspec
 has_rdoc: true
 homepage: http://amon.cx