appygram 0.1.0

data/appygram.gemspec

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/appygram/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name = %q{appygram}
+  gem.version = Appygram::VERSION
+  gem.authors = ["rfc2616"]
+  gem.summary = %q{ appygram is a hosted service for sending messages from mobile/web apps }
+  gem.description = %q{Appygram is the Ruby gem for communicating with http://appygram.com (hosted messaging service). It supports an exception reporting mechanism similar to http://exceptional.io, and this Ruby gem, forked from the Exceptional gem, emulates Exceptional functionality.}
+  gem.email = %q{heittman.rob@gmail.com}
+  gem.files =  Dir['lib/**/*'] + Dir['spec/**/*'] + Dir['spec/**/*'] + Dir['rails/**/*'] + Dir['tasks/**/*'] + Dir['*.rb'] + ["appygram.gemspec"]
+  gem.homepage = %q{http://appygram.com/}
+  gem.require_paths = ["lib"]
+  gem.requirements << "json_pure, json-jruby or json gem required"
+  gem.add_dependency 'rack'
+end

data/init.rb

@@ -0,0 +1,39 @@
+require 'appygram'
+
+# 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?(Appygram::VERSION::STRING) rescue nil) && %w(development test).include?(RAILS_ENV)
+  message = %Q(
+  ***********************************************************************
+  You seem to still have an old version of the Appygram plugin installed.
+  Remove it from /vendor/plugins and try again.
+  ***********************************************************************
+  )
+  puts message
+  exit -1
+else
+  begin
+
+    if (Rails::VERSION::MAJOR < 3)    
+      Appygram::Config.load(File.join(RAILS_ROOT, "/config/Appygram.yml"))
+      if Appygram::Config.should_send_to_api?
+        Appygram.logger.info("Loading Appygram #{Appygram::VERSION} for #{Rails::VERSION::STRING}")      
+        require File.join('Appygram', 'integration', 'rails')    
+        require File.join('Appygram', 'integration', 'dj') if defined?(Delayed::Job)
+      end
+    else
+      Appygram::Config.load(File.join(Rails.root, "/config/Appygram.yml"))
+      
+      if Appygram::Config.should_send_to_api?
+        Appygram.logger.info("Loading Appygram #{Appygram::VERSION} for #{Rails::VERSION::STRING}")      
+        Rails.configuration.middleware.use "Rack::RailsAppygram"
+        require File.join('Appygram', 'integration', 'dj') if defined?(Delayed::Job)
+      end      
+    end
+  rescue => e
+    STDERR.puts "Problem starting Appygram Plugin. Your app will run as normal. #{e.message}"
+    Appygram.logger.error(e.message)
+    Appygram.logger.error(e.backtrace)
+  end
+end

data/lib/appygram/alert_data.rb

@@ -0,0 +1,15 @@
+module Appygram
+  class AlertData < ExceptionData
+    # Overwrite backtrace, since it is irrelevant
+    def extra_data
+      {
+        'exception' => {
+          'exception_class' => @exception.class.to_s,
+          'message' => @exception.message,
+          'backtrace' => "",
+          'occurred_at' => Time.now
+        }
+      }
+    end
+  end
+end

data/lib/appygram/application_environment.rb

@@ -0,0 +1,63 @@
+require 'digest/md5'
+
+module Appygram
+  class ApplicationEnvironment
+    def self.to_hash(framework)
+      {
+        'client' => {
+          'name' => Appygram::CLIENT_NAME,
+          'version' => Appygram::VERSION,
+          'protocol_version' => Appygram::PROTOCOL_VERSION
+        },
+        'application_environment' => {
+          'environment' => environment,
+          'env' => extract_environment(ENV),
+          'host' => get_hostname,
+          'run_as_user' => get_username,
+          'application_root_directory' => (application_root.to_s.respond_to?(:force_encoding) ? application_root.to_s.force_encoding("UTF-8") : application_root),
+          'language' => 'ruby',
+          'language_version' => language_version_string,
+          'framework' => framework,
+          'libraries_loaded' => libraries_loaded
+        }
+      }
+    end
+
+    def self.environment
+      Config.application_environment
+    end
+
+    def self.application_root
+      Config.application_root
+    end
+
+    def self.extract_environment(env)
+      env.reject do |k, v|
+        (k =~ /^HTTP_/) || Appygram::ENVIRONMENT_FILTER.include?(k)
+      end
+    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
+end

data/lib/appygram/catcher.rb

@@ -0,0 +1,34 @@
+module Appygram
+  class Catcher
+    class << self
+      def handle_with_controller(exception, controller=nil, request=nil)
+        if Config.should_send_to_api?
+          data = ControllerExceptionData.new(exception, controller, request)
+          Remote.error(data)
+        else
+          raise exception
+        end
+      end
+      
+      # unspeced
+      def handle_with_rack(exception, environment, request) 
+        if Config.should_send_to_api?
+          data = RackExceptionData.new(exception, environment, request)
+          Remote.error(data)
+        else
+          raise exception
+        end
+      end
+
+      # unspeced
+      def handle(exception, name=nil)
+        if Config.should_send_to_api?
+          data = ExceptionData.new(exception, name)
+          Remote.error(data)
+        else
+          raise exception
+        end
+      end
+    end
+  end
+end

data/lib/appygram/config.rb

@@ -0,0 +1,87 @@
+require 'yaml'
+
+module Appygram
+  class Config
+    class ConfigurationException < StandardError; end
+
+    class << self
+      DEFAULTS = {
+        :ssl => false,
+        :remote_host_http => 'api.appygram.com',
+        :http_open_timeout => 2,
+        :http_read_timeout => 4,
+        :disabled_by_default => %w(development test)
+      }
+
+      attr_accessor :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] || {}
+            @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 api_key
+        return @api_key unless @api_key.nil?
+        @api_key ||= ENV['EXCEPTIONAL_API_KEY'] unless ENV['EXCEPTIONAL_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/appygram/controller_exception_data.rb

@@ -0,0 +1,65 @@
+require 'digest/md5'
+
+module Appygram
+  class ControllerExceptionData < ExceptionData
+    def initialize(exception, controller=nil, request=nil)
+      super(exception)
+      @request = request
+      @controller = controller
+    end
+
+    def framework
+      "rails"
+    end
+
+    def extra_stuff                                                                                               
+      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_parameters(@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)
+      keys_to_filter.map! {|x| x.to_s}
+      if keys_to_filter.is_a?(Array) && !keys_to_filter.empty?
+        hash.each do |key, value|
+          if key_match?(key, keys_to_filter)
+            hash[key] = "[FILTERED]"
+          elsif value.respond_to?(:to_hash)
+            filter_hash(keys_to_filter, hash[key])
+          end
+        end
+      end
+      hash
+    end
+
+    # Closer alignment to latest filtered_params:
+    # https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/http/parameter_filter.rb
+    # https://github.com/exceptional/exceptional/issues/20
+    def key_match?(key, keys_to_filter)
+      keys_to_filter.any? { |k|
+        regexp = k.is_a?(Regexp)? k : Regexp.new(k, true)
+        key =~ regexp
+      }
+    end
+
+    def filter_parameters(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
+end

data/lib/appygram/exception_data.rb

@@ -0,0 +1,108 @@
+require 'digest/md5'
+require 'time'
+
+module Appygram
+  class ExceptionData 
+    
+    def initialize(exception, name=nil)
+      @exception = exception
+      @name = name
+    end
+
+    def to_hash
+      hash = ::Appygram::ApplicationEnvironment.to_hash(framework)
+      hash.merge!({
+        'exception' => {
+          'exception_class' => @exception.class.to_s,
+          'message' => @exception.message,
+          'backtrace' => @exception.backtrace,
+          'occurred_at' => Time.now.utc.iso8601
+        }
+      })
+      hash.merge!(extra_stuff)
+      hash.merge!(context_stuff)
+      self.class.sanitize_hash(hash)
+    end
+
+    def extra_stuff
+      { 'rescue_block' => { 'name' => @name} }
+    end
+
+    def context_stuff
+      context = Thread.current[:appygram_context]
+      (context.nil? || context.empty?) ? {} : {'context' => context}
+    end
+
+    def to_json
+      begin
+        to_hash.to_json
+      rescue NoMethodError
+        begin
+          require 'json'
+          return to_hash.to_json
+        rescue StandardError => e                   
+          Appygram.logger.error(e.message)
+          Appygram.logger.error(e.backtrace)                    
+          raise StandardError.new("You need a json gem/library installed to send errors to Appygram (Object.to_json not defined). \nInstall json_pure, yajl-ruby, json-jruby, or the c-based json gem")
+        end
+      end
+    end
+    
+    def framework
+      nil
+    end    
+
+    def uniqueness_hash
+      return nil if (@exception.backtrace.nil? || @exception.backtrace.empty?)
+      Digest::MD5.hexdigest(@exception.backtrace.join)
+    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
+      Appygram.logger.error(hash)
+      Appygram.logger.error(e.message)
+      Appygram.logger.error(e.backtrace)      
+      {}
+    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
+
+      self.sanitize_hash(session_hash)
+    end  
+  end
+end

data/lib/appygram/integration/alerter.rb

@@ -0,0 +1,11 @@
+module Appygram
+  class Alert <StandardError;
+  end
+
+  module Integration
+    def self.alert(msg, env={})
+      return Appygram::Remote.error(Appygram::AlertData.new(Alert.new(msg), "Alert"))
+    end
+  end
+end
+

data/lib/appygram/integration/debug_exceptions.rb

@@ -0,0 +1,16 @@
+module Appygram
+  module DebugExceptions
+
+    def self.included(base)
+      base.send(:alias_method_chain,:render_exception,:appygram)
+    end
+
+    def render_exception_with_appygram(env,exception)
+      ::Appygram::Catcher.handle_with_controller(exception,
+                                                    env['action_controller.instance'],
+                                                    Rack::Request.new(env))
+      render_exception_without_appygram(env,exception)
+    end
+
+  end
+end

data/lib/appygram/integration/dj.rb

@@ -0,0 +1,15 @@
+if Delayed::Worker.method_defined? :handle_failed_job
+  class Delayed::Worker
+    def handle_failed_job_with_appygram(job, e)
+      Appygram.handle(e, "Delayed::Job #{job.name}")
+      handle_failed_job_without_appygram(job, e)
+      Appygram.context.clear!
+    end
+    alias_method_chain :handle_failed_job, :appygram
+    Appygram.logger.info "DJ integration enabled"
+  end
+else
+  message = "\n\n\nThe Appygram gem does not support Delayed Job 1.8.4 or earlier.\n\n\n"
+  STDERR.puts(message)
+  Appygram.logger.error(message)
+end

data/lib/appygram/integration/rack.rb

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

data/lib/appygram/integration/rack_rails.rb

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

data/lib/appygram/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_appygram(exception)
+        unless exception_handled_by_rescue_from?(exception)
+          Appygram::Catcher.handle_with_controller(exception, self, request)
+          Appygram.context.clear!
+        end
+        rescue_action_without_appygram exception
+      end
+
+      alias_method :rescue_action_without_appygram, :rescue_action
+      alias_method :rescue_action, :rescue_action_with_appygram
+      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/appygram/integration/sinatra.rb

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

data/lib/appygram/log_factory.rb

@@ -0,0 +1,39 @@
+require 'logger'
+
+module Appygram
+  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, "/appygram.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/appygram/monkeypatches.rb

@@ -0,0 +1,10 @@
+class Regexp
+  def to_json(options = {})
+    "\"#{self.to_s}\""
+  end
+end
+class Fixnum
+  def to_json(options = {})
+    to_s
+  end
+end

data/lib/appygram/rack_exception_data.rb

@@ -0,0 +1,29 @@
+require 'digest/md5'
+
+module Appygram
+  class RackExceptionData < ExceptionData
+    def initialize(exception, environment, request)
+      super(exception)                  
+      @environment = environment
+      @request = request
+    end
+
+    def framework
+      "rack"
+    end
+
+    def extra_stuff
+      return {} if @request.nil?
+      {
+        'request' => {
+          'url' => "#{@request.url}",                       
+          'parameters' => @request.params,
+          'request_method' => @request.request_method.to_s,
+          'remote_ip' => @request.ip,
+          'headers' => extract_http_headers(@environment),
+          'session' => self.class.sanitize_session(@request)
+        }
+      }
+    end
+  end
+end

data/lib/appygram/railtie.rb

@@ -0,0 +1,23 @@
+require 'appygram'
+require 'rails'
+
+module Appygram
+  class Railtie < Rails::Railtie
+
+    initializer "appygram.middleware" do |app|
+
+      config_file = File.join(Rails.root, "/config/appygram.yml")
+      Appygram::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 Appygram::Config.should_send_to_api?
+        Appygram.logger.info("Loading Appygram #{Appygram::VERSION} for #{Rails::VERSION::STRING}")
+        if defined?(ActionDispatch::DebugExceptions)
+          ActionDispatch::DebugExceptions.send(:include,Appygram::DebugExceptions)
+        else
+          app.config.middleware.use "Rack::RailsAppygram"
+        end
+      end
+    end
+  end
+end

data/lib/appygram/remote.rb

@@ -0,0 +1,52 @@
+require 'zlib'
+require 'cgi'
+require 'net/http'
+require 'net/https'
+require 'digest/md5'
+
+module Appygram
+  class Remote
+    class << self
+      def startup_announce(startup_data)
+        url = "/api/announcements?api_key=#{::Appygram::Config.api_key}&protocol_version=#{::Appygram::PROTOCOL_VERSION}"
+        compressed = Zlib::Deflate.deflate(startup_data.to_json, Zlib::BEST_SPEED)
+        call_remote(url, compressed)
+      end
+
+      def error(exception_data)
+        uniqueness_hash = exception_data.uniqueness_hash
+        hash_param = uniqueness_hash.nil? ? nil: "&hash=#{uniqueness_hash}"
+        url = "/api/errors?api_key=#{::Appygram::Config.api_key}&protocol_version=#{::Appygram::PROTOCOL_VERSION}#{hash_param}"
+        compressed = Zlib::Deflate.deflate(exception_data.to_json, Zlib::BEST_SPEED)
+        call_remote(url, compressed)
+      end
+
+      def call_remote(url, data)
+        config = Appygram::Config
+        optional_proxy = Net::HTTP::Proxy(config.http_proxy_host,
+                                          config.http_proxy_port,
+                                          config.http_proxy_username,
+                                          config.http_proxy_password)
+        client = optional_proxy.new(config.remote_host, config.remote_port)
+        client.open_timeout = config.http_open_timeout
+        client.read_timeout = config.http_read_timeout
+        client.use_ssl = config.ssl?
+        client.verify_mode = OpenSSL::SSL::VERIFY_NONE if config.ssl?
+        begin
+          response = client.post(url, data)
+          case response
+            when Net::HTTPSuccess
+              Appygram.logger.info( "#{url} - #{response.message}")
+              return true
+            else
+              Appygram.logger.error("#{url} - #{response.code} - #{response.message}")
+          end
+        rescue Exception => e
+          Appygram.logger.error('Problem notifying Appygram about the error')
+          Appygram.logger.error(e)
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/appygram/startup.rb

@@ -0,0 +1,14 @@
+module Appygram
+  class StartupException < StandardError;
+  end
+  class Startup
+    class << self
+      def announce
+        if Config.api_key.blank?
+          raise StartupException, 'API Key must be configured (/config/appygram.yml)'
+        end
+        Remote.startup_announce(::Appygram::ApplicationEnvironment.to_hash('rails'))
+      end
+    end
+  end
+end

data/lib/appygram/version.rb

@@ -0,0 +1,3 @@
+module Appygram
+  VERSION = '0.1.0'
+end

data/lib/appygram.rb

@@ -0,0 +1,71 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'appygram/monkeypatches'
+require 'appygram/catcher'
+require 'appygram/startup'
+require 'appygram/log_factory'
+require 'appygram/config'
+require 'appygram/application_environment'
+require 'appygram/exception_data'
+require 'appygram/controller_exception_data'
+require 'appygram/rack_exception_data'
+require 'appygram/alert_data'
+require 'appygram/remote'
+require 'appygram/integration/rack'    
+require 'appygram/integration/rack_rails'
+require 'appygram/integration/alerter'
+require 'appygram/version'
+require 'appygram/integration/debug_exceptions'
+
+require 'appygram/railtie' if defined?(Rails::Railtie)
+
+module Appygram
+  PROTOCOL_VERSION = 5
+  CLIENT_NAME = 'getappygram-gem'
+  ENVIRONMENT_FILTER = []
+
+  def self.logger
+    ::Appygram::LogFactory.logger
+  end
+
+  def self.configure(api_key)
+    Appygram::Config.api_key = api_key
+  end
+
+  def self.handle(exception, name=nil)
+    Appygram::Catcher.handle(exception, name)
+  end
+  
+  def self.rescue(name=nil, context=nil, &block)
+    begin
+      self.context(context) unless context.nil?
+      block.call
+    rescue Exception => e
+      Appygram::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
+      Appygram::Catcher.handle(e,name)
+      raise(e)
+    ensure
+      self.clear!      
+    end
+  end
+
+  def self.clear!
+    Thread.current[:appygram_context] = nil
+  end
+
+  def self.context(hash = {})
+    Thread.current[:appygram_context] ||= {}
+    Thread.current[:appygram_context].merge!(hash)
+    self
+  end
+end

data/rails/init.rb

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

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: appygram
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- rfc2616
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &70157985912000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70157985912000
+description: Appygram is the Ruby gem for communicating with http://appygram.com (hosted
+  messaging service). It supports an exception reporting mechanism similar to http://exceptional.io,
+  and this Ruby gem, forked from the Exceptional gem, emulates Exceptional functionality.
+email: heittman.rob@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/appygram/alert_data.rb
+- lib/appygram/application_environment.rb
+- lib/appygram/catcher.rb
+- lib/appygram/config.rb
+- lib/appygram/controller_exception_data.rb
+- lib/appygram/exception_data.rb
+- lib/appygram/integration/alerter.rb
+- lib/appygram/integration/debug_exceptions.rb
+- lib/appygram/integration/dj.rb
+- lib/appygram/integration/rack.rb
+- lib/appygram/integration/rack_rails.rb
+- lib/appygram/integration/rails.rb
+- lib/appygram/integration/sinatra.rb
+- lib/appygram/log_factory.rb
+- lib/appygram/monkeypatches.rb
+- lib/appygram/rack_exception_data.rb
+- lib/appygram/railtie.rb
+- lib/appygram/remote.rb
+- lib/appygram/startup.rb
+- lib/appygram/version.rb
+- lib/appygram.rb
+- rails/init.rb
+- init.rb
+- appygram.gemspec
+homepage: http://appygram.com/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- json_pure, json-jruby or json gem required
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: appygram is a hosted service for sending messages from mobile/web apps
+test_files: []