Class: Sentry::Scope

Inherits:
Object
  • Object
show all
Includes:
ArgumentCheckingHelper
Defined in:
lib/sentry/scope.rb

Constant Summary collapse

ATTRIBUTES = 
[
  :transaction_name,
  :transaction_source,
  :contexts,
  :extra,
  :tags,
  :user,
  :level,
  :breadcrumbs,
  :fingerprint,
  :event_processors,
  :rack_env,
  :span,
  :session,
  :attachments,
  :propagation_context
]

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(max_breadcrumbs: nil) ⇒ Scope 



33
34
35
36
 
# File 'lib/sentry/scope.rb', line 33

def initialize(max_breadcrumbs: nil)
  @max_breadcrumbs = max_breadcrumbs
  set_default_value
end

Class Method Details

.add_global_event_processor(&block) ⇒ void

This method returns an undefined value.

Adds a new global event processor [Proc]. Sometimes we need a global event processor without needing to configure scope. These run before scope event processors.



375
376
377
 
# File 'lib/sentry/scope.rb', line 375

def add_global_event_processor(&block)
  global_event_processors << block
end

.global_event_processors ⇒ Array<Proc>

Returns the global event processors array.



365
366
367
 
# File 'lib/sentry/scope.rb', line 365

def global_event_processors
  @global_event_processors ||= []
end

.os_context ⇒ Hash 



341
342
343
344
345
346
347
348
349
350
351
352
353
 
# File 'lib/sentry/scope.rb', line 341

def os_context
  @os_context ||=
    begin
      uname = Etc.uname
      {
        name: uname[:sysname] || RbConfig::CONFIG["host_os"],
        version: uname[:version],
        build: uname[:release],
        kernel_version: uname[:version],
        machine: uname[:machine]
      }
    end
end

.runtime_context ⇒ Hash 



356
357
358
359
360
361
 
# File 'lib/sentry/scope.rb', line 356

def runtime_context
  @runtime_context ||= {
    name: RbConfig::CONFIG["ruby_install_name"],
    version: RUBY_DESCRIPTION || Sentry.sys_command("ruby -v")
  }
end

Instance Method Details

#add_attachment(**opts) ⇒ Object

Add a new attachment to the scope.



305
306
307
308
 
# File 'lib/sentry/scope.rb', line 305

def add_attachment(**opts)
  attachments << (attachment = Attachment.new(**opts))
  attachment
end

#add_breadcrumb(breadcrumb) ⇒ void

This method returns an undefined value.

Adds the breadcrumb to the scope’s breadcrumbs buffer.



95
96
97
 
# File 'lib/sentry/scope.rb', line 95

def add_breadcrumb(breadcrumb)
  breadcrumbs.record(breadcrumb)
end

#add_event_processor(&block) ⇒ void

This method returns an undefined value.

Adds a new event processor [Proc] to the scope.



293
294
295
 
# File 'lib/sentry/scope.rb', line 293

def add_event_processor(&block)
  @event_processors << block
end

#apply_to_event(event, hint = nil) ⇒ Event

Applies stored attributes and event processors to the given event.



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/sentry/scope.rb', line 48

def apply_to_event(event, hint = nil)
  unless event.is_a?(CheckInEvent) || event.is_a?(LogEvent)
    event.tags = tags.merge(event.tags)
    event.user = user.merge(event.user)
    event.extra = extra.merge(event.extra)
    event.contexts = contexts.merge(event.contexts)
    event.transaction = transaction_name if transaction_name
    event.transaction_info = { source: transaction_source } if transaction_source
    event.fingerprint = fingerprint
    event.level = level
    event.breadcrumbs = breadcrumbs
    event.rack_env = rack_env if rack_env
    event.attachments = attachments
  end

  if event.is_a?(LogEvent)
    event.user = user.merge(event.user)
  end

  if span
    event.contexts[:trace] ||= span.get_trace_context

    if event.respond_to?(:dynamic_sampling_context)
      event.dynamic_sampling_context ||= span.get_dynamic_sampling_context
    end
  else
    event.contexts[:trace] ||= propagation_context.get_trace_context

    if event.respond_to?(:dynamic_sampling_context)
      event.dynamic_sampling_context ||= propagation_context.get_dynamic_sampling_context
    end
  end

  all_event_processors = self.class.global_event_processors + @event_processors

  unless all_event_processors.empty?
    all_event_processors.each do |processor_block|
      event = processor_block.call(event, hint)
    end
  end

  event
end

#clear ⇒ void

This method returns an undefined value.

Resets the scope’s attributes to defaults.



40
41
42
 
# File 'lib/sentry/scope.rb', line 40

def clear
  set_default_value
end

#clear_breadcrumbs ⇒ void

This method returns an undefined value.

Clears the scope’s breadcrumbs buffer



101
102
103
 
# File 'lib/sentry/scope.rb', line 101

def clear_breadcrumbs
  set_new_breadcrumb_buffer
end

#dup ⇒ Scope 



106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/sentry/scope.rb', line 106

def dup
  copy = super
  copy.breadcrumbs = breadcrumbs.dup
  copy.contexts = contexts.deep_dup
  copy.extra = extra.deep_dup
  copy.tags = tags.deep_dup
  copy.user = user.deep_dup
  copy.transaction_name = transaction_name.dup
  copy.transaction_source = transaction_source.dup
  copy.fingerprint = fingerprint.deep_dup
  copy.span = span.deep_dup
  copy.session = session.deep_dup
  copy.propagation_context = propagation_context.deep_dup
  copy.attachments = attachments.dup
  copy
end

#generate_propagation_context(env = nil) ⇒ void

This method returns an undefined value.

Generate a new propagation context either from the incoming env headers or from scratch.



300
301
302
 
# File 'lib/sentry/scope.rb', line 300

def generate_propagation_context(env = nil)
  @propagation_context = PropagationContext.new(self, env)
end

#get_span ⇒ Span?

Returns the associated Span object.



277
278
279
 
# File 'lib/sentry/scope.rb', line 277

def get_span
  span
end

#get_transaction ⇒ Transaction?

Returns the associated Transaction object.



271
272
273
 
# File 'lib/sentry/scope.rb', line 271

def get_transaction
  span.transaction if span
end

#set_context(key, value) ⇒ Hash

Adds a new key-value pair to current contexts.



235
236
237
238
 
# File 'lib/sentry/scope.rb', line 235

def set_context(key, value)
  check_argument_type!(value, Hash)
  set_contexts(key => value)
end

#set_contexts(contexts_hash) ⇒ Hash

Updates the scope’s contexts attribute by merging with the old value.



223
224
225
226
227
228
229
230
231
232
 
# File 'lib/sentry/scope.rb', line 223

def set_contexts(contexts_hash)
  check_argument_type!(contexts_hash, Hash)
  contexts_hash.values.each do |val|
    check_argument_type!(val, Hash)
  end

  @contexts.merge!(contexts_hash) do |key, old, new|
    old.merge(new)
  end
end

#set_extra(key, value) ⇒ Hash

Adds a new key-value pair to current extras.



202
203
204
 
# File 'lib/sentry/scope.rb', line 202

def set_extra(key, value)
  set_extras(key => value)
end

#set_extras(extras_hash) ⇒ Hash

Updates the scope’s extras attribute by merging with the old value.



193
194
195
196
 
# File 'lib/sentry/scope.rb', line 193

def set_extras(extras_hash)
  check_argument_type!(extras_hash, Hash)
  @extra.merge!(extras_hash)
end

#set_fingerprint(fingerprint) ⇒ Array

Sets the scope’s fingerprint attribute.



284
285
286
287
288
 
# File 'lib/sentry/scope.rb', line 284

def set_fingerprint(fingerprint)
  check_argument_type!(fingerprint, Array)

  @fingerprint = fingerprint
end

#set_level(level) ⇒ void

This method returns an undefined value.

Sets the scope’s level attribute.



243
244
245
 
# File 'lib/sentry/scope.rb', line 243

def set_level(level)
  @level = level
end

#set_rack_env(env) ⇒ Hash

Sets the scope’s rack_env attribute.



173
174
175
176
 
# File 'lib/sentry/scope.rb', line 173

def set_rack_env(env)
  env = env || {}
  @rack_env = env
end

#set_session(session) ⇒ void

This method returns an undefined value.

Sets the currently active session on the scope.



259
260
261
 
# File 'lib/sentry/scope.rb', line 259

def set_session(session)
  @session = session
end

#set_span(span) ⇒ Span

Sets the scope’s span attribute.



181
182
183
184
 
# File 'lib/sentry/scope.rb', line 181

def set_span(span)
  check_argument_type!(span, Span)
  @span = span
end

#set_tag(key, value) ⇒ Hash

Adds a new key-value pair to current tags.



216
217
218
 
# File 'lib/sentry/scope.rb', line 216

def set_tag(key, value)
  set_tags(key => value)
end

#set_tags(tags_hash) ⇒ Hash

Updates the scope’s tags attribute by merging with the old value.



207
208
209
210
 
# File 'lib/sentry/scope.rb', line 207

def set_tags(tags_hash)
  check_argument_type!(tags_hash, Hash)
  @tags.merge!(tags_hash)
end

#set_transaction_name(transaction_name, source: :custom) ⇒ void

This method returns an undefined value.

Appends a new transaction name to the scope. The “transaction” here does not refer to ‘Transaction` objects.



251
252
253
254
 
# File 'lib/sentry/scope.rb', line 251

def set_transaction_name(transaction_name, source: :custom)
  @transaction_name = transaction_name
  @transaction_source = source
end

#set_user(user_hash) ⇒ Hash

Sets the scope’s user attribute.



187
188
189
190
 
# File 'lib/sentry/scope.rb', line 187

def set_user(user_hash)
  check_argument_type!(user_hash, Hash)
  @user = user_hash
end

#transaction_source_low_quality? ⇒ Boolean

These are high cardinality and thus bad.



265
266
267
 
# File 'lib/sentry/scope.rb', line 265

def transaction_source_low_quality?
  transaction_source == :url
end

#update_from_options(contexts: nil, extra: nil, tags: nil, user: nil, level: nil, fingerprint: nil, attachments: nil, **options) ⇒ Array

Updates the scope’s data from the given options.



149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
# File 'lib/sentry/scope.rb', line 149

def update_from_options(
  contexts: nil,
  extra: nil,
  tags: nil,
  user: nil,
  level: nil,
  fingerprint: nil,
  attachments: nil,
  **options
)
  self.contexts.merge!(contexts) if contexts
  self.extra.merge!(extra) if extra
  self.tags.merge!(tags) if tags
  self.user = user if user
  self.level = level if level
  self.fingerprint = fingerprint if fingerprint

  # Returns unsupported option keys so we can notify users.
  options.keys
end

#update_from_scope(scope) ⇒ void

This method returns an undefined value.

Updates the scope’s data from a given scope.



126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/sentry/scope.rb', line 126

def update_from_scope(scope)
  self.breadcrumbs = scope.breadcrumbs
  self.contexts = scope.contexts
  self.extra = scope.extra
  self.tags = scope.tags
  self.user = scope.user
  self.transaction_name = scope.transaction_name
  self.transaction_source = scope.transaction_source
  self.fingerprint = scope.fingerprint
  self.span = scope.span
  self.propagation_context = scope.propagation_context
  self.attachments = scope.attachments
end