services/api/app/controllers/application_controller.rb

   1 # Copyright (C) The Arvados Authors. All rights reserved.
   2 #
   3 # SPDX-License-Identifier: AGPL-3.0
   4
   5 require 'safe_json'
   6 require 'request_error'
   7
   8 module ApiTemplateOverride
   9   def allowed_to_render?(fieldset, field, model, options)
  10     return false if !super
  11     if options[:select]
  12       options[:select].include? field.to_s
  13     else
  14       true
  15     end
  16   end
  17 end
  18
  19 class ActsAsApi::ApiTemplate
  20   prepend ApiTemplateOverride
  21 end
  22
  23 require 'load_param'
  24
  25 class ApplicationController < ActionController::Base
  26   include CurrentApiClient
  27   include LoadParam
  28   include DbCurrentTime
  29
  30   respond_to :json
  31
  32   # Although CSRF protection is already enabled by default, this is
  33   # still needed to reposition CSRF checks later in callback order.
  34   protect_from_forgery
  35
  36   ERROR_ACTIONS = [:render_error, :render_not_found]
  37
  38   around_action :set_current_request_id
  39   before_action :disable_api_methods
  40   before_action :set_cors_headers
  41   before_action :respond_with_json_by_default
  42   before_action :remote_ip
  43   before_action :load_read_auths
  44   before_action :require_auth_scope, except: ERROR_ACTIONS
  45
  46   before_action :catch_redirect_hint
  47   before_action :load_required_parameters
  48   before_action :load_limit_offset_order_params, only: [:index, :contents]
  49   before_action :load_select_param
  50   before_action(:find_object_by_uuid,
  51                 except: [:index, :create, :update] + ERROR_ACTIONS)
  52   before_action :find_object_for_update, only: [:update]
  53   before_action :load_where_param, only: [:index, :contents]
  54   before_action :load_filters_param, only: [:index, :contents]
  55   before_action :find_objects_for_index, :only => :index
  56   before_action(:set_nullable_attrs_to_null, only: [:update, :create])
  57   before_action :reload_object_before_update, :only => :update
  58   before_action(:render_404_if_no_object,
  59                 except: [:index, :create] + ERROR_ACTIONS)
  60   before_action :only_admin_can_bypass_federation
  61
  62   attr_writer :resource_attrs
  63
  64   begin
  65     rescue_from(Exception,
  66                 ArvadosModel::PermissionDeniedError,
  67                 :with => :render_error)
  68     rescue_from(ActiveRecord::RecordNotFound,
  69                 ActionController::RoutingError,
  70                 AbstractController::ActionNotFound,
  71                 :with => :render_not_found)
  72   end
  73
  74   def initialize *args
  75     super
  76     @object = nil
  77     @objects = nil
  78     @offset = nil
  79     @limit = nil
  80     @select = nil
  81     @distinct = nil
  82     @response_resource_name = nil
  83     @attrs = nil
  84     @extra_included = nil
  85   end
  86
  87   def default_url_options
  88     options = {}
  89     if Rails.configuration.Services.Controller.ExternalURL != URI("")
  90       exturl = Rails.configuration.Services.Controller.ExternalURL
  91       options[:host] = exturl.host
  92       options[:port] = exturl.port
  93       options[:protocol] = exturl.scheme
  94     end
  95     options
  96   end
  97
  98   def index
  99     if params[:eager] and params[:eager] != '0' and params[:eager] != 0 and params[:eager] != ''
 100       @objects.each(&:eager_load_associations)
 101     end
 102     render_list
 103   end
 104
 105   def show
 106     send_json @object.as_api_response(nil, select: select_for_klass(@select, model_class))
 107   end
 108
 109   def create
 110     @object = model_class.new resource_attrs
 111
 112     if @object.respond_to?(:name) && params[:ensure_unique_name]
 113       @object.save_with_unique_name!
 114     else
 115       @object.save!
 116     end
 117
 118     show
 119   end
 120
 121   def update
 122     attrs_to_update = resource_attrs.reject { |k,v|
 123       [:kind, :etag, :href].index k
 124     }
 125     @object.update! attrs_to_update
 126     show
 127   end
 128
 129   def destroy
 130     @object.destroy
 131     show
 132   end
 133
 134   def catch_redirect_hint
 135     if !current_user
 136       if params.has_key?('redirect_to') then
 137         session[:redirect_to] = params[:redirect_to]
 138       end
 139     end
 140   end
 141
 142   def render_404_if_no_object
 143     render_not_found "Object not found" if !@object
 144   end
 145
 146   def only_admin_can_bypass_federation
 147     unless !params[:bypass_federation] || current_user.andand.is_admin
 148       send_error("The bypass_federation parameter is only permitted when current user is admin", status: 403)
 149     end
 150   end
 151
 152   def render_error(e)
 153     logger.error e.inspect
 154     if e.respond_to? :backtrace and e.backtrace
 155       # This will be cleared by lograge after adding it to the log.
 156       # Usually lograge would get the exceptions, but in our case we're catching
 157       # all of them with exception handlers that cannot re-raise them because they
 158       # don't get propagated.
 159       Thread.current[:exception] = e.inspect
 160       Thread.current[:backtrace] = e.backtrace.collect { |x| x + "\n" }.join('')
 161     end
 162     if (@object.respond_to? :errors and
 163         @object.errors.andand.full_messages.andand.any?)
 164       errors = @object.errors.full_messages
 165       logger.error errors.inspect
 166     else
 167       errors = [e.inspect]
 168     end
 169     status = e.respond_to?(:http_status) ? e.http_status : 422
 170     send_error(*errors, status: status)
 171   end
 172
 173   def render_not_found(e=ActionController::RoutingError.new("Path not found"))
 174     logger.error e.inspect
 175     send_error("Path not found", status: 404)
 176   end
 177
 178   def render_accepted
 179     send_json ({accepted: true}), status: 202
 180   end
 181
 182   protected
 183
 184   def bool_param(pname)
 185     if params.include?(pname)
 186       if params[pname].is_a?(Boolean)
 187         return params[pname]
 188       else
 189         logger.warn "Warning: received non-boolean value #{params[pname].inspect} for boolean parameter #{pname} on #{self.class.inspect}, treating as false."
 190       end
 191     end
 192     false
 193   end
 194
 195   def send_error(*args)
 196     if args.last.is_a? Hash
 197       err = args.pop
 198     else
 199       err = {}
 200     end
 201     err[:errors] ||= args
 202     err[:errors].map! do |err|
 203       err += " (#{request.request_id})"
 204     end
 205     err[:error_token] = [Time.now.utc.to_i, "%08x" % rand(16 ** 8)].join("+")
 206     status = err.delete(:status) || 422
 207     logger.error "Error #{err[:error_token]}: #{status}"
 208     send_json err, status: status
 209   end
 210
 211   def send_json response, opts={}
 212     # The obvious render(json: ...) forces a slow JSON encoder. See
 213     # #3021 and commit logs. Might be fixed in Rails 4.1.
 214     render({
 215              plain: SafeJSON.dump(response).html_safe,
 216              content_type: 'application/json'
 217            }.merge opts)
 218   end
 219
 220   def find_objects_for_index
 221     @objects ||= model_class.readable_by(*@read_users, {
 222       :include_trash => (bool_param(:include_trash) || 'untrash' == action_name),
 223       :include_old_versions => bool_param(:include_old_versions)
 224     })
 225     apply_where_limit_order_params
 226   end
 227
 228   def apply_filters model_class=nil
 229     model_class ||= self.model_class
 230     @objects = model_class.apply_filters(@objects, @filters)
 231   end
 232
 233   def select_for_klass sel, model_class, raise_unknown=true
 234     return nil if sel.nil?
 235     # Filter the select fields to only the ones that apply to the
 236     # given class.
 237     sel.map do |column|
 238       sp = column.split(".")
 239       if sp.length == 2 && sp[0] == model_class.table_name && model_class.selectable_attributes.include?(sp[1])
 240         sp[1]
 241       elsif model_class.selectable_attributes.include? column
 242         column
 243       elsif raise_unknown
 244         raise ArgumentError.new("Invalid attribute '#{column}' of #{model_class.name} in select parameter")
 245       else
 246         nil
 247       end
 248     end.compact
 249   end
 250
 251   def apply_where_limit_order_params model_class=nil
 252     model_class ||= self.model_class
 253     apply_filters model_class
 254
 255     ar_table_name = @objects.table_name
 256     if @where.is_a? Hash and @where.any?
 257       conditions = ['1=1']
 258       @where.each do |attr,value|
 259         if attr.to_s == 'any'
 260           if value.is_a?(Array) and
 261               value.length == 2 and
 262               value[0] == 'contains' then
 263             ilikes = []
 264             model_class.searchable_columns('ilike').each do |column|
 265               # Including owner_uuid in an "any column" search will
 266               # probably just return a lot of false positives.
 267               next if column == 'owner_uuid'
 268               ilikes << "#{ar_table_name}.#{column} ilike ?"
 269               conditions << "%#{value[1]}%"
 270             end
 271             if ilikes.any?
 272               conditions[0] << ' and (' + ilikes.join(' or ') + ')'
 273             end
 274           end
 275         elsif attr.to_s.match(/^[a-z][_a-z0-9]+$/) and
 276             model_class.columns.collect(&:name).index(attr.to_s)
 277           if value.nil?
 278             conditions[0] << " and #{ar_table_name}.#{attr} is ?"
 279             conditions << nil
 280           elsif value.is_a? Array
 281             if value[0] == 'contains' and value.length == 2
 282               conditions[0] << " and #{ar_table_name}.#{attr} like ?"
 283               conditions << "%#{value[1]}%"
 284             else
 285               conditions[0] << " and #{ar_table_name}.#{attr} in (?)"
 286               conditions << value
 287             end
 288           elsif value.is_a? String or value.is_a? Integer or value == true or value == false
 289             conditions[0] << " and #{ar_table_name}.#{attr}=?"
 290             conditions << value
 291           elsif value.is_a? Hash
 292             # Not quite the same thing as "equal?" but better than nothing?
 293             value.each do |k,v|
 294               if v.is_a? String
 295                 conditions[0] << " and #{ar_table_name}.#{attr} ilike ?"
 296                 conditions << "%#{k}%#{v}%"
 297               end
 298             end
 299           end
 300         end
 301       end
 302       if conditions.length > 1
 303         conditions[0].sub!(/^1=1 and /, '')
 304         @objects = @objects.
 305           where(*conditions)
 306       end
 307     end
 308
 309     if @select
 310       unless action_name.in? %w(create update destroy)
 311         # Map attribute names in @select to real column names, resolve
 312         # those to fully-qualified SQL column names, and pass the
 313         # resulting string to the select method.
 314         columns_list = model_class.columns_for_attributes(select_for_klass @select, model_class).
 315           map { |s| "#{ar_table_name}.#{ActiveRecord::Base.connection.quote_column_name s}" }
 316         @objects = @objects.select(columns_list.join(", "))
 317       end
 318
 319       # This information helps clients understand what they're seeing
 320       # (Workbench always expects it), but they can't select it explicitly
 321       # because it's not an SQL column.  Always add it.
 322       # (This is harmless, given that clients can deduce what they're
 323       # looking at by the returned UUID anyway.)
 324       @select |= ["kind"]
 325     end
 326     @objects = @objects.order(@orders.join ", ") if @orders.any?
 327     @objects = @objects.limit(@limit)
 328     @objects = @objects.offset(@offset)
 329     @objects = @objects.distinct() if @distinct
 330   end
 331
 332   # limit_database_read ensures @objects (which must be an
 333   # ActiveRelation) does not return too many results to fit in memory,
 334   # by previewing the results and calling @objects.limit() if
 335   # necessary.
 336   def limit_database_read(model_class:)
 337     return if @limit == 0 || @limit == 1
 338     model_class ||= self.model_class
 339     limit_columns = model_class.limit_index_columns_read
 340     limit_columns &= model_class.columns_for_attributes(select_for_klass @select, model_class) if @select
 341     return if limit_columns.empty?
 342     model_class.transaction do
 343       limit_query = @objects.
 344         except(:select, :distinct).
 345         select("(%s) as read_length" %
 346                limit_columns.map { |s| "octet_length(#{model_class.table_name}.#{s})" }.join(" + "))
 347       new_limit = 0
 348       read_total = 0
 349       limit_query.each do |record|
 350         new_limit += 1
 351         read_total += record.read_length.to_i
 352         if read_total >= Rails.configuration.API.MaxIndexDatabaseRead
 353           new_limit -= 1 if new_limit > 1
 354           @limit = new_limit
 355           break
 356         elsif new_limit >= @limit
 357           break
 358         end
 359       end
 360       @objects = @objects.limit(@limit)
 361       # Force @objects to run its query inside this transaction.
 362       @objects.each { |_| break }
 363     end
 364   end
 365
 366   def resource_attrs
 367     return @attrs if @attrs
 368     @attrs = params[resource_name]
 369     if @attrs.nil?
 370       @attrs = {}
 371     elsif @attrs.is_a? String
 372       @attrs = Oj.strict_load @attrs, symbol_keys: true
 373     end
 374     unless [Hash, ActionController::Parameters].include? @attrs.class
 375       message = "No #{resource_name}"
 376       if resource_name.index('_')
 377         message << " (or #{resource_name.camelcase(:lower)})"
 378       end
 379       message << " hash provided with request"
 380       raise ArgumentError.new(message)
 381     end
 382     %w(created_at modified_by_client_uuid modified_by_user_uuid modified_at).each do |x|
 383       @attrs.delete x.to_sym
 384     end
 385     @attrs = @attrs.symbolize_keys if @attrs.is_a? ActiveSupport::HashWithIndifferentAccess
 386     @attrs
 387   end
 388
 389   # Authentication
 390   def load_read_auths
 391     @read_auths = []
 392     if current_api_client_authorization
 393       @read_auths << current_api_client_authorization
 394     end
 395     # Load reader tokens if this is a read request.
 396     # If there are too many reader tokens, assume the request is malicious
 397     # and ignore it.
 398     if request.get? and params[:reader_tokens] and
 399       params[:reader_tokens].size < 100
 400       secrets = params[:reader_tokens].map { |t|
 401         if t.is_a? String and t.starts_with? "v2/"
 402           t.split("/")[2]
 403         else
 404           t
 405         end
 406       }
 407       @read_auths += ApiClientAuthorization
 408         .includes(:user)
 409         .where('api_token IN (?) AND
 410                 (expires_at IS NULL OR expires_at > CURRENT_TIMESTAMP)',
 411                secrets)
 412         .to_a
 413     end
 414     @read_auths.select! { |auth| auth.scopes_allow_request? request }
 415     @read_users = @read_auths.map(&:user).uniq
 416   end
 417
 418   def require_login
 419     if not current_user
 420       respond_to do |format|
 421         format.json { send_error("Not logged in", status: 401) }
 422         format.html { redirect_to '/login' }
 423       end
 424       false
 425     end
 426   end
 427
 428   def admin_required
 429     unless current_user and current_user.is_admin
 430       send_error("Forbidden", status: 403)
 431     end
 432   end
 433
 434   def require_auth_scope
 435     unless current_user && @read_auths.any? { |auth| auth.user.andand.uuid == current_user.uuid }
 436       if require_login != false
 437         send_error("Forbidden", status: 403)
 438       end
 439       false
 440     end
 441   end
 442
 443   def set_current_request_id
 444     Rails.logger.tagged(request.request_id) do
 445       yield
 446     end
 447   end
 448
 449   def append_info_to_payload(payload)
 450     super
 451     payload[:request_id] = request.request_id
 452     payload[:client_ipaddr] = @remote_ip
 453     payload[:client_auth] = current_api_client_authorization.andand.uuid || nil
 454   end
 455
 456   def disable_api_methods
 457     if Rails.configuration.API.DisabledAPIs[controller_name + "." + action_name]
 458       send_error("Disabled", status: 404)
 459     end
 460   end
 461
 462   def set_cors_headers
 463     response.headers['Access-Control-Allow-Origin'] = '*'
 464     response.headers['Access-Control-Allow-Methods'] = 'GET, HEAD, PUT, POST, DELETE'
 465     response.headers['Access-Control-Allow-Headers'] = 'Authorization, Content-Type'
 466     response.headers['Access-Control-Max-Age'] = '86486400'
 467   end
 468
 469   def respond_with_json_by_default
 470     html_index = request.accepts.index(Mime[:html])
 471     if html_index.nil? or request.accepts[0...html_index].include?(Mime[:json])
 472       request.format = :json
 473     end
 474   end
 475
 476   def model_class
 477     controller_name.classify.constantize
 478   end
 479
 480   def resource_name             # params[] key used by client
 481     controller_name.singularize
 482   end
 483
 484   def table_name
 485     controller_name
 486   end
 487
 488   def find_object_for_update
 489     find_object_by_uuid(with_lock: true)
 490   end
 491
 492   def find_object_by_uuid(with_lock: false)
 493     if params[:id] and params[:id].match(/\D/)
 494       params[:uuid] = params.delete :id
 495     end
 496     @where = { uuid: params[:uuid] }
 497     @offset = 0
 498     @limit = 1
 499     @orders = []
 500     @filters = []
 501     @objects = nil
 502
 503     # This is a little hacky but sometimes the fields the user wants
 504     # to selecting on are unrelated to the object being loaded here,
 505     # for example groups#contents, so filter the fields that will be
 506     # used in find_objects_for_index and then reset afterwards.  In
 507     # some cases, code that modifies the @select list needs to set
 508     # @preserve_select.
 509     @preserve_select = @select
 510     @select = select_for_klass(@select, self.model_class, false)
 511
 512     find_objects_for_index
 513     if with_lock && Rails.configuration.API.LockBeforeUpdate
 514       @object = @objects.lock.first
 515     else
 516       @object = @objects.first
 517     end
 518     @select = @preserve_select
 519   end
 520
 521   def nullable_attributes
 522     []
 523   end
 524
 525   # Go code may send empty values (ie: empty string instead of NULL) that
 526   # should be translated to NULL on the database.
 527   def set_nullable_attrs_to_null
 528     nullify_attrs(resource_attrs.to_hash).each do |k, v|
 529       resource_attrs[k] = v
 530     end
 531   end
 532
 533   def nullify_attrs(a = {})
 534     new_attrs = a.to_hash.symbolize_keys
 535     (new_attrs.keys & nullable_attributes).each do |attr|
 536       val = new_attrs[attr]
 537       if (val.class == Integer && val == 0) || (val.class == String && val == "")
 538         new_attrs[attr] = nil
 539       end
 540     end
 541     return new_attrs
 542   end
 543
 544   def reload_object_before_update
 545     # This is necessary to prevent an ActiveRecord::ReadOnlyRecord
 546     # error when updating an object which was retrieved using a join.
 547     if @object.andand.readonly?
 548       @object = model_class.find_by_uuid(@objects.first.uuid)
 549     end
 550   end
 551
 552   def load_json_value(hash, key, must_be_class=nil)
 553     return if hash[key].nil?
 554
 555     val = hash[key]
 556     if val.is_a? ActionController::Parameters
 557       val = val.to_unsafe_hash
 558     elsif val.is_a? String
 559       val = SafeJSON.load(val)
 560       hash[key] = val
 561     end
 562     # When assigning a Hash to an ActionController::Parameters and then
 563     # retrieve it, we get another ActionController::Parameters instead of
 564     # a Hash. This doesn't happen with other types. This is why 'val' is
 565     # being used to do type checking below.
 566     if must_be_class and !val.is_a? must_be_class
 567       raise TypeError.new("parameter #{key.to_s} must be a #{must_be_class.to_s}")
 568     end
 569   end
 570
 571   def self.accept_attribute_as_json(attr, must_be_class=nil)
 572     before_action lambda { accept_attribute_as_json attr, must_be_class }
 573   end
 574   accept_attribute_as_json :properties, Hash
 575   accept_attribute_as_json :info, Hash
 576   def accept_attribute_as_json(attr, must_be_class)
 577     if params[resource_name] and [Hash, ActionController::Parameters].include?(resource_attrs.class)
 578       if resource_attrs[attr].is_a? Hash
 579         # Convert symbol keys to strings (in hashes provided by
 580         # resource_attrs)
 581         resource_attrs[attr] = resource_attrs[attr].
 582           with_indifferent_access.to_hash
 583       else
 584         load_json_value(resource_attrs, attr, must_be_class)
 585       end
 586     end
 587   end
 588
 589   def self.accept_param_as_json(key, must_be_class=nil)
 590     prepend_before_action lambda { load_json_value(params, key, must_be_class) }
 591   end
 592   accept_param_as_json :reader_tokens, Array
 593
 594   def object_list(model_class:)
 595     if @objects.respond_to?(:except)
 596       limit_database_read(model_class: model_class)
 597     end
 598     list = {
 599       :kind  => "arvados##{(@response_resource_name || resource_name).camelize(:lower)}List",
 600       :etag => "",
 601       :self_link => "",
 602       :offset => @offset,
 603       :limit => @limit,
 604       :items => @objects.as_api_response(nil, {select: @select})
 605     }
 606     if @extra_included
 607       list[:included] = @extra_included.as_api_response(nil, {select: @select})
 608     end
 609     case params[:count]
 610     when nil, '', 'exact'
 611       if @objects.respond_to? :except
 612         list[:items_available] = @objects.
 613           except(:limit).except(:offset).
 614           count(@distinct ? :id : '*')
 615       end
 616     when 'none'
 617     else
 618       raise ArgumentError.new("count parameter must be 'exact' or 'none'")
 619     end
 620     list
 621   end
 622
 623   def render_list
 624     send_json object_list(model_class: self.model_class)
 625   end
 626
 627   def remote_ip
 628     # Caveat: this is highly dependent on the proxy setup. YMMV.
 629     if request.headers.key?('HTTP_X_REAL_IP') then
 630       # We're behind a reverse proxy
 631       @remote_ip = request.headers['HTTP_X_REAL_IP']
 632     else
 633       # Hopefully, we are not!
 634       @remote_ip = request.env['REMOTE_ADDR']
 635     end
 636   end
 637
 638   def load_required_parameters
 639     (self.class.send "_#{params[:action]}_requires_parameters" rescue {}).
 640       each do |key, info|
 641       if info[:required] and not params.include?(key)
 642         raise ArgumentError.new("#{key} parameter is required")
 643       elsif info[:type] == 'boolean'
 644         # Make sure params[key] is either true or false -- not a
 645         # string, not nil, etc.
 646         if not params.include?(key)
 647           params[key] = info[:default] || false
 648         elsif [false, 'false', '0', 0].include? params[key]
 649           params[key] = false
 650         elsif [true, 'true', '1', 1].include? params[key]
 651           params[key] = true
 652         else
 653           raise TypeError.new("#{key} parameter must be a boolean, true or false")
 654         end
 655       end
 656     end
 657     true
 658   end
 659
 660   def self._create_requires_parameters
 661     {
 662       select: {
 663         type: 'array',
 664         description: "Attributes of the new object to return in the response.",
 665         required: false,
 666       },
 667       ensure_unique_name: {
 668         type: "boolean",
 669         description: "Adjust name to ensure uniqueness instead of returning an error on (owner_uuid, name) collision.",
 670         location: "query",
 671         required: false,
 672         default: false
 673       },
 674       cluster_id: {
 675         type: 'string',
 676         description: "Create object on a remote federated cluster instead of the current one.",
 677         location: "query",
 678         required: false,
 679       },
 680     }
 681   end
 682
 683   def self._update_requires_parameters
 684     {
 685       select: {
 686         type: 'array',
 687         description: "Attributes of the updated object to return in the response.",
 688         required: false,
 689       },
 690     }
 691   end
 692
 693   def self._show_requires_parameters
 694     {
 695       select: {
 696         type: 'array',
 697         description: "Attributes of the object to return in the response.",
 698         required: false,
 699       },
 700     }
 701   end
 702
 703   def self._index_requires_parameters
 704     {
 705       filters: { type: 'array', required: false },
 706       where: { type: 'object', required: false },
 707       order: { type: 'array', required: false },
 708       select: {
 709         type: 'array',
 710         description: "Attributes of each object to return in the response.",
 711         required: false,
 712       },
 713       distinct: { type: 'boolean', required: false, default: false },
 714       limit: { type: 'integer', required: false, default: DEFAULT_LIMIT },
 715       offset: { type: 'integer', required: false, default: 0 },
 716       count: { type: 'string', required: false, default: 'exact' },
 717       cluster_id: {
 718         type: 'string',
 719         description: "List objects on a remote federated cluster instead of the current one.",
 720         location: "query",
 721         required: false,
 722       },
 723       bypass_federation: {
 724         type: 'boolean',
 725         required: false,
 726         description: 'bypass federation behavior, list items from local instance database only'
 727       }
 728     }
 729   end
 730
 731   def render *opts
 732     if opts.first
 733       response = opts.first[:json]
 734       if response.is_a?(Hash) &&
 735           params[:_profile] &&
 736           Thread.current[:request_starttime]
 737         response[:_profile] = {
 738           request_time: Time.now - Thread.current[:request_starttime]
 739         }
 740       end
 741     end
 742     super(*opts)
 743   end
 744 end