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.



7
8
9
10
11
 
# File 'lib/bugsnag/middleware_stack.rb', line 7

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.



95
96
97
 
# File 'lib/bugsnag/middleware_stack.rb', line 95

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

Instance Method Details

#disable(*middlewares) ⇒ Object

Disable the given middleware. This removes them from the list of middleware and ensures they cannot be added again

See also #remove



75
76
77
78
79
80
81
 
# File 'lib/bugsnag/middleware_stack.rb', line 75

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.



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

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.



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

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

#remove(*middlewares) ⇒ Object

Remove the given middleware from the list of middleware

This is like #disable but allows the middleware to be added again



87
88
89
90
91
 
# File 'lib/bugsnag/middleware_stack.rb', line 87

def remove(*middlewares)
  @mutex.synchronize do
    @middlewares.delete_if {|m| middlewares.include?(m) }
  end
end

#run(report) ⇒ Object

Runs the middleware stack.



101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/bugsnag/middleware_stack.rb', line 101

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.



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

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