Remove all code related to Gitlab::RequestProfile

Changelog: removed

.rubocop_todo.yml

@@ -160,7 +160,6 @@ Lint/MixedRegexpCaptureTypes:
     - 'lib/gitlab/diff/suggestions_parser.rb'
     - 'lib/gitlab/github_import/representation/note.rb'
     - 'lib/gitlab/metrics/system.rb'
-    - 'lib/gitlab/request_profiler/profile.rb'
     - 'lib/gitlab/slash_commands/issue_move.rb'
     - 'lib/gitlab/slash_commands/issue_new.rb'
     - 'lib/gitlab/slash_commands/run.rb'

.rubocop_todo/gitlab/namespaced_class.yml

@@ -875,7 +875,6 @@ Gitlab/NamespacedClass:
   - app/workers/repository_import_worker.rb
   - app/workers/repository_remove_remote_worker.rb
   - app/workers/repository_update_remote_mirror_worker.rb
-  - app/workers/requests_profiles_worker.rb
   - app/workers/run_pipeline_schedule_worker.rb
   - app/workers/schedule_merge_request_cleanup_refs_worker.rb
   - app/workers/schedule_migrate_external_diffs_worker.rb

app/controllers/admin/requests_profiles_controller.rb

-# frozen_string_literal: true
-
-class Admin::RequestsProfilesController < Admin::ApplicationController
-  feature_category :not_owned
-
-  def index
-    @profile_token = Gitlab::RequestProfiler.profile_token
-    @profiles      = Gitlab::RequestProfiler.all.group_by(&:request_path)
-  end
-
-  def show
-    clean_name = Rack::Utils.clean_path_info(params[:name])
-    profile    = Gitlab::RequestProfiler.find(clean_name)
-
-    unless profile && profile.content_type
-      return redirect_to admin_requests_profiles_path, alert: 'Profile not found'
-    end
-
-    send_file profile.file_path, type: "#{profile.content_type}; charset=utf-8", disposition: 'inline'
-  end
-end

app/helpers/nav_helper.rb

@@ -56,7 +56,7 @@ module NavHelper
   end
 
   def admin_monitoring_nav_links
-    %w(system_info background_migrations background_jobs health_check requests_profiles)
+    %w(system_info background_migrations background_jobs health_check)
   end
 
   def admin_analytics_nav_links

app/views/admin/requests_profiles/index.html.haml

-- page_title _('Requests Profiles')
-
-%h3.page-title
-  = page_title
-
-.bs-callout.clearfix
-  = html_escape(_('Pass the header %{codeOpen} X-Profile-Token: %{profile_token} %{codeClose} to profile the request')) % { profile_token: @profile_token, codeOpen: '<code>'.html_safe, codeClose: '</code>'.html_safe }
-
-- if @profiles.present?
-  .gl-mt-3
-    - @profiles.each do |path, profiles|
-      .card
-        .card-header
-          %code= path
-        %ul.content-list
-          - profiles.each do |profile|
-            %li
-              = link_to profile.time.to_s(:long) + ' ' + profile.profile_mode.capitalize,
-                admin_requests_profile_path(profile)
-- else
-  %p
-    = _('No profiles found')

app/views/layouts/nav/sidebar/_admin.html.haml

@@ -103,10 +103,6 @@
             = link_to admin_health_check_path, title: _('Health Check') do
               %span
                 = _('Health Check')
-          = nav_link(controller: :requests_profiles) do
-            = link_to admin_requests_profiles_path, title: _('Requests Profiles') do
-              %span
-                = _('Requests Profiles')
           - if Gitlab::CurrentSettings.current_application_settings.grafana_enabled?
             = nav_link do
               = link_to Gitlab::CurrentSettings.current_application_settings.grafana_url, target: '_blank', title: _('Metrics Dashboard'), rel: 'noopener noreferrer' do

app/workers/all_queues.yml

@@ -597,15 +597,6 @@
   :weight: 1
   :idempotent:
   :tags: []
-- :name: cronjob:requests_profiles
-  :worker_name: RequestsProfilesWorker
-  :feature_category: :source_code_management
-  :has_external_dependencies:
-  :urgency: :low
-  :resource_boundary: :unknown
-  :weight: 1
-  :idempotent:
-  :tags: []
 - :name: cronjob:schedule_merge_request_cleanup_refs
   :worker_name: ScheduleMergeRequestCleanupRefsWorker
   :feature_category: :code_review

app/workers/requests_profiles_worker.rb

-# frozen_string_literal: true
-
-class RequestsProfilesWorker # rubocop:disable Scalability/IdempotentWorker
-  include ApplicationWorker
-
-  data_consistency :always
-
-  # rubocop:disable Scalability/CronWorkerContext
-  # This worker does not perform work scoped to a context
-  include CronjobQueue
-  # rubocop:enable Scalability/CronWorkerContext
-
-  feature_category :source_code_management
-
-  def perform
-    Gitlab::RequestProfiler.remove_all_profiles
-  end
-end

config/initializers/1_settings.rb

@@ -479,9 +479,6 @@ Settings.cron_jobs['import_export_project_cleanup_worker']['job_class'] = 'Impor
 Settings.cron_jobs['ci_archive_traces_cron_worker'] ||= Settingslogic.new({})
 Settings.cron_jobs['ci_archive_traces_cron_worker']['cron'] ||= '17 * * * *'
 Settings.cron_jobs['ci_archive_traces_cron_worker']['job_class'] = 'Ci::ArchiveTracesCronWorker'
-Settings.cron_jobs['requests_profiles_worker'] ||= Settingslogic.new({})
-Settings.cron_jobs['requests_profiles_worker']['cron'] ||= '0 0 * * *'
-Settings.cron_jobs['requests_profiles_worker']['job_class'] = 'RequestsProfilesWorker'
 Settings.cron_jobs['remove_expired_members_worker'] ||= Settingslogic.new({})
 Settings.cron_jobs['remove_expired_members_worker']['cron'] ||= '10 0 * * *'
 Settings.cron_jobs['remove_expired_members_worker']['job_class'] = 'RemoveExpiredMembersWorker'

config/initializers/request_profiler.rb

 # frozen_string_literal: true
 
 Rails.application.configure do |config|
-  config.middleware.use(Gitlab::RequestProfiler::Middleware)
   config.middleware.use(Gitlab::Middleware::Speedscope)
 end

config/routes/admin.rb

@@ -100,7 +100,6 @@ namespace :admin do
   resource :background_jobs, controller: 'background_jobs', only: [:show]
 
   resource :system_info, controller: 'system_info', only: [:show]
-  resources :requests_profiles, only: [:index, :show], param: :name, constraints: { name: /.+\.(html|txt)/ }
 
   resources :projects, only: [:index]
 

lib/gitlab/backtrace_cleaner.rb

@@ -17,7 +17,6 @@ module Gitlab
       lib/gitlab/profiler.rb
       lib/gitlab/query_limiting/
       lib/gitlab/request_context.rb
-      lib/gitlab/request_profiler/
       lib/gitlab/sidekiq_logging/
       lib/gitlab/sidekiq_middleware/
       lib/gitlab/sidekiq_status/

lib/gitlab/profiler.rb

@@ -16,7 +16,6 @@ module Gitlab
       lib/gitlab/middleware/
       ee/lib/gitlab/middleware/
       lib/gitlab/performance_bar/
-      lib/gitlab/request_profiler/
       lib/gitlab/query_limiting/
       lib/gitlab/tracing/
       lib/gitlab/profiler.rb

lib/gitlab/request_profiler.rb

-# frozen_string_literal: true
-
-require 'fileutils'
-
-module Gitlab
-  module RequestProfiler
-    PROFILES_DIR = "#{Gitlab.config.shared.path}/tmp/requests_profiles"
-
-    def all
-      Dir["#{PROFILES_DIR}/*.{html,txt}"].map do |path|
-        Profile.new(File.basename(path))
-      end.select(&:valid?)
-    end
-    module_function :all # rubocop: disable Style/AccessModifierDeclarations
-
-    def find(name)
-      file_path = File.join(PROFILES_DIR, name)
-      return unless File.exist?(file_path)
-
-      Profile.new(name)
-    end
-    module_function :find # rubocop: disable Style/AccessModifierDeclarations
-
-    def profile_token
-      Rails.cache.fetch('profile-token') do
-        Devise.friendly_token
-      end
-    end
-    module_function :profile_token # rubocop: disable Style/AccessModifierDeclarations
-
-    def remove_all_profiles
-      FileUtils.rm_rf(PROFILES_DIR)
-    end
-    module_function :remove_all_profiles # rubocop: disable Style/AccessModifierDeclarations
-  end
-end

lib/gitlab/request_profiler/middleware.rb

-# frozen_string_literal: true
-
-require 'ruby-prof'
-require 'memory_profiler'
-
-module Gitlab
-  module RequestProfiler
-    class Middleware
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        if profile?(env)
-          call_with_profiling(env)
-        else
-          @app.call(env)
-        end
-      end
-
-      def profile?(env)
-        header_token = env['HTTP_X_PROFILE_TOKEN']
-        return unless header_token.present?
-
-        profile_token = Gitlab::RequestProfiler.profile_token
-        return unless profile_token.present?
-
-        header_token == profile_token
-      end
-
-      def call_with_profiling(env)
-        case env['HTTP_X_PROFILE_MODE']
-        when 'execution', nil
-          call_with_call_stack_profiling(env)
-        when 'memory'
-          call_with_memory_profiling(env)
-        else
-          raise ActionController::BadRequest, invalid_profile_mode(env)
-        end
-      end
-
-      def invalid_profile_mode(env)
-        <<~HEREDOC
-          Invalid X-Profile-Mode: #{env['HTTP_X_PROFILE_MODE']}.
-          Supported profile mode request header:
-            - X-Profile-Mode: execution
-            - X-Profile-Mode: memory
-        HEREDOC
-      end
-
-      def call_with_call_stack_profiling(env)
-        ret = nil
-        report = RubyProf::Profile.profile do
-          ret = catch(:warden) do # rubocop:disable Cop/BanCatchThrow
-            @app.call(env)
-          end
-        end
-
-        generate_report(env, 'execution', 'html') do |file|
-          printer = RubyProf::CallStackPrinter.new(report)
-          printer.print(file)
-        end
-
-        handle_request_ret(ret)
-      end
-
-      def call_with_memory_profiling(env)
-        ret = nil
-        report = MemoryProfiler.report do
-          ret = catch(:warden) do # rubocop:disable Cop/BanCatchThrow
-            @app.call(env)
-          end
-        end
-
-        generate_report(env, 'memory', 'txt') do |file|
-          report.pretty_print(to_file: file)
-        end
-
-        handle_request_ret(ret)
-      end
-
-      def generate_report(env, report_type, extension)
-        file_name = "#{env['PATH_INFO'].tr('/', '|')}_#{Time.current.to_i}"\
-                    "_#{report_type}.#{extension}"
-        file_path = "#{PROFILES_DIR}/#{file_name}"
-
-        FileUtils.mkdir_p(PROFILES_DIR)
-
-        begin
-          File.open(file_path, 'wb') do |file|
-            yield(file)
-          end
-        rescue StandardError
-          FileUtils.rm(file_path)
-        end
-      end
-
-      def handle_request_ret(ret)
-        if ret.is_a?(Array)
-          ret
-        else
-          throw(:warden, ret) # rubocop:disable Cop/BanCatchThrow
-        end
-      end
-    end
-  end
-end

lib/gitlab/request_profiler/profile.rb

-# frozen_string_literal: true
-
-module Gitlab
-  module RequestProfiler
-    class Profile
-      attr_reader :name, :time, :file_path, :request_path, :profile_mode, :type
-
-      alias_method :to_param, :name
-
-      def initialize(name)
-        @name = name
-        @file_path = File.join(PROFILES_DIR, name)
-
-        set_attributes
-      end
-
-      def valid?
-        @request_path.present?
-      end
-
-      def content_type
-        case type
-        when 'html'
-          'text/html'
-        when 'txt'
-          'text/plain'
-        end
-      end
-
-      private
-
-      def set_attributes
-        matches = name.match(/^(?<path>.*)_(?<timestamp>\d+)(_(?<profile_mode>\w+))?\.(?<type>html|txt)$/)
-        return unless matches
-
-        @request_path      = matches[:path].tr('|', '/')
-        @time              = Time.at(matches[:timestamp].to_i).utc
-        @profile_mode      = matches[:profile_mode] || 'unknown'
-        @type              = matches[:type]
-      end
-    end
-  end
-end

locale/gitlab.pot

@@ -24141,9 +24141,6 @@ msgstr ""
 msgid "No prioritized labels with such name or description"
 msgstr ""
 
-msgid "No profiles found"
-msgstr ""
-
 msgid "No project subscribes to the pipelines in this project."
 msgstr ""
 
@@ -25691,9 +25688,6 @@ msgstr ""
 msgid "Pass job variables"
 msgstr ""
 
-msgid "Pass the header %{codeOpen} X-Profile-Token: %{profile_token} %{codeClose} to profile the request"
-msgstr ""
-
 msgid "Passed"
 msgstr ""
 
@@ -30292,9 +30286,6 @@ msgstr ""
 msgid "Requests"
 msgstr ""
 
-msgid "Requests Profiles"
-msgstr ""
-
 msgid "Requests for pages at %{code_start}%{help_text_url}%{code_end} redirect to the URL. The destination must meet certain requirements. %{docs_link_start}Learn more.%{docs_link_end}"
 msgstr ""
 

spec/controllers/admin/requests_profiles_controller_spec.rb

-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Admin::RequestsProfilesController do
-  let_it_be(:admin) { create(:admin) }
-
-  before do
-    sign_in(admin)
-  end
-
-  describe '#show' do
-    let(:tmpdir) { Dir.mktmpdir('profiler-test') }
-    let(:test_file) { File.join(tmpdir, basename) }
-
-    subject do
-      get :show, params: { name: basename }
-    end
-
-    before do
-      stub_const('Gitlab::RequestProfiler::PROFILES_DIR', tmpdir)
-      File.write(test_file, sample_data)
-    end
-
-    after do
-      FileUtils.rm_rf(tmpdir)
-    end
-
-    context 'when loading HTML profile' do
-      let(:basename) { "profile_#{Time.current.to_i}_execution.html" }
-
-      let(:sample_data) do
-        '<html> <body> <h1>Heading</h1> <p>paragraph.</p> </body> </html>'
-      end
-
-      it 'renders the data' do
-        subject
-
-        expect(response).to have_gitlab_http_status(:ok)
-        expect(response.body).to eq(sample_data)
-      end
-    end
-
-    context 'when loading TXT profile' do
-      let(:basename) { "profile_#{Time.current.to_i}_memory.txt" }
-
-      let(:sample_data) do
-        <<~TXT
-          Total allocated: 112096396 bytes (1080431 objects)
-          Total retained:  10312598 bytes (53567 objects)
-        TXT
-      end
-
-      it 'renders the data' do
-        subject
-
-        expect(response).to have_gitlab_http_status(:ok)
-        expect(response.body).to eq(sample_data)
-      end
-    end
-
-    context 'when loading PDF profile' do
-      let(:basename) { "profile_#{Time.current.to_i}_anything.pdf" }
-
-      let(:sample_data) { 'mocked pdf content' }
-
-      it 'fails to render the data' do
-        expect { subject }.to raise_error(ActionController::UrlGenerationError, /No route matches.*unmatched constraints:/)
-      end
-    end
-  end
-end

spec/features/admin/admin_requests_profiles_spec.rb

-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'Admin::RequestsProfilesController' do
-  let(:tmpdir) { Dir.mktmpdir('profiler-test') }
-
-  before do
-    stub_const('Gitlab::RequestProfiler::PROFILES_DIR', tmpdir)
-    admin = create(:admin)
-    sign_in(admin)
-    gitlab_enable_admin_mode_sign_in(admin)
-  end
-
-  after do
-    FileUtils.rm_rf(tmpdir)
-  end
-
-  describe 'GET /admin/requests_profiles' do
-    it 'shows the current profile token' do
-      allow(Rails).to receive(:cache).and_return(ActiveSupport::Cache::MemoryStore.new)
-
-      visit admin_requests_profiles_path
-
-      expect(page).to have_content("X-Profile-Token: #{Gitlab::RequestProfiler.profile_token}")
-    end
-
-    context 'when having multiple profiles' do
-      let(:time1) { 1.hour.ago }
-      let(:time2) { 2.hours.ago }
-
-      let(:profiles) do
-        [
-          {
-            request_path: '/gitlab-org/gitlab-foss',
-            name: "|gitlab-org|gitlab-foss_#{time1.to_i}_execution.html",
-            created: time1,
-            profile_mode: 'Execution'
-          },
-          {
-            request_path: '/gitlab-org/gitlab-foss',
-            name: "|gitlab-org|gitlab-foss_#{time2.to_i}_execution.html",
-            created: time2,
-            profile_mode: 'Execution'
-          },
-          {
-            request_path: '/gitlab-org/gitlab-foss',
-            name: "|gitlab-org|gitlab-foss_#{time1.to_i}_memory.html",
-            created: time1,
-            profile_mode: 'Memory'
-          },
-          {
-            request_path: '/gitlab-org/gitlab-foss',
-            name: "|gitlab-org|gitlab-foss_#{time2.to_i}_memory.html",
-            created: time2,
-            profile_mode: 'Memory'
-          },
-          {
-            request_path: '/gitlab-org/infrastructure',
-            name: "|gitlab-org|infrastructure_#{time1.to_i}_execution.html",
-            created: time1,
-            profile_mode: 'Execution'
-          },
-          {
-            request_path: '/gitlab-org/infrastructure',
-            name: "|gitlab-org|infrastructure_#{time2.to_i}_memory.html",
-            created: time2,
-            profile_mode: 'Memory'
-          },
-          {
-            request_path: '/gitlab-org/infrastructure',
-            name: "|gitlab-org|infrastructure_#{time2.to_i}.html",
-            created: time2,
-            profile_mode: 'Unknown'
-          }
-        ]
-      end
-
-      before do
-        profiles.each do |profile|
-          FileUtils.touch(File.join(Gitlab::RequestProfiler::PROFILES_DIR, profile[:name]))
-        end
-      end
-
-      it 'lists all available profiles' do
-        visit admin_requests_profiles_path
-
-        profiles.each do |profile|
-          within('.card', text: profile[:request_path]) do
-            expect(page).to have_selector(
-              "a[href='#{admin_requests_profile_path(profile[:name])}']",
-              text: "#{profile[:created].to_s(:long)} #{profile[:profile_mode]}")
-          end
-        end
-      end
-    end
-  end
-
-  describe 'GET /admin/requests_profiles/:profile' do
-    context 'when a profile exists' do
-      before do
-        File.write("#{Gitlab::RequestProfiler::PROFILES_DIR}/#{profile}", content)
-      end
-
-      context 'when is valid call stack profile' do
-        let(:content) { 'This is a call stack request profile' }
-        let(:profile) { "|gitlab-org|gitlab-ce_#{Time.now.to_i}_execution.html" }
-
-        it 'displays the content' do
-          visit admin_requests_profile_path(profile)
-
-          expect(page).to have_content(content)
-        end
-      end
-
-      context 'when is valid memory profile' do
-        let(:content) { 'This is a memory request profile' }
-        let(:profile) { "|gitlab-org|gitlab-ce_#{Time.now.to_i}_memory.txt" }
-
-        it 'displays the content' do
-          visit admin_requests_profile_path(profile)
-
-          expect(page).to have_content(content)
-        end
-      end
-    end
-
-    context 'when a profile does not exist' do
-      it 'shows an error message' do
-        visit admin_requests_profile_path('|non|existent_12345.html')
-
-        expect(page).to have_content('Profile not found')
-      end
-    end
-  end
-end

spec/lib/gitlab/backtrace_cleaner_spec.rb

@@ -25,7 +25,6 @@ RSpec.describe Gitlab::BacktraceCleaner do
         "app/models/repository.rb:113:in `commit'",
         "lib/gitlab/i18n.rb:50:in `with_locale'",
         "lib/gitlab/middleware/multipart.rb:95:in `call'",
-        "lib/gitlab/request_profiler/middleware.rb:14:in `call'",
         "ee/lib/gitlab/database/load_balancing/rack_middleware.rb:37:in `call'",
         "ee/lib/gitlab/jira/middleware.rb:15:in `call'"
       ]

spec/lib/gitlab/request_profiler/profile_spec.rb

-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::RequestProfiler::Profile do
-  let(:profile) { described_class.new(filename) }
-
-  describe '.new' do
-    context 'using old filename' do
-      let(:filename) { '|api|v4|version.txt_1562854738.html' }
-
-      it 'returns valid data' do
-        expect(profile).to be_valid
-        expect(profile.request_path).to eq('/api/v4/version.txt')
-        expect(profile.time).to eq(Time.at(1562854738).utc)
-        expect(profile.type).to eq('html')
-      end
-    end
-
-    context 'using new filename' do
-      let(:filename) { '|api|v4|version.txt_1563547949_execution.html' }
-
-      it 'returns valid data' do
-        expect(profile).to be_valid
-        expect(profile.request_path).to eq('/api/v4/version.txt')
-        expect(profile.profile_mode).to eq('execution')
-        expect(profile.time).to eq(Time.at(1563547949).utc)
-        expect(profile.type).to eq('html')
-      end
-    end
-  end
-
-  describe '#content_type' do
-    context 'when using html file' do
-      let(:filename) { '|api|v4|version.txt_1562854738_memory.html' }
-
-      it 'returns valid data' do
-        expect(profile).to be_valid
-        expect(profile.content_type).to eq('text/html')
-      end
-    end
-
-    context 'when using text file' do
-      let(:filename) { '|api|v4|version.txt_1562854738_memory.txt' }
-
-      it 'returns valid data' do
-        expect(profile).to be_valid
-        expect(profile.content_type).to eq('text/plain')
-      end
-    end
-
-    context 'when file is unknown' do
-      let(:filename) { '|api|v4|version.txt_1562854738_memory.xxx' }
-
-      it 'returns valid data' do
-        expect(profile).not_to be_valid
-        expect(profile.content_type).to be_nil
-      end
-    end
-  end
-end

spec/lib/gitlab/request_profiler_spec.rb

-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::RequestProfiler do
-  describe '.profile_token' do
-    it 'returns a token' do
-      expect(described_class.profile_token).to be_present
-    end
-
-    it 'caches the token' do
-      expect(Rails.cache).to receive(:fetch).with('profile-token')
-
-      described_class.profile_token
-    end
-  end
-
-  context 'with temporary PROFILES_DIR' do
-    let(:tmpdir) { Dir.mktmpdir('profiler-test') }
-    let(:profile_name) { '|api|v4|version.txt_1562854738_memory.html' }
-    let(:profile_path) { File.join(tmpdir, profile_name) }
-
-    before do
-      stub_const('Gitlab::RequestProfiler::PROFILES_DIR', tmpdir)
-      FileUtils.touch(profile_path)
-    end
-
-    after do
-      FileUtils.rm_rf(tmpdir)
-    end
-
-    describe '.remove_all_profiles' do
-      it 'removes Gitlab::RequestProfiler::PROFILES_DIR directory' do
-        described_class.remove_all_profiles
-
-        expect(Dir.exist?(tmpdir)).to be false
-      end
-    end
-
-    describe '.all' do
-      subject { described_class.all }
-
-      it 'returns all profiles' do
-        expect(subject.map(&:name)).to contain_exactly(profile_name)
-      end
-    end
-
-    describe '.find' do
-      subject { described_class.find(profile_name) }
-
-      it 'returns all profiles' do
-        expect(subject.name).to eq(profile_name)
-      end
-    end
-  end
-end

spec/requests/request_profiler_spec.rb

-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'Request Profiler' do
-  let(:user) { create(:user) }
-
-  shared_examples 'profiling a request' do |profile_type, extension|
-    before do
-      allow(Rails).to receive(:cache).and_return(ActiveSupport::Cache::MemoryStore.new)
-      allow(RubyProf::Profile).to receive(:profile) do |&blk|
-        blk.call
-        RubyProf::Profile.new
-      end
-      allow(MemoryProfiler).to receive(:report) do |&blk|
-        blk.call
-        MemoryProfiler.start
-        MemoryProfiler.stop
-      end
-    end
-
-    it 'creates a profile of the request' do
-      project = create(:project, namespace: user.namespace)
-      time    = Time.now
-      path    = "/#{project.full_path}"
-
-      travel_to(time) do
-        get path, params: {}, headers: { 'X-Profile-Token' => Gitlab::RequestProfiler.profile_token, 'X-Profile-Mode' => profile_type }
-      end
-
-      profile_type = 'execution' if profile_type.nil?
-      profile_path = "#{Gitlab.config.shared.path}/tmp/requests_profiles/#{path.tr('/', '|')}_#{time.to_i}_#{profile_type}.#{extension}"
-      expect(File.exist?(profile_path)).to be true
-    end
-
-    after do
-      Gitlab::RequestProfiler.remove_all_profiles
-    end
-  end
-
-  context "when user is logged-in" do
-    before do
-      login_as(user)
-    end
-
-    include_examples 'profiling a request', 'execution', 'html'
-    include_examples 'profiling a request', nil, 'html'
-    include_examples 'profiling a request', 'memory', 'txt'
-  end
-
-  context "when user is not logged-in" do
-    include_examples 'profiling a request', 'execution', 'html'
-    include_examples 'profiling a request', nil, 'html'
-    include_examples 'profiling a request', 'memory', 'txt'
-  end
-end