Class: Bugsnag::MiddlewareStack

Inherits:
Object
  • Object
show all
Defined in:
lib/bugsnag/middleware_stack.rb

Instance Method Summary collapse

Constructor Details

#initialize ⇒ MiddlewareStack

Creates the middleware stack.



5
6
7
8
9
 
# File 'lib/bugsnag/middleware_stack.rb', line 5

def initialize
  @middlewares = []
  @disabled_middleware = []
  @mutex = Mutex.new
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *args, &block) ⇒ Object

Allows the user to proxy methods for more complex functionality.



78
79
80
 
# File 'lib/bugsnag/middleware_stack.rb', line 78

def method_missing(method, *args, &block)
  @middlewares.send(method, *args, &block)
end

Instance Method Details

#disable(*middlewares) ⇒ Object 



68
69
70
71
72
73
74
 
# File 'lib/bugsnag/middleware_stack.rb', line 68

def disable(*middlewares)
  @mutex.synchronize do
    @disabled_middleware += middlewares

    @middlewares.delete_if {|m| @disabled_middleware.include?(m)}
  end
end

#insert_after(after, new_middleware) ⇒ Object

Inserts a new middleware to use after a given middleware already added.

Will return early if given middleware is disabled or already added. New middleware will be inserted last if the existing middleware is not already included.



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/bugsnag/middleware_stack.rb', line 29

def insert_after(after, new_middleware)
  @mutex.synchronize do
    return if @disabled_middleware.include?(new_middleware)
    return if @middlewares.include?(new_middleware)

    if after.is_a? Array
      index = @middlewares.rindex {|el| after.include?(el)}
    else
      index = @middlewares.rindex(after)
    end

    if index.nil?
      @middlewares << new_middleware
    else
      @middlewares.insert index + 1, new_middleware
    end
  end
end

#insert_before(before, new_middleware) ⇒ Object

Inserts a new middleware to use before a given middleware already added.

Will return early if given middleware is disabled or already added. New middleware will be inserted last if the existing middleware is not already included.



53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/bugsnag/middleware_stack.rb', line 53

def insert_before(before, new_middleware)
  @mutex.synchronize do
    return if @disabled_middleware.include?(new_middleware)
    return if @middlewares.include?(new_middleware)

    if before.is_a? Array
      index = @middlewares.index {|el| before.include?(el)}
    else
      index = @middlewares.index(before)
    end

    @middlewares.insert index || @middlewares.length, new_middleware
  end
end

#run(report) ⇒ Object

Runs the middleware stack.



84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/bugsnag/middleware_stack.rb', line 84

def run(report)
  # The final lambda is the termination of the middleware stack. It calls deliver on the notification
  lambda_has_run = false
  notify_lambda = lambda do |notif|
    lambda_has_run = true
    yield if block_given?
  end

  begin
    # We reverse them, so we can call "call" on the first middleware
    middleware_procs.reverse.inject(notify_lambda) { |n,e| e.call(n) }.call(report)
  rescue StandardError => e
    # KLUDGE: Since we don't re-raise middleware exceptions, this breaks rspec
    raise if e.class.to_s == "RSpec::Expectations::ExpectationNotMetError"

    # We dont notify, as we dont want to loop forever in the case of really broken middleware, we will
    # still send this notify
    Bugsnag.configuration.warn "Bugsnag middleware error: #{e}"
    Bugsnag.configuration.warn "Middleware error stacktrace: #{e.backtrace.inspect}"
  end

  # Ensure that the deliver has been performed, and no middleware has botched it
  notify_lambda.call(report) unless lambda_has_run
end

#use(new_middleware) ⇒ Object

Defines a new middleware to use in the middleware call sequence.

Will return early if given middleware is disabled or already included.



15
16
17
18
19
20
21
22
 
# File 'lib/bugsnag/middleware_stack.rb', line 15

def use(new_middleware)
  @mutex.synchronize do
    return if @disabled_middleware.include?(new_middleware)
    return if @middlewares.include?(new_middleware)

    @middlewares << new_middleware
  end
end