Class: ScoutApm::TrackedRequest
- Inherits:
-
Object
- Object
- ScoutApm::TrackedRequest
- Defined in:
- lib/scout_apm/tracked_request.rb
Constant Summary collapse
- BACKTRACE_BLACKLIST =
["Controller", "Job"]
Instance Attribute Summary collapse
-
#annotations ⇒ Object
readonly
As we go through a request, instrumentation can mark more general data into the Request Known Keys: :uri - the full URI requested by the user :queue_latency - how long a background Job spent in the queue before starting processing.
-
#call_counts ⇒ Object
This maintains a lookup hash of Layer names and call counts.
-
#context ⇒ Object
readonly
Context is application defined extra information.
-
#dev_trace ⇒ Object
Whereas the instant_key gets set per-request in reponse to a URL param, dev_trace is set in the config file.
-
#headers ⇒ Object
readonly
Headers as recorded by rails Can be nil if we never reach a Rails Controller.
-
#instant_key ⇒ Object
if there’s an instant_key, pass the transaction trace on for immediate reporting (in addition to the usual background aggregation) this is set in the controller instumentation (ActionControllerRails3Rails4 according).
-
#recorder ⇒ Object
readonly
An object that responds to ‘record!(TrackedRequest)` to store this tracked request.
-
#request_type ⇒ Object
readonly
What kind of request is this? A trace of a web request, or a background job? Use job! and web! to set, and job? and web? to query.
-
#root_layer ⇒ Object
readonly
The first layer registered with this request.
Instance Method Summary collapse
- #acknowledge_children! ⇒ Object
-
#annotate_request(hsh) ⇒ Object
As we learn things about this request, we can add data here.
-
#backtrace_threshold ⇒ Object
Grab backtraces more aggressively when running in dev trace mode.
- #capture_backtrace?(layer) ⇒ Boolean
- #capture_mem_delta! ⇒ Object
-
#current_layer ⇒ Object
Grab the currently running layer.
-
#error! ⇒ Object
This request had an exception.
- #error? ⇒ Boolean
-
#finalized? ⇒ Boolean
Are we finished with this request? We’re done if we have no layers left after popping one off.
-
#ignore_children! ⇒ Object
Enable this when you would otherwise double track something interesting.
-
#ignore_request! ⇒ Object
At any point in the request, calling code or instrumentation can call ‘ignore_request!` to immediately stop recording any information about new layers, and delete any existing layer info.
- #ignoring_children? ⇒ Boolean
- #ignoring_recorded? ⇒ Boolean
- #ignoring_request? ⇒ Boolean
- #ignoring_start_layer ⇒ Object
- #ignoring_stop_layer ⇒ Object
-
#initialize(store) ⇒ TrackedRequest
constructor
A new instance of TrackedRequest.
- #instant? ⇒ Boolean
- #job! ⇒ Object
- #job? ⇒ Boolean
- #logger ⇒ Object
-
#mem_usage ⇒ Object
This may be in bytes or KB based on the OSX.
-
#prepare_to_dump! ⇒ Object
Actually go fetch & make-real any lazily created data.
-
#record! ⇒ Object
Convert this request to the appropriate structure, then report it into the peristent Store object.
-
#recorded! ⇒ Object
Persist the Request.
-
#recorded? ⇒ Boolean
Have we already persisted this request? Used to know when we should just create a new one (don’t attempt to add data to an already-recorded request).
-
#restore_store ⇒ Object
Go re-fetch the store based on what the Agent’s official one is.
- #set_headers(headers) ⇒ Object
- #start_layer(layer) ⇒ Object
-
#start_request(layer) ⇒ Object
Run at the beginning of the whole request.
- #stop_layer ⇒ Object
-
#stop_request ⇒ Object
Run at the end of the whole request.
- #stopping? ⇒ Boolean
-
#unique_name ⇒ Object
Only call this after the request is complete.
-
#update_call_counts!(layer) ⇒ Object
Maintains a lookup Hash of call counts by layer name.
- #web! ⇒ Object
- #web? ⇒ Boolean
Constructor Details
#initialize(store) ⇒ TrackedRequest
Returns a new instance of TrackedRequest.
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
# File 'lib/scout_apm/tracked_request.rb', line 48 def initialize(store) @store = store #this is passed in so we can use a real store (normal operation) or fake store (instant mode only) @layers = [] @call_set = Hash.new { |h, k| h[k] = CallSet.new } @annotations = {} @ignoring_children = 0 @context = Context.new @root_layer = nil @error = false @stopping = false @instant_key = nil @mem_start = mem_usage @dev_trace = ScoutApm::Agent.instance.config.value('dev_trace') && ScoutApm::Agent.instance.environment.env == "development" @recorder = ScoutApm::Agent.instance.recorder ignore_request! if @recorder.nil? end |
Instance Attribute Details
#annotations ⇒ Object (readonly)
As we go through a request, instrumentation can mark more general data into the Request Known Keys:
:uri - the full URI requested by the user
:queue_latency - how long a background Job spent in the queue before starting processing
23 24 25 |
# File 'lib/scout_apm/tracked_request.rb', line 23 def annotations @annotations end |
#call_counts ⇒ Object
This maintains a lookup hash of Layer names and call counts. It’s used to trigger fetching a backtrace on n+1 calls. Note that layer names might not be Strings - can alse be Utils::ActiveRecordMetricName. Also, this would fail for layers with same names across multiple types.
36 37 38 |
# File 'lib/scout_apm/tracked_request.rb', line 36 def call_counts @call_counts end |
#context ⇒ Object (readonly)
Context is application defined extra information. (ie, which user, what is their email/ip, what plan are they on, what locale are they using, etc) See documentation for examples on how to set this from a before_filter
13 14 15 |
# File 'lib/scout_apm/tracked_request.rb', line 13 def context @context end |
#dev_trace ⇒ Object
Whereas the instant_key gets set per-request in reponse to a URL param, dev_trace is set in the config file
43 44 45 |
# File 'lib/scout_apm/tracked_request.rb', line 43 def dev_trace @dev_trace end |
#headers ⇒ Object (readonly)
Headers as recorded by rails Can be nil if we never reach a Rails Controller
27 28 29 |
# File 'lib/scout_apm/tracked_request.rb', line 27 def headers @headers end |
#instant_key ⇒ Object
if there’s an instant_key, pass the transaction trace on for immediate reporting (in addition to the usual background aggregation) this is set in the controller instumentation (ActionControllerRails3Rails4 according)
40 41 42 |
# File 'lib/scout_apm/tracked_request.rb', line 40 def instant_key @instant_key end |
#recorder ⇒ Object (readonly)
An object that responds to ‘record!(TrackedRequest)` to store this tracked request
46 47 48 |
# File 'lib/scout_apm/tracked_request.rb', line 46 def recorder @recorder end |
#request_type ⇒ Object (readonly)
What kind of request is this? A trace of a web request, or a background job? Use job! and web! to set, and job? and web? to query
31 32 33 |
# File 'lib/scout_apm/tracked_request.rb', line 31 def request_type @request_type end |
#root_layer ⇒ Object (readonly)
The first layer registered with this request. All other layers will be children of this layer.
17 18 19 |
# File 'lib/scout_apm/tracked_request.rb', line 17 def root_layer @root_layer end |
Instance Method Details
#acknowledge_children! ⇒ Object
363 364 365 366 367 |
# File 'lib/scout_apm/tracked_request.rb', line 363 def acknowledge_children! if @ignoring_children > 0 @ignoring_children -= 1 end end |
#annotate_request(hsh) ⇒ Object
As we learn things about this request, we can add data here. For instance, when we know where Rails routed this request to, we can store that scope info. Or as soon as we know which URI it was directed at, we can store that.
This data is internal to ScoutApm, to add custom information, use the Context api.
205 206 207 |
# File 'lib/scout_apm/tracked_request.rb', line 205 def annotate_request(hsh) @annotations.merge!(hsh) end |
#backtrace_threshold ⇒ Object
Grab backtraces more aggressively when running in dev trace mode
374 375 376 |
# File 'lib/scout_apm/tracked_request.rb', line 374 def backtrace_threshold dev_trace ? 0.05 : 0.5 # the minimum threshold in seconds to record the backtrace for a metric. end |
#capture_backtrace?(layer) ⇒ Boolean
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 |
# File 'lib/scout_apm/tracked_request.rb', line 128 def capture_backtrace?(layer) return if ignoring_request? # Never capture backtraces for this kind of layer. The backtrace will # always be 100% framework code. return false if BACKTRACE_BLACKLIST.include?(layer.type) # Only capture backtraces if we're in a real "request". Otherwise we # can spend lot of time capturing backtraces from the internals of # Sidekiq, only to throw them away immediately. return false unless (web? || job?) # Capture any individually slow layer. return true if layer.total_exclusive_time > backtrace_threshold # Capture any layer that we've seen many times. Captures n+1 problems return true if @call_set[layer.name].capture_backtrace? # Don't capture otherwise false end |
#capture_mem_delta! ⇒ Object
160 161 162 |
# File 'lib/scout_apm/tracked_request.rb', line 160 def capture_mem_delta! @mem_delta = mem_usage - @mem_start end |
#current_layer ⇒ Object
Grab the currently running layer. Useful for adding additional data as we learn it. This is useful in ActiveRecord instruments, where we start the instrumentation early, and gradually learn more about the request that actually happened as we go (for instance, the # of records found, or the actual SQL generated).
Returns nil in the case there is no current layer. That would be normal for a completed TrackedRequest
123 124 125 |
# File 'lib/scout_apm/tracked_request.rb', line 123 def current_layer @layers.last end |
#error! ⇒ Object
This request had an exception. Mark it down as an error
210 211 212 |
# File 'lib/scout_apm/tracked_request.rb', line 210 def error! @error = true end |
#error? ⇒ Boolean
214 215 216 |
# File 'lib/scout_apm/tracked_request.rb', line 214 def error? @error end |
#finalized? ⇒ Boolean
Are we finished with this request? We’re done if we have no layers left after popping one off
170 171 172 |
# File 'lib/scout_apm/tracked_request.rb', line 170 def finalized? @layers.none? end |
#ignore_children! ⇒ Object
Enable this when you would otherwise double track something interesting. This came up when we implemented InfluxDB instrumentation, which is more specific, and useful than the fact that InfluxDB happens to use Net::HTTP internally
When enabled, new layers won’t be added to the current Request, and calls to stop_layer will be ignored.
Do not forget to turn if off when leaving a layer, it is the instrumentation’s task to do that.
When you use this in code, be sure to use it in this order:
start_layer ignore_children
-> call
acknowledge_children stop_layer
If you don’t call it in this order, it’s possible to get out of sync, and have an ignored start and an actually-executed stop, causing layers to get out of sync
359 360 361 |
# File 'lib/scout_apm/tracked_request.rb', line 359 def ignore_children! @ignoring_children += 1 end |
#ignore_request! ⇒ Object
At any point in the request, calling code or instrumentation can call ‘ignore_request!` to immediately stop recording any information about new layers, and delete any existing layer info. This class will still exist, and respond to methods as normal, but `record!` won’t be called, and no data will be recorded.
388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 |
# File 'lib/scout_apm/tracked_request.rb', line 388 def ignore_request! return if @ignoring_request # Set instance variable @ignoring_request = true # Store data we'll need @ignoring_depth = @layers.length # Clear data @layers = [] @root_layer = nil @call_set = nil @annotations = {} @instant_key = nil end |
#ignoring_children? ⇒ Boolean
369 370 371 |
# File 'lib/scout_apm/tracked_request.rb', line 369 def ignoring_children? @ignoring_children > 0 end |
#ignoring_recorded? ⇒ Boolean
417 418 419 |
# File 'lib/scout_apm/tracked_request.rb', line 417 def ignoring_recorded? @ignoring_depth <= 0 end |
#ignoring_request? ⇒ Boolean
405 406 407 |
# File 'lib/scout_apm/tracked_request.rb', line 405 def ignoring_request? @ignoring_request end |
#ignoring_start_layer ⇒ Object
409 410 411 |
# File 'lib/scout_apm/tracked_request.rb', line 409 def ignoring_start_layer @ignoring_depth += 1 end |
#ignoring_stop_layer ⇒ Object
413 414 415 |
# File 'lib/scout_apm/tracked_request.rb', line 413 def ignoring_stop_layer @ignoring_depth -= 1 end |
#instant? ⇒ Boolean
238 239 240 241 242 |
# File 'lib/scout_apm/tracked_request.rb', line 238 def instant? return false if ignoring_request? instant_key end |
#job! ⇒ Object
222 223 224 |
# File 'lib/scout_apm/tracked_request.rb', line 222 def job! @request_type = "job" end |
#job? ⇒ Boolean
226 227 228 |
# File 'lib/scout_apm/tracked_request.rb', line 226 def job? request_type == "job" end |
#logger ⇒ Object
421 422 423 |
# File 'lib/scout_apm/tracked_request.rb', line 421 def logger ScoutApm::Agent.instance.logger end |
#mem_usage ⇒ Object
This may be in bytes or KB based on the OSX. We store this as-is here and only do conversion to MB in Layer Converters.
156 157 158 |
# File 'lib/scout_apm/tracked_request.rb', line 156 def mem_usage ScoutApm::Instruments::Process::ProcessMemory.rss end |
#prepare_to_dump! ⇒ Object
Actually go fetch & make-real any lazily created data. Clean up any cleverness in objects. Makes this object ready to be Marshal Dumped (or otherwise serialized)
428 429 430 431 432 |
# File 'lib/scout_apm/tracked_request.rb', line 428 def prepare_to_dump! @call_set = nil @store = nil @recorder = nil end |
#record! ⇒ Object
Convert this request to the appropriate structure, then report it into the peristent Store object
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 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 |
# File 'lib/scout_apm/tracked_request.rb', line 254 def record! recorded! return if ignoring_request? # If we didn't have store, but we're trying to record anyway, go # figure that out. (this happens in Remote Agent scenarios) restore_store if @store.nil? # Bail out early if the user asked us to ignore this uri return if ScoutApm::Agent.instance.ignored_uris.ignore?(annotations[:uri]) # Update immediate and long-term histograms for both job and web requests if unique_name != :unknown ScoutApm::Agent.instance.request_histograms.add(unique_name, root_layer.total_call_time) ScoutApm::Agent.instance.request_histograms_by_time[@store.]. add(unique_name, root_layer.total_call_time) end metrics = LayerConverters::MetricConverter.new(self).call @store.track!(metrics) error_metrics = LayerConverters::ErrorConverter.new(self).call @store.track!(error_metrics) allocation_metrics = LayerConverters::AllocationMetricConverter.new(self).call @store.track!(allocation_metrics) if web? # Don't #call this - that's the job of the ScoredItemSet later. slow_converter = LayerConverters::SlowRequestConverter.new(self) @store.track_slow_transaction!(slow_converter) queue_time_metrics = LayerConverters::RequestQueueTimeConverter.new(self).call @store.track!(queue_time_metrics) # If there's an instant_key, it means we need to report this right away if instant? trace = slow_converter.call ScoutApm::InstantReporting.new(trace, instant_key).call end end if job? job_metrics = LayerConverters::JobConverter.new(self).call @store.track_job!(job_metrics) job_converter = LayerConverters::SlowJobConverter.new(self) @store.track_slow_job!(job_converter) end allocation_metrics = LayerConverters::AllocationMetricConverter.new(self).call @store.track!(allocation_metrics) end |
#recorded! ⇒ Object
Persist the Request
248 249 250 |
# File 'lib/scout_apm/tracked_request.rb', line 248 def recorded! @recorded = true end |
#recorded? ⇒ Boolean
Have we already persisted this request? Used to know when we should just create a new one (don’t attempt to add data to an already-recorded request). See RequestManager
326 327 328 329 330 |
# File 'lib/scout_apm/tracked_request.rb', line 326 def recorded? return ignoring_recorded? if ignoring_request? @recorded end |
#restore_store ⇒ Object
Go re-fetch the store based on what the Agent’s official one is. Used after hydrating a dumped TrackedRequest
436 437 438 |
# File 'lib/scout_apm/tracked_request.rb', line 436 def restore_store @store = ScoutApm::Agent.instance.store end |
#set_headers(headers) ⇒ Object
218 219 220 |
# File 'lib/scout_apm/tracked_request.rb', line 218 def set_headers(headers) @headers = headers end |
#start_layer(layer) ⇒ Object
66 67 68 69 70 71 72 73 74 75 76 |
# File 'lib/scout_apm/tracked_request.rb', line 66 def start_layer(layer) # If we're already stopping, don't do additional layers return if stopping? return if ignoring_children? return ignoring_start_layer if ignoring_request? start_request(layer) unless @root_layer @layers.push(layer) end |
#start_request(layer) ⇒ Object
Run at the beginning of the whole request
-
Capture the first layer as the root_layer
177 178 179 |
# File 'lib/scout_apm/tracked_request.rb', line 177 def start_request(layer) @root_layer = layer unless @root_layer # capture root layer end |
#stop_layer ⇒ Object
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 |
# File 'lib/scout_apm/tracked_request.rb', line 78 def stop_layer # If we're already stopping, don't do additional layers return if stopping? return if ignoring_children? return ignoring_stop_layer if ignoring_request? layer = @layers.pop # Safeguard against a mismatch in the layer tracking in an instrument. # This class works under the assumption that start & stop layers are # lined up correctly. If stop_layer gets called twice, when it should # only have been called once you'll end up with this error. if layer.nil? logger.warn("Error stopping layer, was nil. Root Layer: #{@root_layer.inspect}") stop_request return end layer.record_stop_time! layer.record_allocations! @layers[-1].add_child(layer) if @layers.any? # This must be called before checking if a backtrace should be collected as the call count influences our capture logic. # We call `#update_call_counts in stop layer to ensure the layer has a final desc. Layer#desc is updated during the AR instrumentation flow. update_call_counts!(layer) if capture_backtrace?(layer) layer.capture_backtrace! end if finalized? stop_request end end |
#stop_request ⇒ Object
Run at the end of the whole request
-
Send the request off to be stored
184 185 186 187 188 189 190 |
# File 'lib/scout_apm/tracked_request.rb', line 184 def stop_request @stopping = true if recorder recorder.record!(self) end end |
#stopping? ⇒ Boolean
192 193 194 |
# File 'lib/scout_apm/tracked_request.rb', line 192 def stopping? @stopping end |
#unique_name ⇒ Object
Only call this after the request is complete
310 311 312 313 314 315 316 317 318 319 320 321 |
# File 'lib/scout_apm/tracked_request.rb', line 310 def unique_name return nil if ignoring_request? @unique_name ||= begin scope_layer = LayerConverters::ConverterBase.new(self).scope_layer if scope_layer scope_layer.legacy_metric_name else :unknown end end end |
#update_call_counts!(layer) ⇒ Object
Maintains a lookup Hash of call counts by layer name. Used to determine if we should capture a backtrace.
151 152 153 |
# File 'lib/scout_apm/tracked_request.rb', line 151 def update_call_counts!(layer) @call_set[layer.name].update!(layer.desc) end |
#web! ⇒ Object
230 231 232 |
# File 'lib/scout_apm/tracked_request.rb', line 230 def web! @request_type = "web" end |
#web? ⇒ Boolean
234 235 236 |
# File 'lib/scout_apm/tracked_request.rb', line 234 def web? request_type == "web" end |