Class: Radar::Application

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Defined in:
lib/radar/application.rb

Overview

Represents an instance of Radar for a given application. Every application which uses Radar must instantiate an Application.

Constant Summary collapse

@@registered = 
{}
@@mutex = 
Mutex.new

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name, register = true) ⇒ Application

Creates a new application with the given name and registers it for lookup later. If a block is given, it will be yielded with the new instantiated Radar::Application so you can also #config it all in one go.

Parameters:

  • name (String) —

    Application name. This must be unique for any given application or an exception will be raised.



46
47
48
49
50
51
52
53
54
55
 
# File 'lib/radar/application.rb', line 46

def initialize(name, register=true)
  @@mutex.synchronize do
    raise ApplicationAlreadyExists.new("'#{name}' already defined at '#{self.class.find(name).creation_location}'") if self.class.find(name)

    @name = name
    @creation_location = caller.first
    yield self if block_given?
    @@registered[name] = self if register
  end
end

Instance Attribute Details

#creation_location ⇒ Object (readonly)

Returns the value of attribute creation_location.



20
21
22
 
# File 'lib/radar/application.rb', line 20

def creation_location
  @creation_location
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



19
20
21
 
# File 'lib/radar/application.rb', line 19

def name
  @name
end

Class Method Details

.clear! ⇒ Object

Removes all registered applications. This is only exposed for testing purposes.



34
35
36
 
# File 'lib/radar/application.rb', line 34

def self.clear!
  @@registered.clear
end

.find(name) ⇒ Application

Looks up an application which was registered with the given name.

Parameters:

  • name (String) —

    Application name.

Returns:



28
29
30
 
# File 'lib/radar/application.rb', line 28

def self.find(name)
  @@registered[name]
end

Instance Method Details

#config {|Config| ... } ⇒ Config

Configures the application by returning the configuration object. If a block is given, the configuration object will be passed into it, allowing for a cleaner way of configuring your applications.

$app = Radar::Application.new
$app.config do |config|
  config.reporters.use Radar::Reporter::FileReporter
end

You can also just use it without a block:

$app.config.reporters.use Radar::Reporter::FileReporter

Yields:

  • (Config) —

    Configuration object, only if block is given.

Returns:



73
74
75
76
77
 
# File 'lib/radar/application.rb', line 73

def config
  @_config ||= Config.new
  yield @_config if block_given?
  @_config
end

#integrate(integrator, *args, &block) ⇒ Object

Integrate this application with some external system, such as Rack, Rails, Sinatra, etc. For more information on Radar integrations, please read the user guide.



123
124
125
126
 
# File 'lib/radar/application.rb', line 123

def integrate(integrator, *args, &block)
  integrator = Support::Inflector.constantize("Radar::Integration::#{Support::Inflector.camelize(integrator)}") if !integrator.is_a?(Class)
  integrator.integrate!(self, *args, &block)
end

#logger ⇒ Logger

Returns the logger for the application. Each application gets their own logger which is used for lightweight (single line) logging so users can sanity check that Radar is working as expected.

Returns:



85
86
87
 
# File 'lib/radar/application.rb', line 85

def logger
  @_logger ||= Logger.new(self)
end

#report(exception, extra = nil) ⇒ Object

Reports an exception. This will send the exception on to the various reporters configured for this application. If any matchers are defined, using Config#match, then at least one must match for the report to go forward to reporters.

Parameters:

  • exception (Exception) 


95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/radar/application.rb', line 95

def report(exception, extra=nil)
  data = ExceptionEvent.new(self, exception, extra)

  # If there are matchers, then verify that at least one matches
  # before continuing
  if !config.matchers.empty?
    return if !config.matchers.values.find do |m|
      m.matches?(data) && logger.info("Reporting exception. Matches: #{m}")
    end
  end

  # Report the exception to each of the reporters
  logger.info "Invoking reporters for exception: #{exception.class}"
  config.reporters.values.each do |reporter|
    reporter.report(data)
  end
end

#rescue_at_exit! ⇒ Object

Hooks this application into the at_exit handler so that application crashing exceptions are properly reported.



115
116
117
118
 
# File 'lib/radar/application.rb', line 115

def rescue_at_exit!
  logger.info "Attached to application exit."
  at_exit { report($!) if $! }
end

#to_hash ⇒ Hash

Converts application to a serialization-friendly hash.

Returns:

  • (Hash) 


131
132
133
 
# File 'lib/radar/application.rb', line 131

def to_hash
  { :name => name }
end