excepty 0.0.6

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YTZlMjU1Y2JmMmRjZmIxZmMzZjQ2YThlMmU2ZDQzMmI5YjQwNzg1Mg==
+  data.tar.gz: !binary |-
+    MzkwNDRjYTIxZTMxNTdkYmM2M2FjN2U4MWRiNmYzZmQ0ZjE1MmNkZQ==
+SHA512:
+  metadata.gz: !binary |-
+    Yzk5MDlhY2ZkNjhmZDI2Y2IxZmZmMGRiM2IwNjE5YWU5OGM5MWYxN2YwODNk
+    YzViMWQ3YzcxYTYzMmUxZGQ5ZDdjMzA3YjFmZTdiZjc1NTE5ZDk1NDE3NjBm
+    YWFmYzcxNjgxYWNhODczNTcwYzY4MzYxMjIwNTIzYmM1MWYyZjc=
+  data.tar.gz: !binary |-
+    MWEyZDlkMThmOTRlZWVmOTgwNjRlYjYyNzUzOGY4ZWUzYjg1NTZmMmJiOGI5
+    NjZmZWI5MWY5MGFkNWMwNzk3ZGYwNGZmZjhiYjVlZGQxNGYyNzIxYjZlMmIy
+    NjM5MjhhMzFjOWE5MmZkZjY0NTM2YTMwMGJhMWQwNTI5MjMzMzc=

data/bin/excepty

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+

data/excepty.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+#require File.expand_path('../lib/excepty/version', __FILE__)
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'excepty/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "excepty"
+  gem.version       = Excepty::VERSION
+  gem.authors       = ["Excepty"]
+  gem.email         = ["gem@excepty.com"]
+  gem.description   = %q{T ODO: Write a gem description} #TODO
+  gem.summary       = %q{T ODO: Write a gem summary} #TODO
+  gem.homepage      = "http://www.excepty.com/"
+
+  #gem.files         = `git ls-files`.split($/)
+  gem.files =  Dir['lib/**/*'] + Dir['*.rb'] + ["excepty.gemspec"]
+  # + Dir['spec/**/*'] + Dir['spec/**/*'] + Dir['rails/**/*'] + Dir['tasks/**/*']
+  
+  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.executables << 'excepty'
+  #gem.rubyforge_project = %q{excepty}
+  #gem.requirements << "json_pure, json-jruby or json gem required"
+  
+end

data/lib/excepty.rb

@@ -0,0 +1,19 @@
+EXCEPTY_IN_TESTING_MODE = false
+
+require "excepty/version"
+
+require 'excepty/manager'
+require 'excepty/settings'
+require 'excepty/analyzer'
+require 'excepty/connector'
+require 'excepty/exception_interceptor'
+
+
+require 'excepty/railtie' if defined?(Rails) && defined?(Rails::Railtie)
+
+
+module Excepty
+  
+  # Your code goes here...
+  
+end

data/lib/excepty/analyzer.rb

@@ -0,0 +1,10 @@
+require 'excepty/analyzers/enviroment'
+require 'excepty/analyzers/error'
+
+module Excepty
+  module Analyzer
+    def self.example
+      #Excepty::Manager.logga Enviroment.get_struct
+    end
+  end
+end

data/lib/excepty/analyzers/enviroment.rb

@@ -0,0 +1,138 @@
+
+module Excepty
+  module Analyzer
+    class Enviroment
+      
+      def self.get_struct( my_env = nil )
+        my_env = ENV if my_env.blank?
+        return_struct = {}
+        begin
+          return_struct['env'] = get_env( my_env )
+        rescue Exception => e
+          Excepty::Manager.logga "exception (get_struct-get_env)"
+          begin
+            Excepty::Manager.logga e
+            return_struct['env'] = 'EXCEPTION'
+            #return_struct['env'] = my_env
+          rescue Exception => e
+          end
+        end
+        begin
+          return_struct['rack_env'] = my_env['RACK_ENV']
+          return_struct['rails_env'] = my_env['RAILS_ENV']
+          return_struct['host'] = begin Socket.gethostname; rescue Exception => e; 'UNKNOWN' end
+        rescue Exception => e
+        end
+        begin
+          return_struct['root_folder'] = Rails.root
+          return_struct['root_folder_dir_pwd'] = Dir.pwd
+        
+          return_struct['ruby_version'] = RUBY_VERSION
+          return_struct['ruby_pathlevel'] = begin RUBY_PATCHLEVEL; rescue Exception => e; 'EXCEPTION' end
+          return_struct['ruby_release_date'] = begin RUBY_RELEASE_DATE; rescue Exception => e; 'EXCEPTION' end
+          return_struct['ruby_platform'] = begin RUBY_PLATFORM; rescue Exception => e; 'EXCEPTION' end
+          return_struct['root_folder_bis'] = begin RAILS_ROOT; rescue Exception => e; 'EXCEPTION' end
+        rescue Exception => e
+        end
+        begin
+          #return_struct['libraries_loaded_keys'] = Gem.loaded_specs.keys
+          return_struct['libraries_loaded_all'] = Gem.loaded_specs.values.map{|x| "#{x.name} (#{x.version})"}
+        rescue Exception => e
+        end
+        
+        return return_struct
+      end
+      
+      
+      private
+      
+      def self.get_env( my_env )
+        env = {}
+        #Excepty::Manager.logga "before each" if EXCEPTY_IN_TESTING_MODE
+        my_env.each do |key, value|
+          #Excepty::Manager.logga "each: #{ key }" if EXCEPTY_IN_TESTING_MODE
+          if env[key].blank?
+            env = get_hash( env, key, value)
+          else
+            begin
+              env["other"] = {} if env["other"].blank?
+              env["other"][key] = value.to_json
+            rescue Exception => e
+              Excepty::Manager.logga "exp" if EXCEPTY_IN_TESTING_MODE
+            end
+          end
+        end
+        return env
+      end
+      
+      def self.get_hash( env, key, value )
+        #TODO da testare
+        key_arr = key.split(".")
+        if key_arr.size == 1
+          env["#{key}"] = get_value( value )
+        else
+          #Excepty::Manager.logga "else" if EXCEPTY_IN_TESTING_MODE
+          new_key = key_arr.shift()
+          #Excepty::Manager.logga "new_key: #{new_key}  key_arr: #{ key_arr.join(".") }" if EXCEPTY_IN_TESTING_MODE
+          env[new_key] = {} if env[new_key].blank?
+          unless env[new_key].is_a? Hash
+            tmp = env[new_key]
+            env[new_key] = {}
+            env[new_key]["excepty_value_not_hash"] = tmp
+          end
+          env["#{new_key}"] = get_hash( env[new_key], key_arr.join("."), value )
+        end
+        return env
+      end
+      
+      def self.get_value( value )
+        begin        
+          case value
+          when String, Fixnum, Integer, Bignum
+            return value
+          when NilClass
+            return nil
+          when Array, Hash
+            return value
+          when ApplicationController
+            return value.class.to_s
+          
+            #TODO dividere con un altro switch compreso tra try e catch
+          when ActionDispatch::RemoteIp::GetIp
+            return value.to_s
+          when FalseClass, TrueClass
+            return value.to_s
+            #when ActionDispatch::Routing::RouteSet
+            #Excepty::Manager.logga value.router
+            #return value.class.to_s
+          when StringIO
+            if EXCEPTY_IN_TESTING_MODE
+              Excepty::Manager.logga "StringIO"
+              Excepty::Manager.logga value.string
+              Excepty::Manager.logga value.to_json
+            end
+            return value.string
+          else
+            Excepty::Manager.logga "value.class => #{ value.class.to_s }" if EXCEPTY_IN_TESTING_MODE
+            return value.class.to_s
+          end
+        rescue Exception => e
+          Excepty::Manager.logga "EXCEPTY-exception (get_value)" if EXCEPTY_IN_TESTING_MODE
+          return "EXCEPTY-exception (get_value)"
+        end
+      end
+=begin
+      TODO
+      value.class => StringIO
+      value.class => IO
+      value.class => ActionDispatch::Routing::RouteSet
+      value.class => ActiveSupport::TaggedLogging
+      value.class => Rails::BacktraceCleaner
+      value.class => ActionDispatch::RemoteIp::GetIp
+      value.class => ActionDispatch::Cookies::CookieJar
+=end
+      
+      
+    end
+  end
+end

data/lib/excepty/analyzers/error.rb

@@ -0,0 +1,20 @@
+module Excepty
+  module Analyzer
+    class Error
+      
+      def self.get_struct( exception, env )
+        return_struct = {}
+        
+        return_struct["exception_class"] = exception.class.to_s
+        return_struct["message"] = exception.message.to_s
+        return_struct["backtrace"] = exception.backtrace
+        
+        return return_struct
+      end
+      
+      private
+      
+      
+    end
+  end
+end

data/lib/excepty/analyzers/repositoy.rb

@@ -0,0 +1,7 @@
+module Excepty
+  module Analyzer
+    class Repository
+      
+    end
+  end
+end

data/lib/excepty/analyzers/request.rb

@@ -0,0 +1,7 @@
+module Excepty
+  module Analyzer
+    class Request
+      
+    end
+  end
+end

data/lib/excepty/connector.rb

@@ -0,0 +1,61 @@
+require 'zlib'
+require 'base64'
+require 'net/http'
+require 'net/https'
+require 'uri'
+#require 'json'
+
+
+#http://apidock.com/ruby/Net/HTTP
+
+module Excepty
+  Excepty::Manager.logga "Excepty - Settings - 2" if EXCEPTY_IN_TESTING_MODE
+  class Connector
+    def self.call( url, data = {}, extra_params = nil)
+      arr = []
+      arr.push( "key=#{ Excepty::Settings.config[:key] }" )
+      arr.push( "pv=#{ Excepty::Settings::PROTOCOL_VERSION }" )
+      arr += extra_params.map{ |k,v| "#{k.to_s}=#{v.to_s}" } unless extra_params.blank?
+      url_with_params = url.to_s + "?#{ arr.join("&") }"
+      data_compressed = Zlib::Deflate.deflate( data.to_json, Zlib::BEST_SPEED )
+      data_formatted = Base64.encode64( data_compressed )
+      return start_call( url_with_params, data_formatted )
+    end
+    
+    
+    private
+    
+    def self.start_call( url, data )
+      config = Excepty::Settings.config
+      proxy_settings = Net::HTTP::Proxy( config[:proxy_host], config[:proxy_port], config[:proxy_user], config[:proxy_pass] )      
+      conn = proxy_settings.new(config[:server_host], config[:server_port])
+      if !config[:ssl].blank? && ( config[:ssl] == true || config[:ssl].to_s == 'true' )
+        conn.use_ssl = true
+        conn.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      else
+        conn.use_ssl = false
+      end
+      conn.open_timeout = config[:open_timeout]
+      conn.read_timeout = config[:read_timeout]
+      begin
+        data_to_sent = URI.encode(data)
+        response = conn.post(url, data_to_sent)
+        Excepty::Manager.logga "ricevuto qualcosa" if EXCEPTY_IN_TESTING_MODE
+        case response
+        when Net::HTTPSuccess
+          Excepty::Manager.logga "successofull" if EXCEPTY_IN_TESTING_MODE
+          data = JSON.parse( response.body )
+          return { 'status' => response.code, 'data' => data }
+        else
+          Excepty::Manager.logga "NOOOOOOO successofull" if EXCEPTY_IN_TESTING_MODE
+          return { 'status' => response.code, 'data' => nil }
+        end
+      rescue Exception => e
+        Excepty::Manager.logga "Exceptionnnnnnnn" if EXCEPTY_IN_TESTING_MODE
+        Excepty::Manager.logga e if EXCEPTY_IN_TESTING_MODE
+        return { 'status' => -1, 'data' => nil }
+      end
+    end
+    
+  end
+end

data/lib/excepty/exception_interceptor.rb

@@ -0,0 +1,28 @@
+module Excepty
+  module ExceptionInterceptor
+    
+    def self.included(base)
+      base.send( :alias_method_chain, :render_exception, :excepty )
+      Excepty::Manager.logga "Excepty - ExceptionInterceptor - included" if EXCEPTY_IN_TESTING_MODE
+    end
+
+    def render_exception_with_excepty( env, exception )
+      Excepty::Manager.logga "Excepty - ExceptionInterceptor - render_exception_with_excepty" if EXCEPTY_IN_TESTING_MODE
+      begin
+        Excepty::Manager.analyse_exception( env, exception )
+      rescue Exception => e
+        Excepty::Manager.logga "EXCEPTION" if EXCEPTY_IN_TESTING_MODE
+        Excepty::Manager.logga e if EXCEPTY_IN_TESTING_MODE
+        Excepty::Manager.logga "e.class" if EXCEPTY_IN_TESTING_MODE
+        Excepty::Manager.logga e.class if EXCEPTY_IN_TESTING_MODE
+        Excepty::Manager.logga "e.message" if EXCEPTY_IN_TESTING_MODE
+        Excepty::Manager.logga e.message if EXCEPTY_IN_TESTING_MODE
+        Excepty::Manager.logga "e.backtrace" if EXCEPTY_IN_TESTING_MODE
+        Excepty::Manager.logga e.backtrace if EXCEPTY_IN_TESTING_MODE
+      end
+      
+      render_exception_without_excepty( env, exception )
+    end
+    
+  end
+end

data/lib/excepty/manager.rb

@@ -0,0 +1,148 @@
+require 'logger'
+
+module Excepty
+  class Manager
+    @@excepty_session_id = nil
+    @@excepty_session_id_bis
+    EXCEPTY_SESSION_FILE_NAME = "tmp/excepty.sid"
+    EXCEPTY_LOGGER_FILE_NAME = "excepty.log"
+    EXCEPTY_DEFAULT_LOG_LEVEL = Logger::INFO
+
+
+    cattr_accessor :logger
+    
+    
+    self.logger = if defined?(Rails)
+      Rails.logger
+    elsif defined?(EXCEPTY_DEFAULT_LOG_LEVEL)
+      EXCEPTY_DEFAULT_LOG_LEVEL
+    else
+      nil
+    end
+
+
+    def self.start()
+      self.logger ||= Logger.new( File.join( Rails.root, "log", EXCEPTY_LOGGER_FILE_NAME ) )
+      
+      logga( "Manager: - start" ) if EXCEPTY_IN_TESTING_MODE
+      
+      app_env = get_env_struct()
+      gem_info = get_gem_info_struct()
+      app_info = get_app_info_struct()
+      
+      struct_to_send = { app_env: app_env, gem_info: gem_info, app_info: app_info }
+      begin struct_to_send["time_now"] = Time.now.utc; rescue Exception => e; end
+      #struct_to_send = {}
+      returned_obj = Excepty::Connector.call( "/collector/start", struct_to_send )
+      if returned_obj['status'].to_i == 200
+        @@excepty_session_id = returned_obj['data']['reload_id']
+        @@excepty_session_id_bis = @@excepty_session_id
+        File.delete( EXCEPTY_SESSION_FILE_NAME ) if File::exists?( "file.rb" )
+        file = File.new( EXCEPTY_SESSION_FILE_NAME, "w" )
+        file.puts @@excepty_session_id
+        file.close
+        logga "Dir.tmpdir: #{ Dir.tmpdir }" if EXCEPTY_IN_TESTING_MODE
+        message_response = "Excepty - connetted"
+        logga "@@excepty_session_id: #{@@excepty_session_id}" if EXCEPTY_IN_TESTING_MODE
+        logga "self.excepty_session_id: #{ self.excepty_session_id }" if EXCEPTY_IN_TESTING_MODE
+      else
+        #TODO vedere che fare
+        message_response = "Excepty - NOT connetted"
+      end
+      begin
+        logga(message_response)
+        Rails.logger.info(message_response)
+      rescue Exception => e
+      end
+      logga "@@excepty_session_id: #{@@excepty_session_id}" if EXCEPTY_IN_TESTING_MODE
+      logga "self.excepty_session_id: #{ self.excepty_session_id }" if EXCEPTY_IN_TESTING_MODE
+    end    
+    
+    def self.analyse_exception( env, exception )
+      logga "Excepty - Exception detected"
+      app_env = get_env_struct( env )
+      gem_info = get_gem_info_struct()
+      exc_info = get_exception_struct( exception, env )
+      struct_to_send = { app_env: app_env, gem_info: gem_info, exc_info: exc_info }
+      begin struct_to_send["time_now"] = Time.now.utc; rescue Exception => e; end
+      #@@excepty_session_id = nil
+      if @@excepty_session_id.blank?
+        logga "allora @@excepty_session_id.blank" if EXCEPTY_IN_TESTING_MODE
+        #self.start()
+        file = File.new( EXCEPTY_SESSION_FILE_NAME, "r" )
+        if file
+           content = file.sysread(20)
+           logga content if EXCEPTY_IN_TESTING_MODE
+           logga "LEGGGGGOOOOO"
+           logga "LEGGGGGOOOOO"
+           logga "LEGGGGGOOOOO"
+           @@excepty_session_id = content.to_i
+         end
+      end
+      logga "@@excepty_session_id: #{@@excepty_session_id}" if EXCEPTY_IN_TESTING_MODE
+      logga "self.excepty_session_id: #{ self.excepty_session_id }" if EXCEPTY_IN_TESTING_MODE
+      begin
+        logga "@@@@excepty_session_id_bis: #{ @@excepty_session_id_bis }" if EXCEPTY_IN_TESTING_MODE
+      rescue Exception => e
+      end
+      begin
+        returned_obj = Excepty::Connector.call( "/collector/error", struct_to_send, { session_id: ( @@excepty_session_id || self.excepty_session_id ) } )
+        logga "Excepty - Exception sent"
+      rescue Exception => e
+        logga "Excepty - Exception NOT sent"
+      end
+    end
+    
+    def self.excepty_session_id
+      @@excepty_session_id
+    end
+    
+    def self.logga(text, level = EXCEPTY_DEFAULT_LOG_LEVEL)
+      text = "[Excepty(#{name})] #{text}"
+      logger.add level, "#{Time.now.strftime('%FT%T%z')}: #{text}" if logger
+    end
+    
+    
+    private
+    
+    def self.get_gem_info_struct()
+      gem_info = nil
+      begin
+        gem_info = { name: "excepty", version: Excepty::VERSION, protocol_version: Excepty::Settings::PROTOCOL_VERSION }
+      rescue Exception => e
+      end
+      return gem_info
+    end
+    
+    def self.get_app_info_struct()
+      gem_settings = nil
+      begin
+        gem_settings = Excepty::Settings.get_struct
+      rescue Exception => e
+      end
+      return gem_settings
+    end
+    
+    def self.get_env_struct( env = nil )
+      app_env = nil
+      begin
+        app_env = Excepty::Analyzer::Enviroment.get_struct( env )
+      rescue Exception => e
+        logga "Exception - Excepty::Analyzer::Enviroment.get_struct" if EXCEPTY_IN_TESTING_MODE
+      end
+      return app_env
+    end
+    
+    def self.get_exception_struct( exception, env )
+      exc_info = nil
+      begin
+        exc_info = Excepty::Analyzer::Error.get_struct( exception, env )
+      rescue Exception => e
+        logga "exceptiodfdfs"
+        logga e
+      end
+      return exc_info
+    end
+    
+  end
+end

data/lib/excepty/railtie.rb

@@ -0,0 +1,38 @@
+require 'excepty'
+require 'rails'
+
+#http://edgeapi.rubyonrails.org/classes/Rails/Railtie.html
+
+module Excepty
+  class Railtie < Rails::Railtie
+    initializer "excepty.middleware" do |app|
+      config_yml_file = File.join( Rails.root, "/config/excepty.yml" )
+      Excepty::Settings.configure_with_file( config_yml_file )
+      Excepty::Manager.logga "EXCEPTY - Maybe We Ara in!!" if EXCEPTY_IN_TESTING_MODE
+      Excepty::Manager.logga "nome #{ Excepty::Settings.config[:app_name] }" if EXCEPTY_IN_TESTING_MODE
+      
+      #Excepty::Manager.logga "ANALIZER"
+      #Excepty::Manager.logga Excepty::Analyzer::Enviroment.get_struct
+      #Excepty::Manager.logga Excepty::Analyzer.example
+      
+      Excepty::Manager.start()
+      
+      if Excepty::Settings.can_catch_exceptions?
+        if defined?(ActionDispatch::DebugExceptions)
+          #rails 3.2.X
+          Excepty::Manager.logga "rails 3.2.X" if EXCEPTY_IN_TESTING_MODE
+          ActionDispatch::DebugExceptions.send(:include,Excepty::ExceptionInterceptor)
+        elsif defined?(ActionDispatch::ShowExceptions)
+          #rails 3.0.X -> 3.1.X
+          Excepty::Manager.logga "rails 3.0.X -> 3.1.X" if EXCEPTY_IN_TESTING_MODE
+        else
+          #rails ~ 2.X
+          Excepty::Manager.logga "rails ~ 2.X" if EXCEPTY_IN_TESTING_MODE
+        end
+        Excepty::Manager.logga "Excepty - exception module actived"
+      else
+        Excepty::Manager.logga "Excepty - exception module NOT actived"
+      end
+    end
+  end
+end

data/lib/excepty/settings.rb

@@ -0,0 +1,96 @@
+require 'yaml'
+require 'erb'
+
+#http://stackoverflow.com/questions/6233124/where-to-place-access-config-file-in-gem
+
+Excepty::Manager.logga "Excepty - Settings - 1" if EXCEPTY_IN_TESTING_MODE
+module Excepty
+  Excepty::Manager.logga "Excepty - Settings - 2" if EXCEPTY_IN_TESTING_MODE
+  class Settings
+    
+    PROTOCOL_VERSION = "1"
+    
+    Excepty::Manager.logga "Excepty - Settings - 3" if EXCEPTY_IN_TESTING_MODE
+    # Settings defaults
+    @config = {
+      # APP INFO
+      :key => "1A2B3C4D5E",
+      :app_name => "My Application",
+      
+      # DEBUGING
+      :enabled => true,
+      :releases_enabled => true,
+      :version_enabled => true,
+      
+      #SERVER
+      :server_host => "collector.excepty.com",
+      :server_port => 80,
+      
+      # CONNECTION
+      :ssl => false,
+      :proxy_host => nil, #hostname
+      :proxy_port => nil, #8080
+      :proxy_user => nil,
+      :proxy_pass => nil,
+      
+      :open_timeout => 4,
+      :read_timeout => 7
+    }
+    @valid_config_keys = @config.keys
+    
+    # Configure Settings through yaml file
+    def self.configure_with_file( config_yml_file )
+      #begin
+      if config_yml_file.blank? || !File.file?( config_yml_file )
+        #TODO what can I do or say?
+        Excepty::Manager.logga "BLANCO" if EXCEPTY_IN_TESTING_MODE
+        return
+      end
+      
+      Excepty::Manager.logga "Excepty - Settings - 5" if EXCEPTY_IN_TESTING_MODE
+      #begin
+      enviroment = ENV['RAILS_ENV'] || ENV['RACK_ENV']
+      config_yml = YAML::load( IO.read( config_yml_file ) )
+      #config_yml = YAML.load( ERB.new( File.new( config_yml_file ).read ).result )
+      config_yml_by_env = config_yml[enviroment] || {}
+      begin
+      rescue Errno::ENOENT
+        log(:warning, "YAML configuration file couldn't be found. Using defaults."); return
+      rescue Psych::SyntaxError
+        log(:warning, "YAML configuration file contains invalid syntax. Using defaults."); return
+      end
+      
+      #begin
+      #@config.each { |k,v| @config[k.to_sym] = config_yml_by_env[k.to_sym] || config_yml[k.to_sym] || v if @valid_config_keys.include? k.to_sym }
+      @config.each do |k,v|
+        @config[k.to_sym] = config_yml_by_env[k.to_s] || config_yml[k.to_s] || v if @valid_config_keys.include? k.to_sym
+      end
+      Excepty::Manager.logga "@config: #{@config.to_json}" if EXCEPTY_IN_TESTING_MODE
+      begin # <= lele
+      rescue Exception => e
+        log(:warning, "YAML Settings error in load yml file."); return
+      end
+    end
+    
+    def self.config
+      @config
+    end
+    
+    def self.can_catch_exceptions?
+      return true if EXCEPTY_IN_TESTING_MODE
+      return @config['enabled'] || true
+    end
+    
+    def self.get_struct
+      obj = {}
+      begin obj['app_name'] = @config[:app_name]; rescue Exception => e; end
+      begin obj['key'] = @config[:key]; rescue Exception => e; end
+      begin obj['webapp_name_by_env'] = ENV["APP_NAME"]; rescue Exception => e; end
+      begin obj['webapp_name'] = Rails.application.class.parent_name; rescue Exception => e; end
+      begin obj['webapp_name_class'] = Rails.application.class.to_s; rescue Exception => e; end
+      return obj
+    end
+    
+  end
+  
+end

data/lib/excepty/version.rb

@@ -0,0 +1,3 @@
+module Excepty
+  VERSION = "0.0.6"
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: excepty
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+platform: ruby
+authors:
+- Excepty
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-22 00:00:00.000000000 Z
+dependencies: []
+description: ! 'T ODO: Write a gem description'
+email:
+- gem@excepty.com
+executables:
+- excepty
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/excepty
+- excepty.gemspec
+- lib/excepty.rb
+- lib/excepty/analyzer.rb
+- lib/excepty/analyzers/enviroment.rb
+- lib/excepty/analyzers/error.rb
+- lib/excepty/analyzers/repositoy.rb
+- lib/excepty/analyzers/request.rb
+- lib/excepty/connector.rb
+- lib/excepty/exception_interceptor.rb
+- lib/excepty/manager.rb
+- lib/excepty/railtie.rb
+- lib/excepty/settings.rb
+- lib/excepty/version.rb
+homepage: http://www.excepty.com/
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.3.0
+signing_key: 
+specification_version: 4
+summary: ! 'T ODO: Write a gem summary'
+test_files: []