RSolr::Error::Http in SearchController#show. Скидки молоко

raise "The response does not have the correct keys => :body, :headers, :status" unless

%W(body headers status) == response.keys.map{|k|k.to_s}.sort

raise RSolr::Error::Http.new request, response unless [200,302].include? response[:status]

result = if respond_to? "evaluate_#{request[:params][:wt]}_response", true

send "evaluate_#{request[:params][:wt]}_response", request, response

end

adapt_response(request_context, raw_response) unless raw_response.nil?

end

def retry_503?(request_context, response)

def send_and_receive path, opts

request_context = build_request path, opts

execute request_context

end

#

payload = {:path => path, :parameters => parameters}

ActiveSupport::Notifications.instrument("request.rsolr", payload) do

send_and_receive_without_as_instrumentation(path, opts)

end

end

end

def instrument(name, payload = {})

if notifier.listening?(name)

instrumenter.instrument(name, payload) { yield payload if block_given? }

else

yield payload if block_given?

end

start name, payload

begin

yield payload

rescue Exception => e

payload[:exception] = [e.class.name, e.message]

raise e

def instrument(name, payload = {})

if notifier.listening?(name)

instrumenter.instrument(name, payload) { yield payload if block_given? }

else

yield payload if block_given?

end

parameters.merge!(opts[:data]) if opts[:data].is_a? Hash

payload = {:path => path, :parameters => parameters}

ActiveSupport::Notifications.instrument("request.rsolr", payload) do

send_and_receive_without_as_instrumentation(path, opts)

end

end

reset

params = @query.to_params

@solr_result = @connection.post "#{request_handler}", :data => params

self

end

def search(*types, &block)

search = new_search(*types, &block)

search.execute

end

#

module_eval(<<-RUBY, __FILE__, __LINE__ + 1)

def #{method}(*args, &block)

#{delegate}.#{method}(*args, &block)

end

RUBY

end

#

def search(*types, &block)

session.search(*types, &block)

end

def new_more_like_this(object, *types, &block)

alias_method method_name, _traced_method_name(method_name, metric_name_code)

send visibility, method_name

send visibility, _traced_method_name(method_name, metric_name_code)

::NewRelic::Agent.logger.debug("Traced method: class = #{derived_class_name},"+

"method = #{method_name}, "+

"metric = '#{metric_name_code}'")

begin

yield

ensure

segment.finish

end

class_eval traced_method, __FILE__, __LINE__

alias_method _untraced_method_name(method_name, metric_name_code), method_name

alias_method method_name, _traced_method_name(method_name, metric_name_code)

send visibility, method_name

send visibility, _traced_method_name(method_name, metric_name_code)

::NewRelic::Agent.logger.debug("Traced method: class = #{derived_class_name},"+

def search(term, options = {})

catalogs = Sunspot.search(CatalogLocation) do

with(:valid_from).less_than Date.today

with(:valid_until).greater_than Date.today

term_search = (defined?(@product) && [email protected]?) ? @product.title : @search_term

@catalogs = Catalog.search(term_search, opts)

searched_pages = Page.search(term_search, opts).compact rescue []

module ImplicitRender

def send_action(method, *args)

ret = super

default_render unless performed?

ret

end

# which is *not* necessarily the same as the action name.

def process_action(method_name, *args)

send_action(method_name, *args)

end

# Actually call the method associated with the action. Override

def process_action(*) #:nodoc:

self.formats = request.formats.map(&:ref).compact

super

end

# Check for double render errors and set the content_type after rendering.

def process_action(*args)

run_callbacks(:process_action) do

super

end

end

def call(env)

block = env.run_block

env.value = !env.halted && (!block || block.call)

env

end

end

def call(env)

block = env.run_block

env.value = !env.halted && (!block || block.call)

env

end

end

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

else

user_callback.call(target, value) {

env = next_callback.call env

env.value

}

env

else

user_callback.call(target, value) {

env = next_callback.call env

env.value

}

env

end

yield

ensure

I18n.default_locale = current_default_locale if tmp_default_locale

case filter

when Symbol

lambda { |target, _, &blk| target.send filter, &blk }

when String

l = eval "lambda { |value| #{filter} }"

lambda { |target, value| target.instance_exec(value, &l) }

next_callback.call env

else

user_callback.call(target, value) {

env = next_callback.call env

env.value

}

next_callback.call env

else

user_callback.call(target, value) {

env = next_callback.call env

env.value

}

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

runner = callbacks.compile

e = Filters::Environment.new(self, false, nil, block)

runner.call(e).value

end

end

runner = callbacks.compile

e = Filters::Environment.new(self, false, nil, block)

runner.call(e).value

end

end

module_eval <<-RUBY, __FILE__, __LINE__ + 1

def _run_#{name}_callbacks(&block)

_run_callbacks(_#{name}_callbacks, &block)

end

RUBY

end

# end

def run_callbacks(kind, &block)

send "_run_#{kind}_callbacks", &block

end

private

# process_action callbacks around the normal behavior.

def process_action(*args)

run_callbacks(:process_action) do

super

end

end

private

def process_action(*args)

super

rescue Exception => exception

request.env['action_dispatch.show_detailed_exceptions'] ||= show_detailed_exceptions?

rescue_with_handler(exception) || raise(exception)

ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|

result = super

payload[:status] = response.status

append_info_to_payload(payload)

result

def instrument(name, payload = {})

if notifier.listening?(name)

instrumenter.instrument(name, payload) { yield payload if block_given? }

else

yield payload if block_given?

end

start name, payload

begin

yield payload

rescue Exception => e

payload[:exception] = [e.class.name, e.message]

raise e

def instrument(name, payload = {})

if notifier.listening?(name)

instrumenter.instrument(name, payload) { yield payload if block_given? }

else

yield payload if block_given?

end

ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload.dup)

ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|

result = super

payload[:status] = response.status

append_info_to_payload(payload)

request.filtered_parameters.merge! wrapped_filtered_hash

end

super

end

private

# and it won't be cleaned up by the method below.

ActiveRecord::LogSubscriber.reset_runtime

super

end

def cleanup_view_runtime

@_response_body = nil

process_action(action_name, *args)

end

# Delegates to the class' #controller_path

def process(*) #:nodoc:

old_config, I18n.config = I18n.config, I18nProxy.new(I18n.config, lookup_context)

super

ensure

I18n.config = old_config

end

@_env = request.env

@_env['action_controller.instance'] = self

process(name)

to_a

end

def dispatch(action, request)

set_response!(request)

super(action, request)

end

def response_body=(body)

end

else

lambda { |env| new.dispatch(name, klass.new(env)) }

end

end

def dispatch(controller, action, env)

controller.action(action).call(env)

end

def normalize_controller!(params)

def dispatch(controller, action, env)

controller.action(action).call(env)

end

def normalize_controller!(params)

end

dispatch(controller, params[:action], req.env)

end

def prepare_params!(params)

req.path_parameters = set_params.merge parameters

status, headers, body = route.app.serve(req)

if 'pass' == headers['X-Cascade']

req.script_name = script_name

def serve(req)

find_routes(req).each do |match, parameters, route|

set_params = req.path_parameters

path_info = req.path_info

script_name = req.script_name

def serve(req)

find_routes(req).each do |match, parameters, route|

set_params = req.path_parameters

path_info = req.path_info

script_name = req.script_name

req = request_class.new(env)

req.path_info = Journey::Router::Utils.normalize_path(req.path_info)

@router.serve(req)

end

def recognize_path(path, environment = {})

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def traced_call(env)

@app.call(env)

end

end

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def traced_call(env)

result = @app.call(env) # [status, headers, response]

js_to_inject = NewRelic::Agent.browser_timing_header

if (js_to_inject != "") && should_instrument?(env, result[0], result[1])

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

end

@app.call(env)

end

# Checks to see if any redirect options were passed in

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

@check_after = Time.now.to_f + @dwell if @dwell

end

@app.call(env)

end

end

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

#p "-" * 100

#p env.inspect

@app.call(env)

end

end

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

env['warden'] = Proxy.new(env, self)

result = catch(:warden) do

@app.call(env)

end

result ||= {}

env['warden'] = Proxy.new(env, self)

result = catch(:warden) do

@app.call(env)

end

env['warden'] = Proxy.new(env, self)

result = catch(:warden) do

@app.call(env)

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

status, headers, body = @app.call(env)

if etag_status?(status) && etag_body?(body) && !skip_caching?(headers)

original_body = body

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

case env[REQUEST_METHOD]

when "GET", "HEAD"

status, headers, body = @app.call(env)

headers = Utils::HeaderHash.new(headers)

if status == 200 && fresh?(env, headers)

status = 304

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

status, headers, body = @app.call(env)

if env[REQUEST_METHOD] == HEAD

[

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

end

@app.call(env)

end

private

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

@app.call(env)

ensure

session = Request::Session.find(env) || {}

flash_hash = env[KEY]

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def context(env, app=@app)

prepare_session(env)

status, headers, body = app.call(env)

commit_session(env, status, headers, body)

end

def call(env)

context(env)

end

def context(env, app=@app)

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

status, headers, body = @app.call(env)

if cookie_jar = env['action_dispatch.cookies']

unless cookie_jar.committed?

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

connection.enable_query_cache!

response = @app.call(env)

response[2] = Rack::BodyProxy.new(response[2]) do

restore_query_cache_settings(connection_id, enabled)

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

# rubocop:disable Lint/RescueException

begin

response = @app.call(env)

rescue Exception => ex

notify_airbrake(ex, env)

raise ex

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

testing = env['rack.test']

response = @app.call(env)

response[2] = ::Rack::BodyProxy.new(response[2]) do

ActiveRecord::Base.clear_active_connections! unless testing

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

result = run_callbacks :call do

begin

@app.call(env)

rescue => error

end

end

def _run_callbacks(callbacks, &block)

if callbacks.empty?

block.call if block

else

runner = callbacks.compile

e = Filters::Environment.new(self, false, nil, block)

def _run_callbacks(callbacks, &block)

if callbacks.empty?

block.call if block

else

runner = callbacks.compile

e = Filters::Environment.new(self, false, nil, block)

module_eval <<-RUBY, __FILE__, __LINE__ + 1

def _run_#{name}_callbacks(&block)

_run_callbacks(_#{name}_callbacks, &block)

end

RUBY

end

# end

def run_callbacks(kind, &block)

send "_run_#{kind}_callbacks", &block

end

private

def call(env)

error = nil

result = run_callbacks :call do

begin

@app.call(env)

rescue => error

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

env["action_dispatch.remote_ip"] = GetIp.new(env, self)

@app.call(env)

end

# The GetIp class exists as a way to defer processing of the request data

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

better_errors_call env

else

@app.call env

end

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

_, headers, body = response = @app.call(env)

if headers['X-Cascade'] == 'pass'

body.close if body.respond_to?(:close)

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

@app.call(env)

rescue Exception => exception

if env['action_dispatch.show_exceptions'] == false

raise exception

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

instrumenter.start 'request.action_dispatch', request: request

logger.info { started_request_message(request) }

resp = @app.call(env)

resp[2] = ::Rack::BodyProxy.new(resp[2]) { finish(request) }

resp

rescue Exception

if logger.respond_to?(:tagged)

logger.tagged(compute_tags(request)) { call_app(request, env) }

else

call_app(request, env)

end

def tagged(*tags)

formatter.tagged(*tags) { yield self }

end

def flush

def tagged(*tags)

new_tags = push_tags(*tags)

yield self

ensure

pop_tags(new_tags.size)

end

def tagged(*tags)

formatter.tagged(*tags) { yield self }

end

def flush

if logger.respond_to?(:tagged)

logger.tagged(compute_tags(request)) { call_app(request, env) }

else

call_app(request, env)

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

RequestStore.begin!

@app.call(env)

ensure

RequestStore.end!

RequestStore.clear!

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

env["action_dispatch.request_id"] = external_request_id(env) || internal_request_id

@app.call(env).tap { |_status, headers, _body| headers["X-Request-Id"] = env["action_dispatch.request_id"] }

end

private

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

end

@app.call(env)

end

def method_override(env)

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

start_time = clock_time

status, headers, body = @app.call(env)

request_time = clock_time - start_time

if !headers.has_key?(@header_name)

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

LocalCacheRegistry.set_cache_for(local_cache_key, LocalStore.new)

response = @app.call(env)

response[2] = ::Rack::BodyProxy.new(response[2]) do

LocalCacheRegistry.set_cache_for(local_cache_key, nil)

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

old, env[FLAG] = env[FLAG], false

@mutex.lock

response = @app.call(env)

body = BodyProxy.new(response[2]) { @mutex.unlock }

response[2] = body

response

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

end

@app.call(env)

end

end

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

status, headers, body = @app.call(env)

if body.respond_to?(:to_path)

case type = variation(env)

when 'X-Accel-Redirect'

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

env["ROUTES_#{routes.object_id}_SCRIPT_NAME"] = env['SCRIPT_NAME'].dup

end

app.call(env)

end

# Defines additional Rack env configuration that is added on each call.

env["ORIGINAL_FULLPATH"] = build_original_fullpath(env)

env["ORIGINAL_SCRIPT_NAME"] = env["SCRIPT_NAME"]

super(env)

end

# Reload application routes regardless if they changed or not.

def method_missing(name, *args, &block)

if instance.respond_to?(name)

instance.public_send(name, *args, &block)

else

super

end

def method_missing(name, *args, &block)

if instance.respond_to?(name)

instance.public_send(name, *args, &block)

else

super

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

env['PATH_INFO'] = rest

return app.call(env)

end

[404, {CONTENT_TYPE => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path}"]]

sPort = env['SERVER_PORT']

@mapping.each do |host, location, match, app|

unless casecmp?(hHost, host) \

|| casecmp?(sName, host) \

|| (!host && (casecmp?(hHost, sName) ||

sPort = env['SERVER_PORT']

@mapping.each do |host, location, match, app|

unless casecmp?(hHost, host) \

|| casecmp?(sName, host) \

|| (!host && (casecmp?(hHost, sName) ||

begin

status, headers, body = @app.call(env)

rescue => e

if !should_swallow_app_error?(e, socket_wrapper)

# It's a good idea to catch application exceptions here because

begin

if headers[REQUEST_METHOD] == GET

process_request(headers, connection, socket_wrapper, @protocol == :http)

elsif headers[REQUEST_METHOD] == PING

process_ping(headers, connection)

false

finish_callback.call

while true

hijacked = accept_and_process_next_request(socket_wrapper, channel, buffer)

socket_wrapper = Utils::UnseekableSocket.new if hijacked

end

rescue Interrupted

handler = thread_handler.new(self, main_socket_options)

handler.install

handler.main_loop(set_initialization_state_to_true)

ensure

set_initialization_state.call(false)

unregister_current_thread

Thread.current.abort_on_exception = true

begin

yield(*args)

rescue SystemExit

raise

rescue Exception => e

raise "The response does not have the correct keys => :body, :headers, :status" unless

%W(body headers status) == response.keys.map{|k|k.to_s}.sort

raise RSolr::Error::Http.new request, response unless [200,302].include? response[:status]

result = if respond_to? "evaluate_#{request[:params][:wt]}_response", true

send "evaluate_#{request[:params][:wt]}_response", request, response

end

adapt_response(request_context, raw_response) unless raw_response.nil?

end

def retry_503?(request_context, response)

def send_and_receive path, opts

request_context = build_request path, opts

execute request_context

end

#

payload = {:path => path, :parameters => parameters}

ActiveSupport::Notifications.instrument("request.rsolr", payload) do

send_and_receive_without_as_instrumentation(path, opts)

end

end

end

def instrument(name, payload = {})

if notifier.listening?(name)

instrumenter.instrument(name, payload) { yield payload if block_given? }

else

yield payload if block_given?

end

start name, payload

begin

yield payload

rescue Exception => e

payload[:exception] = [e.class.name, e.message]

raise e

def instrument(name, payload = {})

if notifier.listening?(name)

instrumenter.instrument(name, payload) { yield payload if block_given? }

else

yield payload if block_given?

end

parameters.merge!(opts[:data]) if opts[:data].is_a? Hash

payload = {:path => path, :parameters => parameters}

ActiveSupport::Notifications.instrument("request.rsolr", payload) do

send_and_receive_without_as_instrumentation(path, opts)

end

end

reset

params = @query.to_params

@solr_result = @connection.post "#{request_handler}", :data => params

self

end

def search(*types, &block)

search = new_search(*types, &block)

search.execute

end

#

module_eval(<<-RUBY, __FILE__, __LINE__ + 1)

def #{method}(*args, &block)

#{delegate}.#{method}(*args, &block)

end

RUBY

end

#

def search(*types, &block)

session.search(*types, &block)

end

def new_more_like_this(object, *types, &block)

alias_method method_name, _traced_method_name(method_name, metric_name_code)

send visibility, method_name

send visibility, _traced_method_name(method_name, metric_name_code)

::NewRelic::Agent.logger.debug("Traced method: class = #{derived_class_name},"+

"method = #{method_name}, "+

"metric = '#{metric_name_code}'")

begin

yield

ensure

segment.finish

end

class_eval traced_method, __FILE__, __LINE__

alias_method _untraced_method_name(method_name, metric_name_code), method_name

alias_method method_name, _traced_method_name(method_name, metric_name_code)

send visibility, method_name

send visibility, _traced_method_name(method_name, metric_name_code)

::NewRelic::Agent.logger.debug("Traced method: class = #{derived_class_name},"+

def search(term, options = {})

catalogs = Sunspot.search(CatalogLocation) do

with(:valid_from).less_than Date.today

with(:valid_until).greater_than Date.today

term_search = (defined?(@product) && [email protected]?) ? @product.title : @search_term

@catalogs = Catalog.search(term_search, opts)

searched_pages = Page.search(term_search, opts).compact rescue []

module ImplicitRender

def send_action(method, *args)

ret = super

default_render unless performed?

ret

end

# which is *not* necessarily the same as the action name.

def process_action(method_name, *args)

send_action(method_name, *args)

end

# Actually call the method associated with the action. Override

def process_action(*) #:nodoc:

self.formats = request.formats.map(&:ref).compact

super

end

# Check for double render errors and set the content_type after rendering.

def process_action(*args)

run_callbacks(:process_action) do

super

end

end

def call(env)

block = env.run_block

env.value = !env.halted && (!block || block.call)

env

end

end

def call(env)

block = env.run_block

env.value = !env.halted && (!block || block.call)

env

end

end

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

else

user_callback.call(target, value) {

env = next_callback.call env

env.value

}

env

else

user_callback.call(target, value) {

env = next_callback.call env

env.value

}

env

end

yield

ensure

I18n.default_locale = current_default_locale if tmp_default_locale

case filter

when Symbol

lambda { |target, _, &blk| target.send filter, &blk }

when String

l = eval "lambda { |value| #{filter} }"

lambda { |target, value| target.instance_exec(value, &l) }

next_callback.call env

else

user_callback.call(target, value) {

env = next_callback.call env

env.value

}

next_callback.call env

else

user_callback.call(target, value) {

env = next_callback.call env

env.value

}

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

runner = callbacks.compile

e = Filters::Environment.new(self, false, nil, block)

runner.call(e).value

end

end

runner = callbacks.compile

e = Filters::Environment.new(self, false, nil, block)

runner.call(e).value

end

end

module_eval <<-RUBY, __FILE__, __LINE__ + 1

def _run_#{name}_callbacks(&block)

_run_callbacks(_#{name}_callbacks, &block)

end

RUBY

end

# end

def run_callbacks(kind, &block)

send "_run_#{kind}_callbacks", &block

end

private

# process_action callbacks around the normal behavior.

def process_action(*args)

run_callbacks(:process_action) do

super

end

end

private

def process_action(*args)

super

rescue Exception => exception

request.env['action_dispatch.show_detailed_exceptions'] ||= show_detailed_exceptions?

rescue_with_handler(exception) || raise(exception)

ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|

result = super

payload[:status] = response.status

append_info_to_payload(payload)

result

def instrument(name, payload = {})

if notifier.listening?(name)

instrumenter.instrument(name, payload) { yield payload if block_given? }

else

yield payload if block_given?

end

start name, payload

begin

yield payload

rescue Exception => e

payload[:exception] = [e.class.name, e.message]

raise e

def instrument(name, payload = {})

if notifier.listening?(name)

instrumenter.instrument(name, payload) { yield payload if block_given? }

else

yield payload if block_given?

end

ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload.dup)

ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|

result = super

payload[:status] = response.status

append_info_to_payload(payload)

request.filtered_parameters.merge! wrapped_filtered_hash

end

super

end

private

# and it won't be cleaned up by the method below.

ActiveRecord::LogSubscriber.reset_runtime

super

end

def cleanup_view_runtime

@_response_body = nil

process_action(action_name, *args)

end

# Delegates to the class' #controller_path

def process(*) #:nodoc:

old_config, I18n.config = I18n.config, I18nProxy.new(I18n.config, lookup_context)

super

ensure

I18n.config = old_config

end

@_env = request.env

@_env['action_controller.instance'] = self

process(name)

to_a

end

def dispatch(action, request)

set_response!(request)

super(action, request)

end

def response_body=(body)

end

else

lambda { |env| new.dispatch(name, klass.new(env)) }

end

end

def dispatch(controller, action, env)

controller.action(action).call(env)

end

def normalize_controller!(params)

def dispatch(controller, action, env)

controller.action(action).call(env)

end

def normalize_controller!(params)

end

dispatch(controller, params[:action], req.env)

end

def prepare_params!(params)

req.path_parameters = set_params.merge parameters

status, headers, body = route.app.serve(req)

if 'pass' == headers['X-Cascade']

req.script_name = script_name

def serve(req)

find_routes(req).each do |match, parameters, route|

set_params = req.path_parameters

path_info = req.path_info

script_name = req.script_name

def serve(req)

find_routes(req).each do |match, parameters, route|

set_params = req.path_parameters

path_info = req.path_info

script_name = req.script_name

req = request_class.new(env)

req.path_info = Journey::Router::Utils.normalize_path(req.path_info)

@router.serve(req)

end

def recognize_path(path, environment = {})

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def traced_call(env)

@app.call(env)

end

end

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def traced_call(env)

result = @app.call(env) # [status, headers, response]

js_to_inject = NewRelic::Agent.browser_timing_header

if (js_to_inject != "") && should_instrument?(env, result[0], result[1])

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

end

@app.call(env)

end

# Checks to see if any redirect options were passed in

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

@check_after = Time.now.to_f + @dwell if @dwell

end

@app.call(env)

end

end

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

#p "-" * 100

#p env.inspect

@app.call(env)

end

end

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

env['warden'] = Proxy.new(env, self)

result = catch(:warden) do

@app.call(env)

end

result ||= {}

env['warden'] = Proxy.new(env, self)

result = catch(:warden) do

@app.call(env)

end

env['warden'] = Proxy.new(env, self)

result = catch(:warden) do

@app.call(env)

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

status, headers, body = @app.call(env)

if etag_status?(status) && etag_body?(body) && !skip_caching?(headers)

original_body = body

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

case env[REQUEST_METHOD]

when "GET", "HEAD"

status, headers, body = @app.call(env)

headers = Utils::HeaderHash.new(headers)

if status == 200 && fresh?(env, headers)

status = 304

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

status, headers, body = @app.call(env)

if env[REQUEST_METHOD] == HEAD

[

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

end

@app.call(env)

end

private

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

@app.call(env)

ensure

session = Request::Session.find(env) || {}

flash_hash = env[KEY]

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def context(env, app=@app)

prepare_session(env)

status, headers, body = app.call(env)

commit_session(env, status, headers, body)

end

def call(env)

context(env)

end

def context(env, app=@app)

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

status, headers, body = @app.call(env)

if cookie_jar = env['action_dispatch.cookies']

unless cookie_jar.committed?

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

connection.enable_query_cache!

response = @app.call(env)

response[2] = Rack::BodyProxy.new(response[2]) do

restore_query_cache_settings(connection_id, enabled)

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

# rubocop:disable Lint/RescueException

begin

response = @app.call(env)

rescue Exception => ex

notify_airbrake(ex, env)

raise ex

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

testing = env['rack.test']

response = @app.call(env)

response[2] = ::Rack::BodyProxy.new(response[2]) do

ActiveRecord::Base.clear_active_connections! unless testing

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

result = run_callbacks :call do

begin

@app.call(env)

rescue => error

end

end

def _run_callbacks(callbacks, &block)

if callbacks.empty?

block.call if block

else

runner = callbacks.compile

e = Filters::Environment.new(self, false, nil, block)

def _run_callbacks(callbacks, &block)

if callbacks.empty?

block.call if block

else

runner = callbacks.compile

e = Filters::Environment.new(self, false, nil, block)

module_eval <<-RUBY, __FILE__, __LINE__ + 1

def _run_#{name}_callbacks(&block)

_run_callbacks(_#{name}_callbacks, &block)

end

RUBY

end

# end

def run_callbacks(kind, &block)

send "_run_#{kind}_callbacks", &block

end

private

def call(env)

error = nil

result = run_callbacks :call do

begin

@app.call(env)

rescue => error

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

env["action_dispatch.remote_ip"] = GetIp.new(env, self)

@app.call(env)

end

# The GetIp class exists as a way to defer processing of the request data

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

better_errors_call env

else

@app.call env

end

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

_, headers, body = response = @app.call(env)

if headers['X-Cascade'] == 'pass'

body.close if body.respond_to?(:close)

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

@app.call(env)

rescue Exception => exception

if env['action_dispatch.show_exceptions'] == false

raise exception

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

instrumenter.start 'request.action_dispatch', request: request

logger.info { started_request_message(request) }

resp = @app.call(env)

resp[2] = ::Rack::BodyProxy.new(resp[2]) { finish(request) }

resp

rescue Exception

if logger.respond_to?(:tagged)

logger.tagged(compute_tags(request)) { call_app(request, env) }

else

call_app(request, env)

end

def tagged(*tags)

formatter.tagged(*tags) { yield self }

end

def flush

def tagged(*tags)

new_tags = push_tags(*tags)

yield self

ensure

pop_tags(new_tags.size)

end

def tagged(*tags)

formatter.tagged(*tags) { yield self }

end

def flush

if logger.respond_to?(:tagged)

logger.tagged(compute_tags(request)) { call_app(request, env) }

else

call_app(request, env)

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

RequestStore.begin!

@app.call(env)

ensure

RequestStore.end!

RequestStore.clear!

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

env["action_dispatch.request_id"] = external_request_id(env) || internal_request_id

@app.call(env).tap { |_status, headers, _body| headers["X-Request-Id"] = env["action_dispatch.request_id"] }

end

private

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

end

@app.call(env)

end

def method_override(env)

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

start_time = clock_time

status, headers, body = @app.call(env)

request_time = clock_time - start_time

if !headers.has_key?(@header_name)

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

LocalCacheRegistry.set_cache_for(local_cache_key, LocalStore.new)

response = @app.call(env)

response[2] = ::Rack::BodyProxy.new(response[2]) do

LocalCacheRegistry.set_cache_for(local_cache_key, nil)

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

old, env[FLAG] = env[FLAG], false

@mutex.lock

response = @app.call(env)

body = BodyProxy.new(response[2]) { @mutex.unlock }

response[2] = body

response

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

end

@app.call(env)

end

end

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

status, headers, body = @app.call(env)

if body.respond_to?(:to_path)

case type = variation(env)

when 'X-Accel-Redirect'

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

env["ROUTES_#{routes.object_id}_SCRIPT_NAME"] = env['SCRIPT_NAME'].dup

end

app.call(env)

end

# Defines additional Rack env configuration that is added on each call.

env["ORIGINAL_FULLPATH"] = build_original_fullpath(env)

env["ORIGINAL_SCRIPT_NAME"] = env["SCRIPT_NAME"]

super(env)

end

# Reload application routes regardless if they changed or not.

def method_missing(name, *args, &block)

if instance.respond_to?(name)

instance.public_send(name, *args, &block)

else

super

end

def method_missing(name, *args, &block)

if instance.respond_to?(name)

instance.public_send(name, *args, &block)

else

super

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

env['PATH_INFO'] = rest

return app.call(env)

end

[404, {CONTENT_TYPE => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path}"]]

sPort = env['SERVER_PORT']

@mapping.each do |host, location, match, app|

unless casecmp?(hHost, host) \

|| casecmp?(sName, host) \

|| (!host && (casecmp?(hHost, sName) ||

sPort = env['SERVER_PORT']

@mapping.each do |host, location, match, app|

unless casecmp?(hHost, host) \

|| casecmp?(sName, host) \

|| (!host && (casecmp?(hHost, sName) ||

begin

status, headers, body = @app.call(env)

rescue => e

if !should_swallow_app_error?(e, socket_wrapper)

# It's a good idea to catch application exceptions here because

begin

if headers[REQUEST_METHOD] == GET

process_request(headers, connection, socket_wrapper, @protocol == :http)

elsif headers[REQUEST_METHOD] == PING

process_ping(headers, connection)

false

finish_callback.call

while true

hijacked = accept_and_process_next_request(socket_wrapper, channel, buffer)

socket_wrapper = Utils::UnseekableSocket.new if hijacked

end

rescue Interrupted

handler = thread_handler.new(self, main_socket_options)

handler.install

handler.main_loop(set_initialization_state_to_true)

ensure

set_initialization_state.call(false)

unregister_current_thread

Thread.current.abort_on_exception = true

begin

yield(*args)

rescue SystemExit

raise

rescue Exception => e

raise "The response does not have the correct keys => :body, :headers, :status" unless

%W(body headers status) == response.keys.map{|k|k.to_s}.sort

raise RSolr::Error::Http.new request, response unless [200,302].include? response[:status]

result = if respond_to? "evaluate_#{request[:params][:wt]}_response", true

send "evaluate_#{request[:params][:wt]}_response", request, response

end

adapt_response(request_context, raw_response) unless raw_response.nil?

end

def retry_503?(request_context, response)

def send_and_receive path, opts

request_context = build_request path, opts

execute request_context

end

#

payload = {:path => path, :parameters => parameters}

ActiveSupport::Notifications.instrument("request.rsolr", payload) do

send_and_receive_without_as_instrumentation(path, opts)

end

end

end

def instrument(name, payload = {})

if notifier.listening?(name)

instrumenter.instrument(name, payload) { yield payload if block_given? }

else

yield payload if block_given?

end

start name, payload

begin

yield payload

rescue Exception => e

payload[:exception] = [e.class.name, e.message]

raise e

def instrument(name, payload = {})

if notifier.listening?(name)

instrumenter.instrument(name, payload) { yield payload if block_given? }

else

yield payload if block_given?

end

parameters.merge!(opts[:data]) if opts[:data].is_a? Hash

payload = {:path => path, :parameters => parameters}

ActiveSupport::Notifications.instrument("request.rsolr", payload) do

send_and_receive_without_as_instrumentation(path, opts)

end

end

reset

params = @query.to_params

@solr_result = @connection.post "#{request_handler}", :data => params

self

end

def search(*types, &block)

search = new_search(*types, &block)

search.execute

end

#

module_eval(<<-RUBY, __FILE__, __LINE__ + 1)

def #{method}(*args, &block)

#{delegate}.#{method}(*args, &block)

end

RUBY

end

#

def search(*types, &block)

session.search(*types, &block)

end

def new_more_like_this(object, *types, &block)

alias_method method_name, _traced_method_name(method_name, metric_name_code)

send visibility, method_name

send visibility, _traced_method_name(method_name, metric_name_code)

::NewRelic::Agent.logger.debug("Traced method: class = #{derived_class_name},"+

"method = #{method_name}, "+

"metric = '#{metric_name_code}'")

begin

yield

ensure

segment.finish

end

class_eval traced_method, __FILE__, __LINE__

alias_method _untraced_method_name(method_name, metric_name_code), method_name

alias_method method_name, _traced_method_name(method_name, metric_name_code)

send visibility, method_name

send visibility, _traced_method_name(method_name, metric_name_code)

::NewRelic::Agent.logger.debug("Traced method: class = #{derived_class_name},"+

def search(term, options = {})

catalogs = Sunspot.search(CatalogLocation) do

with(:valid_from).less_than Date.today

with(:valid_until).greater_than Date.today

term_search = (defined?(@product) && [email protected]?) ? @product.title : @search_term

@catalogs = Catalog.search(term_search, opts)

searched_pages = Page.search(term_search, opts).compact rescue []

module ImplicitRender

def send_action(method, *args)

ret = super

default_render unless performed?

ret

end

# which is *not* necessarily the same as the action name.

def process_action(method_name, *args)

send_action(method_name, *args)

end

# Actually call the method associated with the action. Override

def process_action(*) #:nodoc:

self.formats = request.formats.map(&:ref).compact

super

end

# Check for double render errors and set the content_type after rendering.

def process_action(*args)

run_callbacks(:process_action) do

super

end

end

def call(env)

block = env.run_block

env.value = !env.halted && (!block || block.call)

env

end

end

def call(env)

block = env.run_block

env.value = !env.halted && (!block || block.call)

env

end

end

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

def self.halting(next_callback, user_callback)

lambda { |env|

env = next_callback.call env

unless env.halted

user_callback.call env.target, env.value

end

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

else

user_callback.call(target, value) {

env = next_callback.call env

env.value

}

env

else

user_callback.call(target, value) {

env = next_callback.call env

env.value

}

env

end

yield

ensure

I18n.default_locale = current_default_locale if tmp_default_locale

case filter

when Symbol

lambda { |target, _, &blk| target.send filter, &blk }

when String

l = eval "lambda { |value| #{filter} }"

lambda { |target, value| target.instance_exec(value, &l) }

next_callback.call env

else

user_callback.call(target, value) {

env = next_callback.call env

env.value

}

next_callback.call env

else

user_callback.call(target, value) {

env = next_callback.call env

env.value

}

end

end

next_callback.call env

}

end

private_class_method :halting

end

end

next_callback.call env

}

end

private_class_method :halting

runner = callbacks.compile

e = Filters::Environment.new(self, false, nil, block)

runner.call(e).value

end

end

runner = callbacks.compile

e = Filters::Environment.new(self, false, nil, block)

runner.call(e).value

end

end

module_eval <<-RUBY, __FILE__, __LINE__ + 1

def _run_#{name}_callbacks(&block)

_run_callbacks(_#{name}_callbacks, &block)

end

RUBY

end

# end

def run_callbacks(kind, &block)

send "_run_#{kind}_callbacks", &block

end

private

# process_action callbacks around the normal behavior.

def process_action(*args)

run_callbacks(:process_action) do

super

end

end

private

def process_action(*args)

super

rescue Exception => exception

request.env['action_dispatch.show_detailed_exceptions'] ||= show_detailed_exceptions?

rescue_with_handler(exception) || raise(exception)

ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|

result = super

payload[:status] = response.status

append_info_to_payload(payload)

result

def instrument(name, payload = {})

if notifier.listening?(name)

instrumenter.instrument(name, payload) { yield payload if block_given? }

else

yield payload if block_given?

end

start name, payload

begin

yield payload

rescue Exception => e

payload[:exception] = [e.class.name, e.message]

raise e

def instrument(name, payload = {})

if notifier.listening?(name)

instrumenter.instrument(name, payload) { yield payload if block_given? }

else

yield payload if block_given?

end

ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload.dup)

ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|

result = super

payload[:status] = response.status

append_info_to_payload(payload)

request.filtered_parameters.merge! wrapped_filtered_hash

end

super

end

private

# and it won't be cleaned up by the method below.

ActiveRecord::LogSubscriber.reset_runtime

super

end

def cleanup_view_runtime

@_response_body = nil

process_action(action_name, *args)

end

# Delegates to the class' #controller_path

def process(*) #:nodoc:

old_config, I18n.config = I18n.config, I18nProxy.new(I18n.config, lookup_context)

super

ensure

I18n.config = old_config

end

@_env = request.env

@_env['action_controller.instance'] = self

process(name)

to_a

end

def dispatch(action, request)

set_response!(request)

super(action, request)

end

def response_body=(body)

end

else

lambda { |env| new.dispatch(name, klass.new(env)) }

end

end

def dispatch(controller, action, env)

controller.action(action).call(env)

end

def normalize_controller!(params)

def dispatch(controller, action, env)

controller.action(action).call(env)

end

def normalize_controller!(params)

end

dispatch(controller, params[:action], req.env)

end

def prepare_params!(params)

req.path_parameters = set_params.merge parameters

status, headers, body = route.app.serve(req)

if 'pass' == headers['X-Cascade']

req.script_name = script_name

def serve(req)

find_routes(req).each do |match, parameters, route|

set_params = req.path_parameters

path_info = req.path_info

script_name = req.script_name

def serve(req)

find_routes(req).each do |match, parameters, route|

set_params = req.path_parameters

path_info = req.path_info

script_name = req.script_name

req = request_class.new(env)

req.path_info = Journey::Router::Utils.normalize_path(req.path_info)

@router.serve(req)

end

def recognize_path(path, environment = {})

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def traced_call(env)

@app.call(env)

end

end

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def traced_call(env)

result = @app.call(env) # [status, headers, response]

js_to_inject = NewRelic::Agent.browser_timing_header

if (js_to_inject != "") && should_instrument?(env, result[0], result[1])

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

end

@app.call(env)

end

# Checks to see if any redirect options were passed in

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

@check_after = Time.now.to_f + @dwell if @dwell

end

@app.call(env)

end

end

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

#p "-" * 100

#p env.inspect

@app.call(env)

end

end

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

env['warden'] = Proxy.new(env, self)

result = catch(:warden) do

@app.call(env)

end

result ||= {}

env['warden'] = Proxy.new(env, self)

result = catch(:warden) do

@app.call(env)

end

env['warden'] = Proxy.new(env, self)

result = catch(:warden) do

@app.call(env)

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

status, headers, body = @app.call(env)

if etag_status?(status) && etag_body?(body) && !skip_caching?(headers)

original_body = body

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

case env[REQUEST_METHOD]

when "GET", "HEAD"

status, headers, body = @app.call(env)

headers = Utils::HeaderHash.new(headers)

if status == 200 && fresh?(env, headers)

status = 304

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

status, headers, body = @app.call(env)

if env[REQUEST_METHOD] == HEAD

[

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

end

@app.call(env)

end

private

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

@app.call(env)

ensure

session = Request::Session.find(env) || {}

flash_hash = env[KEY]

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def context(env, app=@app)

prepare_session(env)

status, headers, body = app.call(env)

commit_session(env, status, headers, body)

end

def call(env)

context(env)

end

def context(env, app=@app)

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

status, headers, body = @app.call(env)

if cookie_jar = env['action_dispatch.cookies']

unless cookie_jar.committed?

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

connection.enable_query_cache!

response = @app.call(env)

response[2] = Rack::BodyProxy.new(response[2]) do

restore_query_cache_settings(connection_id, enabled)

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

# rubocop:disable Lint/RescueException

begin

response = @app.call(env)

rescue Exception => ex

notify_airbrake(ex, env)

raise ex

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

testing = env['rack.test']

response = @app.call(env)

response[2] = ::Rack::BodyProxy.new(response[2]) do

ActiveRecord::Base.clear_active_connections! unless testing

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

result = run_callbacks :call do

begin

@app.call(env)

rescue => error

end

end

def _run_callbacks(callbacks, &block)

if callbacks.empty?

block.call if block

else

runner = callbacks.compile

e = Filters::Environment.new(self, false, nil, block)

def _run_callbacks(callbacks, &block)

if callbacks.empty?

block.call if block

else

runner = callbacks.compile

e = Filters::Environment.new(self, false, nil, block)

module_eval <<-RUBY, __FILE__, __LINE__ + 1

def _run_#{name}_callbacks(&block)

_run_callbacks(_#{name}_callbacks, &block)

end

RUBY

end

# end

def run_callbacks(kind, &block)

send "_run_#{kind}_callbacks", &block

end

private

def call(env)

error = nil

result = run_callbacks :call do

begin

@app.call(env)

rescue => error

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

env["action_dispatch.remote_ip"] = GetIp.new(env, self)

@app.call(env)

end

# The GetIp class exists as a way to defer processing of the request data

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

better_errors_call env

else

@app.call env

end

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

_, headers, body = response = @app.call(env)

if headers['X-Cascade'] == 'pass'

body.close if body.respond_to?(:close)

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

@app.call(env)

rescue Exception => exception

if env['action_dispatch.show_exceptions'] == false

raise exception

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

instrumenter.start 'request.action_dispatch', request: request

logger.info { started_request_message(request) }

resp = @app.call(env)

resp[2] = ::Rack::BodyProxy.new(resp[2]) { finish(request) }

resp

rescue Exception

if logger.respond_to?(:tagged)

logger.tagged(compute_tags(request)) { call_app(request, env) }

else

call_app(request, env)

end

def tagged(*tags)

formatter.tagged(*tags) { yield self }

end

def flush

def tagged(*tags)

new_tags = push_tags(*tags)

yield self

ensure

pop_tags(new_tags.size)

end

def tagged(*tags)

formatter.tagged(*tags) { yield self }

end

def flush

if logger.respond_to?(:tagged)

logger.tagged(compute_tags(request)) { call_app(request, env) }

else

call_app(request, env)

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

RequestStore.begin!

@app.call(env)

ensure

RequestStore.end!

RequestStore.clear!

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

env["action_dispatch.request_id"] = external_request_id(env) || internal_request_id

@app.call(env).tap { |_status, headers, _body| headers["X-Request-Id"] = env["action_dispatch.request_id"] }

end

private

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

end

@app.call(env)

end

def method_override(env)

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

start_time = clock_time

status, headers, body = @app.call(env)

request_time = clock_time - start_time

if !headers.has_key?(@header_name)

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

LocalCacheRegistry.set_cache_for(local_cache_key, LocalStore.new)

response = @app.call(env)

response[2] = ::Rack::BodyProxy.new(response[2]) do

LocalCacheRegistry.set_cache_for(local_cache_key, nil)

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

old, env[FLAG] = env[FLAG], false

@mutex.lock

response = @app.call(env)

body = BodyProxy.new(response[2]) { @mutex.unlock }

response[2] = body

response

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

end

@app.call(env)

end

end

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

def call(env)

status, headers, body = @app.call(env)

if body.respond_to?(:to_path)

case type = variation(env)

when 'X-Accel-Redirect'

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

env["ROUTES_#{routes.object_id}_SCRIPT_NAME"] = env['SCRIPT_NAME'].dup

end

app.call(env)

end

# Defines additional Rack env configuration that is added on each call.

env["ORIGINAL_FULLPATH"] = build_original_fullpath(env)

env["ORIGINAL_SCRIPT_NAME"] = env["SCRIPT_NAME"]

super(env)

end

# Reload application routes regardless if they changed or not.

def method_missing(name, *args, &block)

if instance.respond_to?(name)

instance.public_send(name, *args, &block)

else

super

end

def method_missing(name, *args, &block)

if instance.respond_to?(name)

instance.public_send(name, *args, &block)

else

super

end

events.notify(:before_call, env) if first_middleware

result = (target == self) ? traced_call(env) : target.call(env)

if first_middleware

capture_response_attributes(state, result)

env['PATH_INFO'] = rest

return app.call(env)

end

[404, {CONTENT_TYPE => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path}"]]

sPort = env['SERVER_PORT']

@mapping.each do |host, location, match, app|

unless casecmp?(hHost, host) \

|| casecmp?(sName, host) \

|| (!host && (casecmp?(hHost, sName) ||

sPort = env['SERVER_PORT']

@mapping.each do |host, location, match, app|

unless casecmp?(hHost, host) \

|| casecmp?(sName, host) \

|| (!host && (casecmp?(hHost, sName) ||

begin

status, headers, body = @app.call(env)

rescue => e

if !should_swallow_app_error?(e, socket_wrapper)

# It's a good idea to catch application exceptions here because

begin

if headers[REQUEST_METHOD] == GET

process_request(headers, connection, socket_wrapper, @protocol == :http)

elsif headers[REQUEST_METHOD] == PING

process_ping(headers, connection)

false

finish_callback.call

while true

hijacked = accept_and_process_next_request(socket_wrapper, channel, buffer)

socket_wrapper = Utils::UnseekableSocket.new if hijacked

end

rescue Interrupted

handler = thread_handler.new(self, main_socket_options)

handler.install

handler.main_loop(set_initialization_state_to_true)

ensure

set_initialization_state.call(false)

unregister_current_thread

Thread.current.abort_on_exception = true

begin

yield(*args)

rescue SystemExit

raise

rescue Exception => e