ramon 0.3.3 → 0.4.0

data/lib/ramon.rb

@@ -1,28 +1,71 @@
 def require_local(file)
-  require File.join(File.dirname(__FILE__), 'ramon', file)
+    require File.join(File.dirname(__FILE__), "ramon", file)
 end
 
-require_local "version"
-require_local "log_factory"
-require_local "remote"
-require_local "catcher"
+require_local  "version"
+require_local  "sender"
+require_local  "configuration"
+require_local  "catcher"
 require_local  "exception_data"
 require_local  "controller_exception_data"
 require_local  "enviroment_data"
 
-require_local 'integration/rails' if defined?(Rails)
-require_local 'railtie' if defined?(Rails)
+require_local  "integration/rails" if defined?(Rails)
+require_local  "railtie" if defined?(Rails)
 
 module Ramon
 
-	def self.log(message, tags=nil)
-		log_hash = Log.log(message, tags)
-		Remote.post('log', log_hash)
-	end
+    class << self
 
-	def self.post(type, data)
-		Remote.post(type, data)
-	end
+        # The sender object is responsible for delivering formatted data to the Amon server.
+        attr_accessor :sender
 
-end
+        # Ramon configuration object. Must act like a hash and return sensible
+        # values for all configuration options. 
+        attr_writer :configuration
+
+        # Call this method to modify defaults in your initializers.
+        #
+        # @example
+        #   Ramon.configure do |config|
+        #     config.app_key = '1234567890abcdef'
+        #     config.host  = 'http://127.0.0.1'
+        #     config.port  = 2464
+        #   end
+        def configure()
+            yield(configuration)
+            self.sender = Sender.new(configuration)
+            self.sender
+        end
+
+        # The configuration object.
+        # @see Ramon.configure
+        def configuration
+            @configuration ||= Configuration.new
+        end
+
+
+        # Look for the Rails logger currently defined
+        def logger
+            self.configuration.logger
+        end
+
+        def format_log(message, tags=nil)
+            tags ||= 'notset'
+            log = {"message" => message, "tags" => tags}
+            log 
+        end
+
+        def log(message, tags=nil)
+            log = format_log(message, tags)
+            sender.post('log', log)
+        end
+
+        def post(type, data)
+            sender.post(type, data)
+        end
+
+    end # self end 
+
+end # module end
 

data/lib/ramon/catcher.rb

@@ -1,22 +1,22 @@
 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)
-		  Ramon.post('exception', data)
-	  end
+    class Catcher
+        class << self
 
-	  def handle(exception, name=nil)
-		  data = ExceptionData.new(exception, name)
-		  Ramon.post('exception', data)
-	  end
+            def handle_with_controller(exception, controller=nil, request=nil)
+                data = ControllerExceptionData.new(exception, controller, request)
+                Ramon.post('exception', data)
+            end
 
-	end
-end # class end
+            def handle_with_rack(exception, environment, request) 
+                data = RackExceptionData.new(exception, environment, request)
+                Ramon.post('exception', data)
+            end
+
+            def handle(exception, name=nil)
+                data = ExceptionData.new(exception, name)
+                Ramon.post('exception', data)
+            end
+
+        end
+    end # class end
 end # module end

data/lib/ramon/configuration.rb

@@ -0,0 +1,63 @@
+module Ramon
+    class Configuration
+        class ConfigurationException < StandardError; end
+        OPTIONS = [:app_key, :host, :port, :secret,
+            :environment_name, :framework, :project_root].freeze
+
+        # The Aplication key. Only in Amon Plus.
+        attr_accessor :app_key
+
+        # Secret key, used for securely logging in the normal Amon version
+        attr_accessor :secret
+
+        # The host to connect to (defaults to 127.0.0.1).
+        attr_accessor :host
+
+        # The port on which your Amon instance runs. Defaults to 2464
+        attr_accessor :port
+
+        # The name of the environment the application is running in
+        attr_accessor :environment_name
+
+        # The path to the project in which the error occurred, such as the RAILS_ROOT
+        attr_accessor :project_root
+
+        # The framework Ramon is configured to use
+        attr_accessor :framework
+
+        # The logger used by Amon
+        attr_accessor :logger
+
+        def initialize
+            @host                     = 'http://127.0.0.1'
+            @port                     = 2464
+            @app_key                  = ''
+            @secret                   = ''
+            @framework                = 'Standalone'
+        end
+
+
+        # Allows config options to be read like a hash
+        #
+        # @param [Symbol] option Key for a given attribute
+        def [](option)
+            send(option)
+        end
+
+        # Returns a hash of all configurable options
+        def to_hash
+            OPTIONS.inject({}) do |hash, option|
+                hash.merge(option.to_sym => send(option))
+            end
+        end
+
+        # Returns a hash of all configurable options merged with +hash+
+        #
+        # @param [Hash] hash A set of configuration options that will take precedence over the defaults
+        def merge(hash)
+            to_hash.merge(hash)
+        end
+
+
+    end # Class end
+end # Module end

data/lib/ramon/controller_exception_data.rb

@@ -1,59 +1,59 @@
 require 'digest/md5'
 
 module Ramon
-class ControllerExceptionData < ExceptionData
-	def initialize(exception, controller=nil, request=nil)
-	  super(exception)
-	  @request = request
-	  @controller = controller
-	end
+    class ControllerExceptionData < ExceptionData
+        def initialize(exception, controller=nil, request=nil)
+            super(exception)
+            @request = request
+            @controller = controller
+        end
 
-	def framework
-	  "rails"
-	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 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 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 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
+        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 # class end
 end # module end

data/lib/ramon/enviroment_data.rb

@@ -1,37 +1,37 @@
 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
+    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_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.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
+        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

@@ -1,99 +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
+    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/railtie.rb

@@ -6,6 +6,17 @@ class Railtie < Rails::Railtie
     initializer "amon.middleware" do |app|
         app.config.middleware.use "Rack::RailsAmonException"
     end
-end
-end
+
+
+    config.after_initialize do
+      Ramon.configure do |config|
+        config.logger           ||= ::Rails.logger
+        config.environment_name ||= ::Rails.env
+        config.project_root     ||= ::Rails.root
+        config.framework        = "Rails: #{::Rails::VERSION::STRING}"
+      end
+    end
+
+end # class end
+end # module end
 

data/lib/ramon/sender.rb

@@ -0,0 +1,65 @@
+require 'net/http'
+require 'json'
+require 'zlib'
+
+module Ramon
+    class Sender
+        def initialize(options = {})
+            [ :host, 
+                :port, 
+                :app_key,
+                :secret
+            ].each do |option|
+                instance_variable_set("@#{option}", options[option])
+            end
+        end
+
+
+        attr_reader :host,
+            :port,
+            :app_key,
+            :secret
+
+        def log(level, message)
+            logger.send level, '** Amon '+ message
+		end
+
+
+        def logger
+            Ramon.logger
+        end
+
+
+        def url
+            URI.parse("#{host}:#{port}/api/")
+        end
+
+        def post(type, data)
+
+            if type == 'log'
+                @url = "#{url}log/#{app_key}"
+            else
+                @url = "#{url}exception/#{app_key}"
+            end
+
+            request = Net::HTTP::Post.new(@url, initheader = {'Content-Type' =>'application/json'})
+            request.body = data.to_json
+
+            begin
+                response = Net::HTTP.new(url.host, url.port).start {|http| http.request(request) }
+                case response
+                when Net::HTTPSuccess
+                    log :error, "#{@url} - #{response.message}"
+                    return response
+                else
+                    log :error, "#{@url} - #{response.code} - #{response.message}"
+                end
+            rescue Exception => e
+                log :error, "[Ramon::Sender#post] Cannot send data to #{@url} Error: #{e.class} - #{e.message}"
+                nil 
+            end
+
+        end
+
+    end # Class end 
+end # Module end

data/lib/ramon/version.rb

@@ -1,3 +1,3 @@
 module Ramon
-  VERSION = "0.3.3"
+  VERSION = "0.4.0"
 end

data/spec/config_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+module Ramon
+describe Configuration do
+
+ it "should provide default values" do
+    config = Ramon::Configuration.new
+    config.port.should == 2464
+    config.host.should == 'http://127.0.0.1'
+  end
+
+end
+end # end module

data/spec/{logger_spec.rb → log_spec.rb}

@@ -1,40 +1,40 @@
 require 'spec_helper'
 
 module Ramon
-describe Log do
+describe "log" do
 	
 	it "should return a hash with tags - debug and message - test" do
-		@log = Log.log('test', 'debug')
+		@log = Ramon.format_log('test', 'debug')
 		@log.should == {"tags" => "debug", "message" => "test"}
 	end
 
 	it "should return a hash with tags - info and message - test" do
-		@log = Log.log('test', 'info')
+		@log = Ramon.format_log('test', 'info')
 		@log.should == {"tags" => "info", "message" => "test"}
 	end
 	
 	it "should return a hash with tags - notset and message - test" do
-		@log = Log.log('test')
+		@log = Ramon.format_log('test')
 		@log.should == {"tags" => "notset", "message" => "test"}
 	end
 	
 	it "should return a hash with tags - notset and a message hash" do
-		@log = Log.log({:test => "test value", :more => "even more value"})
+		@log = Ramon.format_log({:test => "test value", :more => "even more value"})
 		@log.should == {"tags" => "notset", "message"=>{:more=>"even more value", :test=>"test value"}}
 	end
 	
 	it "should return a hash with tags - debug and a message hash" do
-		@log = Log.log({:test => "test value", :more => "even more value"},'debug')
+		@log = Ramon.format_log({:test => "test value", :more => "even more value"},'debug')
 		@log.should == {"tags" => "debug", "message"=>{:more=>"even more value", :test=>"test value"}}
 	end
 	
 	it "should return a hash with tags - notset and a message array" do
-		@log = Log.log([1,2,3,4])
+		@log = Ramon.format_log([1,2,3,4])
 		@log.should == {"tags" => "notset", "message"=>[1,2,3,4]}
 	end
 
 	it "should return an array with tags - debug, benchmark and a message string" do
-		@log = Log.log("test", ["debug", "benchmark"])
+		@log = Ramon.format_log("test", ["debug", "benchmark"])
 		@log.should == {"tags" => ["debug", "benchmark"], "message"=>"test"}
 	end
 

data/spec/web_spec.rb

@@ -1,22 +1,30 @@
 require 'spec_helper'
 
-# Works only when the Amon application is started
-describe 'Web app test' do
+module Ramon
+    # Works only when the Amon application is started
+    describe 'Web app test' do
 
-	it 'Test logging' do
-		Ramon.log([1,2,3,4]).response.code.should == "200"
-		Ramon.log({:test => 'data', :more_test => 'more_data'}).response.code.should == "200"
-	end	
-	
-	it 'Test logging with multiple tags' do
-		Ramon.log("test", ['debug', 'benchmark']).response.code.should == "200"
-		Ramon.log({:test => 'data', :more_test => 'more_data'}, ['info','warning','user']).response.code.should == "200"
-	end
+        it 'Test logging' do
 
+            Ramon.configure do |config|
+                config.host  = 'http://127.0.0.1'
+                config.port  = 2464
+            end
+            
+            Ramon.log([1,2,3,4]).response.code.should == "200"
+            Ramon.log({:test => 'data', :more_test => 'more_data'}).response.code.should == "200"
+        end	
 
-	it 'Test Exceptions' do
-		Ramon.post('exception', {:url => 'test', :exception_class => 'test_me'}).response.code.should == "200"
-	end
+        it 'Test logging with multiple tags' do
+            Ramon.log("test", ['debug', 'benchmark']).response.code.should == "200"
+            Ramon.log({:test => 'data', :more_test => 'more_data'}, ['info','warning','user']).response.code.should == "200"
+        end
 
-end
+
+        it 'Test Exceptions' do
+            Ramon.post('exception', {:url => 'test', :exception_class => 'test_me'}).response.code.should == "200"
+        end
+
+    end
+end 
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ramon
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 3
-  version: 0.3.3
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - martinrusev
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-03 00:00:00 +00:00
+date: 2012-02-23 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -47,21 +47,19 @@ files:
 - Rakefile
 - lib/ramon.rb
 - lib/ramon/catcher.rb
-- lib/ramon/config.rb
+- lib/ramon/configuration.rb
 - lib/ramon/controller_exception_data.rb
 - lib/ramon/enviroment_data.rb
 - lib/ramon/exception_data.rb
 - lib/ramon/integration/rails.rb
-- lib/ramon/log_factory.rb
 - lib/ramon/railtie.rb
-- lib/ramon/remote.rb
+- lib/ramon/sender.rb
 - lib/ramon/version.rb
 - ramon.gemspec
 - spec/config_spec.rb
 - spec/exception_data_spec.rb
-- spec/logger_spec.rb
+- spec/log_spec.rb
 - spec/rails_integration_spec.rb
-- spec/remote_spec.rb
 - spec/spec_helper.rb
 - spec/web_spec.rb
 has_rdoc: true

data/lib/ramon/config.rb

@@ -1,48 +0,0 @@
-require 'json'
-
-module Ramon
-class Config
-class ConfigurationException < StandardError; end
-	
-	class << self
-		DEFAULTS = {
-			:host => '127.0.0.1',
-			:port => 2464
-		}
-
-		def load
-			config_file ||= "/etc/amon.conf"
-
-			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?
-
-				  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 application_root
-			(defined?(Rails) && Rails.respond_to?(:root)) ? Rails.root : Dir.pwd
-		end
-
-		def port
-			@port ||= DEFAULTS[:port]
-		end
-		
-		def host
-			@host ||= DEFAULTS[:host]
-		end
-
-	end # self end
-	load
-end # Config end 
-end # Module end

data/lib/ramon/log_factory.rb

@@ -1,46 +0,0 @@
-require 'logger'
-require 'date'
-
-module Ramon
-class Log
-	
-	def self.log(message, tags=nil)
-		tags ||= 'notset'
-		log = {"message" => message, "tags" => tags}
-		
-		log
-	end
-
-end # class end
-
-# Used internally
-class LogFactory
-
-	def self.log
-		@logger ||= define_internal_logger
-	end
-	
-	private
-	def self.define_internal_logger
-        log_dir = File.join(Config.application_root, 'log')
-        Dir.mkdir(log_dir) unless File.directory?(log_dir)
-        log_path = File.join(log_dir, "/ramon.log")
-        
-		log = Logger.new(log_path)
-        log.level = Logger::INFO
-
-		log.formatter = proc do |severity, datetime, progname, msg|
-			"#{datetime}: #{msg} -- #{severity}\n"
-		end
-
-		log
-	end
-
-end # class end
-
-end # module end
-
-
-
-
-

data/lib/ramon/remote.rb

@@ -1,35 +0,0 @@
-require 'net/http'
-require 'json'
-require 'zlib'
-require "#{File.dirname(__FILE__)}/config"
-
-module Ramon
-class Remote
-	def self.post(type, data)
-
-		if type == 'log'
-			@url = '/api/log'
-		else
-			@url = '/api/exception'
-		end
-
-		request = Net::HTTP::Post.new(@url, initheader = {'Content-Type' =>'application/json'})
-		request.body = data.to_json
-
-		begin
-		  response = Net::HTTP.new(Config::host, Config::port).start {|http| http.request(request) }
-          case response
-            when Net::HTTPSuccess
-              LogFactory.log.info( "#{@url} - #{response.message}")
-              return response
-            else
-              LogFactory.log.error("#{@url} - #{response.code} - #{response.message}")
-          end
-        rescue Exception => e
-          LogFactory.log.error(e)
-        end
-
-	end
-end # class end
-end # module end 
-