Module: Sentry

Extended by:
Forwardable
Defined in:
lib/sentry/dsn.rb,
lib/sentry/hub.rb,
lib/sentry-ruby.rb,
lib/sentry/puma.rb,
lib/sentry/rake.rb,
lib/sentry/span.rb,
lib/sentry/event.rb,
lib/sentry/redis.rb,
lib/sentry/scope.rb,
lib/sentry/client.rb,
lib/sentry/logger.rb,
lib/sentry/baggage.rb,
lib/sentry/faraday.rb,
lib/sentry/metrics.rb,
lib/sentry/session.rb,
lib/sentry/version.rb,
lib/sentry/envelope.rb,
lib/sentry/net/http.rb,
lib/sentry/profiler.rb,
lib/sentry/backtrace.rb,
lib/sentry/interface.rb,
lib/sentry/linecache.rb,
lib/sentry/transport.rb,
lib/sentry/attachment.rb,
lib/sentry/breadcrumb.rb,
lib/sentry/exceptions.rb,
lib/sentry/integrable.rb,
lib/sentry/error_event.rb,
lib/sentry/test_helper.rb,
lib/sentry/transaction.rb,
lib/sentry/configuration.rb,
lib/sentry/check_in_event.rb,
lib/sentry/metrics/metric.rb,
lib/sentry/metrics/timing.rb,
lib/sentry/session_flusher.rb,
lib/sentry/release_detector.rb,
lib/sentry/background_worker.rb,
lib/sentry/breadcrumb_buffer.rb,
lib/sentry/transaction_event.rb,
lib/sentry/cron/configuration.rb,
lib/sentry/interfaces/request.rb,
lib/sentry/interfaces/threads.rb,
lib/sentry/metrics/aggregator.rb,
lib/sentry/metrics/set_metric.rb,
lib/sentry/cron/monitor_config.rb,
lib/sentry/propagation_context.rb,
lib/sentry/backpressure_monitor.rb,
lib/sentry/interfaces/exception.rb,
lib/sentry/interfaces/mechanism.rb,
lib/sentry/metrics/gauge_metric.rb,
lib/sentry/cron/monitor_schedule.rb,
lib/sentry/interfaces/stacktrace.rb,
lib/sentry/metrics/configuration.rb,
lib/sentry/cron/monitor_check_ins.rb,
lib/sentry/metrics/counter_metric.rb,
lib/sentry/rack/capture_exceptions.rb,
lib/sentry/transport/configuration.rb,
lib/sentry/breadcrumb/sentry_logger.rb,
lib/sentry/metrics/local_aggregator.rb,
lib/sentry/threaded_periodic_worker.rb,
lib/sentry/transport/http_transport.rb,
lib/sentry/transport/dummy_transport.rb,
lib/sentry/interfaces/single_exception.rb,
lib/sentry/metrics/distribution_metric.rb,
lib/sentry/interfaces/stacktrace_builder.rb,
lib/sentry/transport/spotlight_transport.rb

Defined Under Namespace

Modules: Cron, Faraday, Integrable, Metrics, Net, Puma, Rack, Rake, TestHelper Classes: Attachment, BackgroundWorker, BackpressureMonitor, Backtrace, Baggage, Breadcrumb, BreadcrumbBuffer, CheckInEvent, Client, Configuration, DSN, DummyTransport, Envelope, Error, ErrorEvent, Event, ExceptionInterface, ExternalError, HTTPTransport, Hub, Interface, LineCache, Logger, Mechanism, Profiler, PropagationContext, Redis, ReleaseDetector, RequestInterface, Scope, Session, SessionFlusher, SingleExceptionInterface, Span, SpotlightTransport, StacktraceBuilder, StacktraceInterface, ThreadedPeriodicWorker, ThreadsInterface, Transaction, TransactionEvent, Transport

Constant Summary collapse

META = 
{ "name" => "sentry.ruby", "version" => Sentry::VERSION }.freeze
CAPTURED_SIGNATURE = 
:@__sentry_captured
LOGGER_PROGNAME = 
"sentry".freeze
SENTRY_TRACE_HEADER_NAME = 
"sentry-trace".freeze
BAGGAGE_HEADER_NAME = 
"baggage".freeze
THREAD_LOCAL = 
:sentry_hub
VERSION = 
"5.20.0"

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.background_worker ⇒ BackgroundWorker

Returns:



72
73
74
 
# File 'lib/sentry-ruby.rb', line 72

def background_worker
  @background_worker
end

.backpressure_monitor ⇒ Object (readonly)

Returns the value of attribute backpressure_monitor.



80
81
82
 
# File 'lib/sentry-ruby.rb', line 80

def backpressure_monitor
  @backpressure_monitor
end

.metrics_aggregator ⇒ Object (readonly)

Returns the value of attribute metrics_aggregator.



84
85
86
 
# File 'lib/sentry-ruby.rb', line 84

def metrics_aggregator
  @metrics_aggregator
end

.session_flusher ⇒ Object (readonly)

Returns the value of attribute session_flusher.



76
77
78
 
# File 'lib/sentry-ruby.rb', line 76

def session_flusher
  @session_flusher
end

Class Method Details

.add_attachment ⇒ Object 



216
217
218
219
 
# File 'lib/sentry-ruby.rb', line 216

def add_attachment(**opts)
  return unless initialized?
  get_current_scope.add_attachment(**opts)
end

.add_breadcrumb(breadcrumb, **options) ⇒ Breadcrumb?

Takes an instance of Sentry::Breadcrumb and stores it to the current active scope.

Returns:



311
312
313
314
 
# File 'lib/sentry-ruby.rb', line 311

def add_breadcrumb(breadcrumb, **options)
  return unless initialized?
  get_current_hub.add_breadcrumb(breadcrumb, **options)
end

.add_global_event_processor {|event, hint| ... } ⇒ void

This method returns an undefined value.

Add a global event processor [Proc]. These run before scope event processors.

Examples:

Sentry.add_global_event_processor do |event, hint|
  event.tags = { foo: 42 }
  event
end

Yield Parameters:

  • event (Event)
  • hint (Hash, nil) 


530
531
532
 
# File 'lib/sentry-ruby.rb', line 530

def add_global_event_processor(&block)
  Scope.add_global_event_processor(&block)
end

.capture_check_in(slug, status, **options) ⇒ String?

Captures a check-in and sends it to Sentry via the currently active hub.

Parameters:

Options Hash (**options):

  • check_in_id (String) —

    for updating the status of an existing monitor

  • duration (Integer) —

    seconds elapsed since this monitor started

  • monitor_config (Cron::MonitorConfig) —

    configuration for this monitor

Returns:



470
471
472
473
 
# File 'lib/sentry-ruby.rb', line 470

def capture_check_in(slug, status, **options)
  return unless initialized?
  get_current_hub.capture_check_in(slug, status, **options)
end

.capture_event(event) ⇒ Event?

Takes an instance of Sentry::Event and dispatches it to the currently active hub.

Returns:



454
455
456
457
 
# File 'lib/sentry-ruby.rb', line 454

def capture_event(event)
  return unless initialized?
  get_current_hub.capture_event(event)
end

.capture_exception(exception, **options) {|scope| ... } ⇒ Event?

Takes an exception and reports it to Sentry via the currently active hub.

Yield Parameters:

Returns:



418
419
420
421
 
# File 'lib/sentry-ruby.rb', line 418

def capture_exception(exception, **options, &block)
  return unless initialized?
  get_current_hub.capture_exception(exception, **options, &block)
end

.capture_message(message, **options) {|scope| ... } ⇒ Event?

Takes a message string and reports it to Sentry via the currently active hub.

Yield Parameters:

Returns:



446
447
448
449
 
# File 'lib/sentry-ruby.rb', line 446

def capture_message(message, **options, &block)
  return unless initialized?
  get_current_hub.capture_message(message, **options, &block)
end

.clone_hub_to_current_thread ⇒ void

This method returns an undefined value.

Clones the main thread’s active hub and stores it to the current thread.



348
349
350
351
 
# File 'lib/sentry-ruby.rb', line 348

def clone_hub_to_current_thread
  return unless initialized?
  Thread.current.thread_variable_set(THREAD_LOCAL, get_main_hub.clone)
end

.close ⇒ void

This method returns an undefined value.

Flushes pending events and cleans up SDK state. SDK will stop sending events and all top-level APIs will be no-ops after this.



249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
 
# File 'lib/sentry-ruby.rb', line 249

def close
  if @session_flusher
    @session_flusher.flush
    @session_flusher.kill
    @session_flusher = nil
  end

  if @backpressure_monitor
    @backpressure_monitor.kill
    @backpressure_monitor = nil
  end

  if @metrics_aggregator
    @metrics_aggregator.flush(force: true)
    @metrics_aggregator.kill
    @metrics_aggregator = nil
  end

  if client = get_current_client
    client.flush

    if client.configuration.include_local_variables
      exception_locals_tp.disable
    end
  end

  @background_worker.shutdown

  @main_hub = nil
  Thread.current.thread_variable_set(THREAD_LOCAL, nil)
end

.configuration ⇒ Object 



156
157
158
159
 
# File 'lib/sentry-ruby.rb', line 156

def configuration
  return unless initialized?
  get_current_client.configuration
end

.configure_scope {|scope| ... } ⇒ void

This method returns an undefined value.

Takes a block and yields the current active scope.

Examples:

Sentry.configure_scope do |scope|
  scope.set_tags(foo: "bar")
end

Sentry.capture_message("test message") # this event will have tags { foo: "bar" }

Yield Parameters:



364
365
366
367
 
# File 'lib/sentry-ruby.rb', line 364

def configure_scope(&block)
  return unless initialized?
  get_current_hub.configure_scope(&block)
end

.continue_trace(env, **options) ⇒ Transaction?

Continue an incoming trace from a rack env like hash.

Parameters:

  • env (Hash)

Returns:



574
575
576
577
 
# File 'lib/sentry-ruby.rb', line 574

def continue_trace(env, **options)
  return nil unless initialized?
  get_current_hub.continue_trace(env, **options)
end

.csp_report_uri ⇒ String?

Returns an uri for security policy reporting that’s generated from the given DSN (To learn more about security policy reporting: docs.sentry.io/product/security-policy-reporting/)

It returns nil if

  • The SDK is not initialized yet.

  • The DSN is not provided or is invalid.

Returns:

  • (String, nil) 


296
297
298
299
 
# File 'lib/sentry-ruby.rb', line 296

def csp_report_uri
  return unless initialized?
  configuration.csp_report_uri
end

.exception_captured?(exc) ⇒ Boolean

Checks if the exception object has been captured by the SDK.

Returns:

  • (Boolean) 


512
513
514
515
 
# File 'lib/sentry-ruby.rb', line 512

def exception_captured?(exc)
  return false unless initialized?
  !!exc.instance_variable_get(CAPTURED_SIGNATURE)
end

.get_baggage ⇒ String?

Returns the baggage header for distributed tracing. Can be either from the currently active span or the propagation context.

Returns:

  • (String, nil) 


547
548
549
550
 
# File 'lib/sentry-ruby.rb', line 547

def get_baggage
  return nil unless initialized?
  get_current_hub.get_baggage
end

.get_current_client ⇒ Client?

Returns the current active client.

Returns:



332
333
334
335
 
# File 'lib/sentry-ruby.rb', line 332

def get_current_client
  return unless initialized?
  get_current_hub.current_client
end

.get_current_hub ⇒ Hub

Returns the current active hub. If the current thread doesn’t have an active hub, it will clone the main thread’s active hub, stores it in the current thread, and then returns it.

Returns:



321
322
323
324
325
326
327
328
 
# File 'lib/sentry-ruby.rb', line 321

def get_current_hub
  # we need to assign a hub to the current thread if it doesn't have one yet
  #
  # ideally, we should do this proactively whenever a new thread is created
  # but it's impossible for the SDK to keep track every new thread
  # so we need to use this rather passive way to make sure the app doesn't crash
  Thread.current.thread_variable_get(THREAD_LOCAL) || clone_hub_to_current_thread
end

.get_current_scope ⇒ Scope?

Returns the current active scope.

Returns:



340
341
342
343
 
# File 'lib/sentry-ruby.rb', line 340

def get_current_scope
  return unless initialized?
  get_current_hub.current_scope
end

.get_main_hub ⇒ Hub

Returns the main thread’s active hub.

Returns:



304
305
306
 
# File 'lib/sentry-ruby.rb', line 304

def get_main_hub
  @main_hub
end

.get_trace_propagation_headers ⇒ Hash?

Returns the a Hash containing sentry-trace and baggage. Can be either from the currently active span or the propagation context.

Returns:

  • (Hash, nil) 


556
557
558
559
 
# File 'lib/sentry-ruby.rb', line 556

def get_trace_propagation_headers
  return nil unless initialized?
  get_current_hub.get_trace_propagation_headers
end

.get_trace_propagation_meta ⇒ String

Returns the a Hash containing sentry-trace and baggage. Can be either from the currently active span or the propagation context.

Returns:

  • (String) 


565
566
567
568
 
# File 'lib/sentry-ruby.rb', line 565

def get_trace_propagation_meta
  return "" unless initialized?
  get_current_hub.get_trace_propagation_meta
end

.get_traceparent ⇒ String?

Returns the traceparent (sentry-trace) header for distributed tracing. Can be either from the currently active span or the propagation context.

Returns:

  • (String, nil) 


538
539
540
541
 
# File 'lib/sentry-ruby.rb', line 538

def get_traceparent
  return nil unless initialized?
  get_current_hub.get_traceparent
end

.init {|config| ... } ⇒ void

This method returns an undefined value.

Initializes the SDK with given configuration.

Yield Parameters:



227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
 
# File 'lib/sentry-ruby.rb', line 227

def init(&block)
  config = Configuration.new
  yield(config) if block_given?
  config.detect_release
  apply_patches(config)
  client = Client.new(config)
  scope = Scope.new(max_breadcrumbs: config.max_breadcrumbs)
  hub = Hub.new(client, scope)
  Thread.current.thread_variable_set(THREAD_LOCAL, hub)
  @main_hub = hub
  @background_worker = Sentry::BackgroundWorker.new(config)
  @session_flusher = config.session_tracking? ? Sentry::SessionFlusher.new(config, client) : nil
  @backpressure_monitor = config.enable_backpressure_handling ? Sentry::BackpressureMonitor.new(config, client) : nil
  @metrics_aggregator = config.metrics.enabled ? Sentry::Metrics::Aggregator.new(config, client) : nil
  exception_locals_tp.enable if config.include_local_variables
  at_exit { close }
end

.initialized? ⇒ Boolean

Returns true if the SDK is initialized.

Returns:

  • (Boolean) 


284
285
286
 
# File 'lib/sentry-ruby.rb', line 284

def initialized?
  !!get_main_hub
end

.integrations ⇒ Hash{String=>Hash}

Returns a hash that contains all the integrations that have been registered to the main SDK.

Returns:

  • (Hash{String=>Hash}) 


120
121
122
 
# File 'lib/sentry-ruby.rb', line 120

def integrations
  @integrations ||= {}
end

.last_event_id ⇒ String?

Returns the id of the lastly reported Sentry::Event.

Returns:

  • (String, nil) 


504
505
506
507
 
# File 'lib/sentry-ruby.rb', line 504

def last_event_id
  return unless initialized?
  get_current_hub.last_event_id
end

.register_integration(name, version) ⇒ Object

Registers the SDK integration with its name and version.

Parameters:

  • name (String) —

    name of the integration

  • version (String) —

    version of the integration



128
129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/sentry-ruby.rb', line 128

def register_integration(name, version)
  if initialized?
    logger.warn(LOGGER_PROGNAME) do
      <<~MSG
        Integration '#{name}' is loaded after the SDK is initialized, which can cause unexpected behavior.  Please make sure all integrations are loaded before SDK initialization.
      MSG
    end
  end

  meta = { name: "sentry.ruby.#{name}", version: version }.freeze
  integrations[name.to_s] = meta
end

.send_event ⇒ Object 



163
164
165
166
 
# File 'lib/sentry-ruby.rb', line 163

def send_event(*args)
  return unless initialized?
  get_current_client.send_event(*args)
end

.set_context ⇒ Object 



209
210
211
212
 
# File 'lib/sentry-ruby.rb', line 209

def set_context(*args)
  return unless initialized?
  get_current_scope.set_context(*args)
end

.set_extras ⇒ Object 



195
196
197
198
 
# File 'lib/sentry-ruby.rb', line 195

def set_extras(*args)
  return unless initialized?
  get_current_scope.set_extras(*args)
end

.set_tags ⇒ Object 



188
189
190
191
 
# File 'lib/sentry-ruby.rb', line 188

def set_tags(*args)
  return unless initialized?
  get_current_scope.set_tags(*args)
end

.set_user ⇒ Object 



202
203
204
205
 
# File 'lib/sentry-ruby.rb', line 202

def set_user(*args)
  return unless initialized?
  get_current_scope.set_user(*args)
end

.start_transaction(**options) ⇒ Transaction?

Takes or initializes a new Sentry::Transaction and makes a sampling decision for it.

Returns:



478
479
480
481
 
# File 'lib/sentry-ruby.rb', line 478

def start_transaction(**options)
  return unless initialized?
  get_current_hub.start_transaction(**options)
end

.with_child_span(**attributes) {|child_span| ... } ⇒ Object

Records the block’s execution as a child of the current span. If the current scope doesn’t have a span, the block would still be executed but the yield param will be nil.

Examples:

Sentry.with_child_span(op: "my operation") do |child_span|
  child_span.set_data(operation_data)
  child_span.set_description(operation_detail)
  # result will be returned
end

Parameters:

  • attributes (Hash) —

    attributes for the child span.

Yield Parameters:

  • child_span (Span, nil)

Returns:

  • yield result



496
497
498
499
 
# File 'lib/sentry-ruby.rb', line 496

def with_child_span(**attributes, &block)
  return yield(nil) unless Sentry.initialized?
  get_current_hub.with_child_span(**attributes, &block)
end

.with_exception_captured(**options, &block) ⇒ Object

Takes a block and evaluates it. If the block raised an exception, it reports the exception to Sentry and re-raises it. If the block ran without exception, it returns the evaluation result.

Examples:

Sentry.with_exception_captured do
  1/1 #=> 1 will be returned
end

Sentry.with_exception_captured do
  1/0 #=> ZeroDivisionError will be reported and re-raised
end


435
436
437
438
439
440
 
# File 'lib/sentry-ruby.rb', line 435

def with_exception_captured(**options, &block)
  yield
rescue Exception => e
  capture_exception(e, **options)
  raise
end

.with_scope {|scope| ... } ⇒ void

This method returns an undefined value.

Takes a block and yields a temporary scope. The temporary scope will inherit all the attributes from the current active scope and replace it to be the active scope inside the block.

Examples:

Sentry.configure_scope do |scope|
  scope.set_tags(foo: "bar")
end

Sentry.capture_message("test message") # this event will have tags { foo: "bar" }

Sentry.with_scope do |temp_scope|
  temp_scope.set_tags(foo: "baz")
  Sentry.capture_message("test message 2") # this event will have tags { foo: "baz" }
end

Sentry.capture_message("test message 3") # this event will have tags { foo: "bar" }

Yield Parameters:



389
390
391
392
 
# File 'lib/sentry-ruby.rb', line 389

def with_scope(&block)
  return yield unless initialized?
  get_current_hub.with_scope(&block)
end

.with_session_tracking(&block) ⇒ void

This method returns an undefined value.

Wrap a given block with session tracking. Aggregate sessions in minutely buckets will be recorded around this block and flushed every minute.

Examples:

Sentry.with_session_tracking do
  a = 1 + 1 # new session recorded with :exited status
end

Sentry.with_session_tracking do
  1 / 0
rescue => e
  Sentry.capture_exception(e) # new session recorded with :errored status
end


409
410
411
412
 
# File 'lib/sentry-ruby.rb', line 409

def with_session_tracking(&block)
  return yield unless initialized?
  get_current_hub.with_session_tracking(&block)
end