564 lines
18 KiB
Ruby
564 lines
18 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require 'spec_helper'
|
|
|
|
require 'raven/transports/dummy'
|
|
require 'sentry/transport/dummy_transport'
|
|
|
|
RSpec.describe Gitlab::ErrorTracking, feature_category: :shared do
|
|
let(:exception) { RuntimeError.new('boom') }
|
|
let(:issue_url) { 'http://gitlab.com/gitlab-org/gitlab-foss/issues/1' }
|
|
let(:extra) { { issue_url: issue_url, some_other_info: 'info' } }
|
|
|
|
let_it_be(:user) { create(:user) }
|
|
|
|
let(:sentry_payload) do
|
|
{
|
|
tags: {
|
|
program: 'test',
|
|
locale: 'en',
|
|
feature_category: 'feature_a',
|
|
correlation_id: 'cid'
|
|
},
|
|
user: {
|
|
username: user.username
|
|
},
|
|
extra: {
|
|
some_other_info: 'info',
|
|
issue_url: 'http://gitlab.com/gitlab-org/gitlab-foss/issues/1'
|
|
}
|
|
}
|
|
end
|
|
|
|
let(:logger_payload) do
|
|
{
|
|
'exception.class' => 'RuntimeError',
|
|
'exception.message' => 'boom',
|
|
'tags.program' => 'test',
|
|
'tags.locale' => 'en',
|
|
'tags.feature_category' => 'feature_a',
|
|
'tags.correlation_id' => 'cid',
|
|
'user.username' => user.username,
|
|
'extra.some_other_info' => 'info',
|
|
'extra.issue_url' => 'http://gitlab.com/gitlab-org/gitlab-foss/issues/1'
|
|
}
|
|
end
|
|
|
|
let(:raven_event) do
|
|
event = Raven.client.transport.events.last[1]
|
|
Gitlab::Json.parse(event)
|
|
end
|
|
|
|
let(:sentry_event) do
|
|
Sentry.get_current_client.transport.events.last
|
|
end
|
|
|
|
before do
|
|
stub_feature_flags(enable_old_sentry_integration: true)
|
|
stub_feature_flags(enable_new_sentry_integration: true)
|
|
stub_sentry_settings
|
|
|
|
allow(described_class).to receive(:sentry_configurable?).and_return(true)
|
|
|
|
allow(Labkit::Correlation::CorrelationId).to receive(:current_id).and_return('cid')
|
|
allow(I18n).to receive(:locale).and_return('en')
|
|
|
|
described_class.configure do |config|
|
|
config.encoding = 'json' if config.respond_to?(:encoding=)
|
|
config.transport.transport_class = Sentry::DummyTransport if config.respond_to?(:transport)
|
|
end
|
|
end
|
|
|
|
around do |example|
|
|
Gitlab::ApplicationContext.with_context(user: user, feature_category: 'feature_a') do
|
|
example.run
|
|
end
|
|
end
|
|
|
|
after do
|
|
Sentry.get_current_scope.clear
|
|
end
|
|
|
|
describe '.track_and_raise_for_dev_exception' do
|
|
context 'when exceptions for dev should be raised' do
|
|
before do
|
|
allow(described_class).to receive(:should_raise_for_dev?).and_return(true)
|
|
end
|
|
|
|
it 'raises the exception' do
|
|
expect(Raven).to receive(:capture_exception).with(exception, sentry_payload)
|
|
expect(Sentry).to receive(:capture_exception).with(exception, sentry_payload)
|
|
|
|
expect do
|
|
described_class.track_and_raise_for_dev_exception(
|
|
exception,
|
|
issue_url: issue_url,
|
|
some_other_info: 'info'
|
|
)
|
|
end.to raise_error(RuntimeError, /boom/)
|
|
end
|
|
|
|
context 'with tags' do
|
|
let(:tags) { { 'mytag' => 2 } }
|
|
|
|
before do
|
|
sentry_payload[:tags].merge!(tags)
|
|
end
|
|
|
|
it 'includes additional tags' do
|
|
expect(Raven).to receive(:capture_exception).with(exception, sentry_payload)
|
|
expect(Sentry).to receive(:capture_exception).with(exception, sentry_payload)
|
|
|
|
expect do
|
|
described_class.track_and_raise_for_dev_exception(
|
|
exception,
|
|
{ issue_url: issue_url, some_other_info: 'info' },
|
|
tags
|
|
)
|
|
end.to raise_error(RuntimeError, /boom/)
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'when exceptions for dev should not be raised' do
|
|
before do
|
|
allow(described_class).to receive(:should_raise_for_dev?).and_return(false)
|
|
end
|
|
|
|
it 'logs the exception with all attributes passed' do
|
|
expect(Raven).to receive(:capture_exception).with(exception, sentry_payload)
|
|
expect(Sentry).to receive(:capture_exception).with(exception, sentry_payload)
|
|
|
|
described_class.track_and_raise_for_dev_exception(
|
|
exception,
|
|
issue_url: issue_url,
|
|
some_other_info: 'info'
|
|
)
|
|
end
|
|
|
|
it 'calls Gitlab::ErrorTracking::Logger.error with formatted payload' do
|
|
expect(Gitlab::ErrorTracking::Logger).to receive(:error).with(logger_payload)
|
|
|
|
described_class.track_and_raise_for_dev_exception(
|
|
exception,
|
|
issue_url: issue_url,
|
|
some_other_info: 'info'
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '.track_and_raise_exception' do
|
|
it 'always raises the exception' do
|
|
expect(Raven).to receive(:capture_exception).with(exception, sentry_payload)
|
|
expect(Sentry).to receive(:capture_exception).with(exception, sentry_payload)
|
|
|
|
expect do
|
|
described_class.track_and_raise_for_dev_exception(
|
|
exception,
|
|
issue_url: issue_url,
|
|
some_other_info: 'info'
|
|
)
|
|
end.to raise_error(RuntimeError, /boom/)
|
|
end
|
|
|
|
it 'calls Gitlab::ErrorTracking::Logger.error with formatted payload' do
|
|
expect(Gitlab::ErrorTracking::Logger).to receive(:error).with(logger_payload)
|
|
|
|
expect do
|
|
described_class.track_and_raise_exception(
|
|
exception,
|
|
issue_url: issue_url,
|
|
some_other_info: 'info'
|
|
)
|
|
end.to raise_error(RuntimeError)
|
|
end
|
|
end
|
|
|
|
describe '.log_and_raise_exception' do
|
|
subject(:log_and_raise_exception) do
|
|
described_class.log_and_raise_exception(exception, extra)
|
|
end
|
|
|
|
it 'only logs and raises the exception' do
|
|
expect(Raven).not_to receive(:capture_exception)
|
|
expect(Sentry).not_to receive(:capture_exception)
|
|
expect(Gitlab::ErrorTracking::Logger).to receive(:error).with(logger_payload)
|
|
|
|
expect { log_and_raise_exception }.to raise_error(RuntimeError)
|
|
end
|
|
|
|
context 'when extra details are provided' do
|
|
let(:extra) { { test: 1, my_token: 'test' } }
|
|
|
|
it 'filters parameters' do
|
|
expect(Gitlab::ErrorTracking::Logger).to receive(:error).with(
|
|
hash_including({ 'extra.test' => 1, 'extra.my_token' => '[FILTERED]' })
|
|
)
|
|
|
|
expect { log_and_raise_exception }.to raise_error(RuntimeError)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '.track_exception' do
|
|
let(:tags) { {} }
|
|
|
|
subject(:track_exception) do
|
|
described_class.track_exception(exception, extra, tags)
|
|
end
|
|
|
|
before do
|
|
allow(Raven).to receive(:capture_exception).and_call_original
|
|
allow(Sentry).to receive(:capture_exception).and_call_original
|
|
allow(Gitlab::ErrorTracking::Logger).to receive(:error)
|
|
end
|
|
|
|
it 'calls Raven.capture_exception' do
|
|
track_exception
|
|
|
|
expect(Raven)
|
|
.to have_received(:capture_exception).with(exception, sentry_payload)
|
|
|
|
expect(Sentry)
|
|
.to have_received(:capture_exception).with(exception, sentry_payload)
|
|
end
|
|
|
|
it 'calls Gitlab::ErrorTracking::Logger.error with formatted payload' do
|
|
track_exception
|
|
|
|
expect(Gitlab::ErrorTracking::Logger).to have_received(:error).with(logger_payload)
|
|
end
|
|
|
|
context 'with tags' do
|
|
let(:tags) { { 'mytag' => 2 } }
|
|
|
|
it 'includes the tags' do
|
|
track_exception
|
|
|
|
expect(Gitlab::ErrorTracking::Logger).to have_received(:error).with(
|
|
hash_including({ 'tags.mytag' => 2 })
|
|
)
|
|
end
|
|
end
|
|
|
|
context 'with filterable parameters' do
|
|
let(:extra) { { test: 1, my_token: 'test' } }
|
|
|
|
it 'filters parameters' do
|
|
track_exception
|
|
|
|
expect(Gitlab::ErrorTracking::Logger).to have_received(:error).with(
|
|
hash_including({ 'extra.test' => 1, 'extra.my_token' => '[FILTERED]' })
|
|
)
|
|
end
|
|
end
|
|
|
|
context 'when the exception implements :sentry_extra_data' do
|
|
let(:extra_info) { { event: 'explosion', size: :massive } }
|
|
|
|
before do
|
|
allow(exception).to receive(:sentry_extra_data).and_return(extra_info)
|
|
end
|
|
|
|
it 'includes the extra data from the exception in the tracking information' do
|
|
track_exception
|
|
|
|
expect(Raven).to have_received(:capture_exception).with(
|
|
exception, a_hash_including(extra: a_hash_including(extra_info))
|
|
)
|
|
|
|
expect(Sentry).to have_received(:capture_exception).with(
|
|
exception, a_hash_including(extra: a_hash_including(extra_info))
|
|
)
|
|
end
|
|
end
|
|
|
|
context 'when the exception implements :sentry_extra_data, which returns nil' do
|
|
let(:extra) { { issue_url: issue_url } }
|
|
|
|
before do
|
|
allow(exception).to receive(:sentry_extra_data).and_return(nil)
|
|
end
|
|
|
|
it 'just includes the other extra info' do
|
|
track_exception
|
|
|
|
expect(Raven).to have_received(:capture_exception).with(
|
|
exception, a_hash_including(extra: a_hash_including(extra))
|
|
)
|
|
|
|
expect(Sentry).to have_received(:capture_exception).with(
|
|
exception, a_hash_including(extra: a_hash_including(extra))
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'event processors' do
|
|
subject(:track_exception) { described_class.track_exception(exception, extra) }
|
|
|
|
before do
|
|
allow(Raven).to receive(:capture_exception).and_call_original
|
|
allow(Sentry).to receive(:capture_exception).and_call_original
|
|
allow(Gitlab::ErrorTracking::Logger).to receive(:error)
|
|
end
|
|
|
|
# This is a workaround for restoring Raven's user context below.
|
|
# Raven.user_context(&block) does not restore the user context correctly.
|
|
around do |example|
|
|
previous_user_context = Raven.context.user.dup
|
|
example.run
|
|
ensure
|
|
Raven.context.user = previous_user_context
|
|
end
|
|
|
|
context 'with custom GitLab context when using Raven.capture_exception directly' do
|
|
subject(:track_exception) { Raven.capture_exception(exception) }
|
|
|
|
it 'merges a default set of tags into the existing tags' do
|
|
allow(Raven.context).to receive(:tags).and_return(foo: 'bar')
|
|
|
|
track_exception
|
|
|
|
expect(raven_event['tags']).to include('correlation_id', 'feature_category', 'foo', 'locale', 'program')
|
|
end
|
|
|
|
it 'merges the current user information into the existing user information' do
|
|
Raven.user_context(id: -1)
|
|
|
|
track_exception
|
|
|
|
expect(raven_event['user']).to eq('id' => -1, 'username' => user.username)
|
|
end
|
|
end
|
|
|
|
context 'with custom GitLab context when using Sentry.capture_exception directly' do
|
|
subject(:track_exception) { Sentry.capture_exception(exception) }
|
|
|
|
it 'merges a default set of tags into the existing tags' do
|
|
Sentry.set_tags(foo: 'bar')
|
|
|
|
track_exception
|
|
|
|
expect(sentry_event.tags).to include(:correlation_id, :feature_category, :foo, :locale, :program)
|
|
end
|
|
|
|
it 'merges the current user information into the existing user information' do
|
|
Sentry.set_user(id: -1)
|
|
|
|
track_exception
|
|
|
|
expect(sentry_event.user).to eq(id: -1, username: user.username)
|
|
end
|
|
end
|
|
|
|
context 'with sidekiq args' do
|
|
context 'when the args does not have anything sensitive' do
|
|
let(:extra) do
|
|
{
|
|
sidekiq: {
|
|
'class' => 'PostReceive',
|
|
'args' => [
|
|
1,
|
|
{ 'id' => 2, 'name' => 'hello' },
|
|
'some-value',
|
|
'another-value'
|
|
]
|
|
}
|
|
}
|
|
end
|
|
|
|
it 'ensures extra.sidekiq.args is a string' do
|
|
track_exception
|
|
|
|
expect(Gitlab::ErrorTracking::Logger).to have_received(:error).with(
|
|
hash_including(
|
|
'extra.sidekiq' => {
|
|
'class' => 'PostReceive',
|
|
'args' => ['1', '{"id"=>2, "name"=>"hello"}', 'some-value', 'another-value']
|
|
}
|
|
)
|
|
)
|
|
end
|
|
|
|
it 'does not filter parameters when sending to Sentry' do
|
|
track_exception
|
|
expected_data = [1, { 'id' => 2, 'name' => 'hello' }, 'some-value', 'another-value']
|
|
|
|
expect(raven_event.dig('extra', 'sidekiq', 'args')).to eq(expected_data)
|
|
expect(sentry_event.extra[:sidekiq]['args']).to eq(expected_data)
|
|
end
|
|
end
|
|
|
|
context 'when the args has sensitive information' do
|
|
let(:extra) { { sidekiq: { 'class' => 'UnknownWorker', 'args' => ['sensitive string', 1, 2] } } }
|
|
|
|
it 'filters sensitive arguments before sending and logging' do
|
|
track_exception
|
|
|
|
expect(raven_event.dig('extra', 'sidekiq', 'args')).to eq(['[FILTERED]', 1, 2])
|
|
expect(sentry_event.extra[:sidekiq]['args']).to eq(['[FILTERED]', 1, 2])
|
|
expect(Gitlab::ErrorTracking::Logger).to have_received(:error).with(
|
|
hash_including(
|
|
'extra.sidekiq' => {
|
|
'class' => 'UnknownWorker',
|
|
'args' => ['[FILTERED]', '1', '2']
|
|
}
|
|
)
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'when the error is a GRPC error' do
|
|
context 'when the GRPC error contains a debug_error_string value' do
|
|
let(:exception) { GRPC::DeadlineExceeded.new('unknown cause', {}, '{"hello":1}') }
|
|
|
|
it 'sets the GRPC debug error string in the Sentry event and adds a custom fingerprint' do
|
|
track_exception
|
|
|
|
expect(raven_event.dig('extra', 'grpc_debug_error_string')).to eq('{"hello":1}')
|
|
expect(raven_event['fingerprint']).to eq(['GRPC::DeadlineExceeded', '4:unknown cause.'])
|
|
expect(sentry_event.extra[:grpc_debug_error_string]).to eq('{"hello":1}')
|
|
expect(sentry_event.fingerprint).to eq(['GRPC::DeadlineExceeded', '4:unknown cause.'])
|
|
end
|
|
end
|
|
|
|
context 'when the GRPC error does not contain a debug_error_string value' do
|
|
let(:exception) { GRPC::DeadlineExceeded.new }
|
|
|
|
it 'does not do any processing on the event' do
|
|
track_exception
|
|
|
|
expect(raven_event['extra']).not_to include('grpc_debug_error_string')
|
|
expect(raven_event['fingerprint']).to eq(['GRPC::DeadlineExceeded', '4:unknown cause'])
|
|
expect(sentry_event.extra).not_to include(:grpc_debug_error_string)
|
|
expect(sentry_event.fingerprint).to eq(['GRPC::DeadlineExceeded', '4:unknown cause'])
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'when exception is excluded' do
|
|
before do
|
|
stub_const('SubclassRetryError', Class.new(Gitlab::SidekiqMiddleware::RetryError))
|
|
end
|
|
|
|
['Gitlab::SidekiqMiddleware::RetryError', 'SubclassRetryError'].each do |ex|
|
|
context "with #{ex} exception" do
|
|
let(:exception) { ex.constantize.new }
|
|
|
|
it "does not report exception to Sentry" do
|
|
expect(Gitlab::ErrorTracking::Logger).to receive(:error)
|
|
|
|
track_exception
|
|
|
|
expect(Raven.client.transport.events).to eq([])
|
|
expect(Sentry.get_current_client.transport.events).to eq([])
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'when processing invalid URI exceptions' do
|
|
let(:invalid_uri) { 'http://foo:bar' }
|
|
let(:raven_exception_values) { raven_event['exception']['values'] }
|
|
let(:sentry_exception_values) { sentry_event.exception.to_hash[:values] }
|
|
|
|
context 'when the error is a URI::InvalidURIError' do
|
|
let(:exception) do
|
|
URI.parse(invalid_uri)
|
|
rescue URI::InvalidURIError => error
|
|
error
|
|
end
|
|
|
|
it 'filters the URI from the error message' do
|
|
track_exception
|
|
|
|
expect(raven_exception_values).to include(
|
|
hash_including(
|
|
'type' => 'URI::InvalidURIError',
|
|
'value' => 'bad URI(is not URI?): [FILTERED]'
|
|
)
|
|
)
|
|
expect(sentry_exception_values).to include(
|
|
hash_including(
|
|
type: 'URI::InvalidURIError',
|
|
value: 'bad URI(is not URI?): [FILTERED]'
|
|
)
|
|
)
|
|
end
|
|
end
|
|
|
|
context 'when the error is a Addressable::URI::InvalidURIError' do
|
|
let(:exception) do
|
|
Addressable::URI.parse(invalid_uri)
|
|
rescue Addressable::URI::InvalidURIError => error
|
|
error
|
|
end
|
|
|
|
it 'filters the URI from the error message' do
|
|
track_exception
|
|
|
|
expect(raven_exception_values).to include(
|
|
hash_including(
|
|
'type' => 'Addressable::URI::InvalidURIError',
|
|
'value' => 'Invalid port number: [FILTERED]'
|
|
)
|
|
)
|
|
expect(sentry_exception_values).to include(
|
|
hash_including(
|
|
type: 'Addressable::URI::InvalidURIError',
|
|
value: 'Invalid port number: [FILTERED]'
|
|
)
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'when request contains sensitive information' do
|
|
before do
|
|
Sentry.get_current_scope.set_rack_env({
|
|
'HTTP_AUTHORIZATION' => 'Bearer 123456',
|
|
'HTTP_PRIVATE_TOKEN' => 'abcdef',
|
|
'HTTP_JOB_TOKEN' => 'secret123'
|
|
})
|
|
end
|
|
|
|
it 'filters sensitive data' do
|
|
track_exception
|
|
|
|
expect(sentry_event.to_hash[:request][:headers]).to include(
|
|
'Authorization' => '[FILTERED]',
|
|
'Private-Token' => '[FILTERED]',
|
|
'Job-Token' => '[FILTERED]'
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'Sentry performance monitoring' do
|
|
context 'when ENABLE_SENTRY_PERFORMANCE_MONITORING env is disabled' do
|
|
before do
|
|
stub_env('ENABLE_SENTRY_PERFORMANCE_MONITORING', false)
|
|
described_class.configure_sentry # Force re-initialization to reset traces_sample_rate setting
|
|
end
|
|
|
|
it 'does not set traces_sample_rate' do
|
|
expect(Sentry.get_current_client.configuration.traces_sample_rate.present?).to eq false
|
|
end
|
|
end
|
|
|
|
context 'when ENABLE_SENTRY_PERFORMANCE_MONITORING env is enabled' do
|
|
before do
|
|
stub_env('ENABLE_SENTRY_PERFORMANCE_MONITORING', true)
|
|
described_class.configure_sentry # Force re-initialization to reset traces_sample_rate setting
|
|
end
|
|
|
|
it 'sets traces_sample_rate' do
|
|
expect(Sentry.get_current_client.configuration.traces_sample_rate.present?).to eq true
|
|
end
|
|
end
|
|
end
|
|
end
|