sentry-ruby 5.3.1 → 5.16.1

data/lib/sentry/session_flusher.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Sentry
+  class SessionFlusher
+    include LoggingHelper
+
+    FLUSH_INTERVAL = 60
+
+    def initialize(configuration, client)
+      @thread = nil
+      @exited = false
+      @client = client
+      @pending_aggregates = {}
+      @release = configuration.release
+      @environment = configuration.environment
+      @logger = configuration.logger
+
+      log_debug("[Sessions] Sessions won't be captured without a valid release") unless @release
+    end
+
+    def flush
+      return if @pending_aggregates.empty?
+      envelope = pending_envelope
+
+      Sentry.background_worker.perform do
+        @client.transport.send_envelope(envelope)
+      end
+
+      @pending_aggregates = {}
+    end
+
+    def add_session(session)
+      return if @exited
+      return unless @release
+
+      begin
+        ensure_thread
+      rescue ThreadError
+        log_debug("Session flusher thread creation failed")
+        @exited = true
+        return
+      end
+
+      return unless Session::AGGREGATE_STATUSES.include?(session.status)
+      @pending_aggregates[session.aggregation_key] ||= init_aggregates(session.aggregation_key)
+      @pending_aggregates[session.aggregation_key][session.status] += 1
+    end
+
+    def kill
+      log_debug("Killing session flusher")
+
+      @exited = true
+      @thread&.kill
+    end
+
+    private
+
+    def init_aggregates(aggregation_key)
+      aggregates = { started: aggregation_key.iso8601 }
+      Session::AGGREGATE_STATUSES.each { |k| aggregates[k] = 0 }
+      aggregates
+    end
+
+    def pending_envelope
+      envelope = Envelope.new
+
+      header = { type: 'sessions' }
+      payload = { attrs: attrs, aggregates: @pending_aggregates.values }
+
+      envelope.add_item(header, payload)
+      envelope
+    end
+
+    def attrs
+      { release: @release, environment: @environment }
+    end
+
+    def ensure_thread
+      return if @thread&.alive?
+
+      @thread = Thread.new do
+        loop do
+          sleep(FLUSH_INTERVAL)
+          flush
+        end
+      end
+    end
+
+  end
+end

data/lib/sentry/span.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Sentry
+  class Span
+
+    # We will try to be consistent with OpenTelemetry on this front going forward.
+    # https://develop.sentry.dev/sdk/performance/span-data-conventions/
+    module DataConventions
+      URL = "url"
+      HTTP_STATUS_CODE = "http.response.status_code"
+      HTTP_QUERY = "http.query"
+      HTTP_METHOD = "http.request.method"
+
+      # An identifier for the database management system (DBMS) product being used.
+      # Example: postgresql
+      DB_SYSTEM = "db.system"
+
+      # The name of the database being accessed.
+      # For commands that switch the database, this should be set to the target database
+      # (even if the command fails).
+      # Example: myDatabase
+      DB_NAME = "db.name"
+
+      # Name of the database host.
+      # Example: example.com
+      SERVER_ADDRESS = "server.address"
+
+      # Logical server port number
+      # Example: 80; 8080; 443
+      SERVER_PORT = "server.port"
+
+      # Physical server IP address or Unix socket address.
+      # Example: 10.5.3.2
+      SERVER_SOCKET_ADDRESS = "server.socket.address"
+
+      # Physical server port.
+      # Recommended: If different than server.port.
+      # Example: 16456
+      SERVER_SOCKET_PORT = "server.socket.port"
+    end
+
+    STATUS_MAP = {
+      400 => "invalid_argument",
+      401 => "unauthenticated",
+      403 => "permission_denied",
+      404 => "not_found",
+      409 => "already_exists",
+      429 => "resource_exhausted",
+      499 => "cancelled",
+      500 => "internal_error",
+      501 => "unimplemented",
+      503 => "unavailable",
+      504 => "deadline_exceeded"
+    }
+
+    # An uuid that can be used to identify a trace.
+    # @return [String]
+    attr_reader :trace_id
+    # An uuid that can be used to identify the span.
+    # @return [String]
+    attr_reader :span_id
+    # Span parent's span_id.
+    # @return [String]
+    attr_reader :parent_span_id
+    # Sampling result of the span.
+    # @return [Boolean, nil]
+    attr_reader :sampled
+    # Starting timestamp of the span.
+    # @return [Float]
+    attr_reader :start_timestamp
+    # Finishing timestamp of the span.
+    # @return [Float]
+    attr_reader :timestamp
+    # Span description
+    # @return [String]
+    attr_reader :description
+    # Span operation
+    # @return [String]
+    attr_reader :op
+    # Span status
+    # @return [String]
+    attr_reader :status
+    # Span tags
+    # @return [Hash]
+    attr_reader :tags
+    # Span data
+    # @return [Hash]
+    attr_reader :data
+
+    # The SpanRecorder the current span belongs to.
+    # SpanRecorder holds all spans under the same Transaction object (including the Transaction itself).
+    # @return [SpanRecorder]
+    attr_accessor :span_recorder
+
+    # The Transaction object the Span belongs to.
+    # Every span needs to be attached to a Transaction and their child spans will also inherit the same transaction.
+    # @return [Transaction]
+    attr_reader :transaction
+
+    def initialize(
+      transaction:,
+      description: nil,
+      op: nil,
+      status: nil,
+      trace_id: nil,
+      span_id: nil,
+      parent_span_id: nil,
+      sampled: nil,
+      start_timestamp: nil,
+      timestamp: nil
+    )
+      @trace_id = trace_id || SecureRandom.uuid.delete("-")
+      @span_id = span_id || SecureRandom.uuid.delete("-").slice(0, 16)
+      @parent_span_id = parent_span_id
+      @sampled = sampled
+      @start_timestamp = start_timestamp || Sentry.utc_now.to_f
+      @timestamp = timestamp
+      @description = description
+      @transaction = transaction
+      @op = op
+      @status = status
+      @data = {}
+      @tags = {}
+    end
+
+    # Finishes the span by adding a timestamp.
+    # @return [self]
+    def finish(end_timestamp: nil)
+      @timestamp = end_timestamp || @timestamp || Sentry.utc_now.to_f
+      self
+    end
+
+    # Generates a trace string that can be used to connect other transactions.
+    # @return [String]
+    def to_sentry_trace
+      sampled_flag = ""
+      sampled_flag = @sampled ? 1 : 0 unless @sampled.nil?
+
+      "#{@trace_id}-#{@span_id}-#{sampled_flag}"
+    end
+
+    # Generates a W3C Baggage header string for distributed tracing
+    # from the incoming baggage stored on the transaction.
+    # @return [String, nil]
+    def to_baggage
+      transaction.get_baggage&.serialize
+    end
+
+    # @return [Hash]
+    def to_hash
+      {
+        trace_id: @trace_id,
+        span_id: @span_id,
+        parent_span_id: @parent_span_id,
+        start_timestamp: @start_timestamp,
+        timestamp: @timestamp,
+        description: @description,
+        op: @op,
+        status: @status,
+        tags: @tags,
+        data: @data
+      }
+    end
+
+    # Returns the span's context that can be used to embed in an Event.
+    # @return [Hash]
+    def get_trace_context
+      {
+        trace_id: @trace_id,
+        span_id: @span_id,
+        parent_span_id: @parent_span_id,
+        description: @description,
+        op: @op,
+        status: @status
+      }
+    end
+
+    # Starts a child span with given attributes.
+    # @param attributes [Hash] the attributes for the child span.
+    def start_child(**attributes)
+      attributes = attributes.dup.merge(transaction: @transaction, trace_id: @trace_id, parent_span_id: @span_id, sampled: @sampled)
+      new_span = Span.new(**attributes)
+      new_span.span_recorder = span_recorder
+
+      if span_recorder
+        span_recorder.add(new_span)
+      end
+
+      new_span
+    end
+
+    # Starts a child span, yield it to the given block, and then finish the span after the block is executed.
+    # @example
+    #   span.with_child_span do |child_span|
+    #     # things happen here will be recorded in a child span
+    #   end
+    #
+    # @param attributes [Hash] the attributes for the child span.
+    # @param block [Proc] the action to be recorded in the child span.
+    # @yieldparam child_span [Span]
+    def with_child_span(**attributes, &block)
+      child_span = start_child(**attributes)
+
+      yield(child_span)
+
+      child_span.finish
+    rescue
+      child_span.set_http_status(500)
+      child_span.finish
+      raise
+    end
+
+    def deep_dup
+      dup
+    end
+
+    # Sets the span's operation.
+    # @param op [String] operation of the span.
+    def set_op(op)
+      @op = op
+    end
+
+    # Sets the span's description.
+    # @param description [String] description of the span.
+    def set_description(description)
+      @description = description
+    end
+
+
+    # Sets the span's status.
+    # @param satus [String] status of the span.
+    def set_status(status)
+      @status = status
+    end
+
+    # Sets the span's finish timestamp.
+    # @param timestamp [Float] finished time in float format (most precise).
+    def set_timestamp(timestamp)
+      @timestamp = timestamp
+    end
+
+    # Sets the span's status with given http status code.
+    # @param status_code [String] example: "500".
+    def set_http_status(status_code)
+      status_code = status_code.to_i
+      set_data(DataConventions::HTTP_STATUS_CODE, status_code)
+
+      status =
+        if status_code >= 200 && status_code < 299
+          "ok"
+        else
+          STATUS_MAP[status_code]
+        end
+      set_status(status)
+    end
+
+    # Inserts a key-value pair to the span's data payload.
+    # @param key [String, Symbol]
+    # @param value [Object]
+    def set_data(key, value)
+      @data[key] = value
+    end
+
+    # Sets a tag to the span.
+    # @param key [String, Symbol]
+    # @param value [String]
+    def set_tag(key, value)
+      @tags[key] = value
+    end
+  end
+end

data/lib/sentry/test_helper.rb

@@ -0,0 +1,84 @@
+module Sentry
+  module TestHelper
+    DUMMY_DSN = 'http://12345:67890@sentry.localdomain/sentry/42'
+
+    # Alters the existing SDK configuration with test-suitable options. Mainly:
+    # - Sets a dummy DSN instead of `nil` or an actual DSN.
+    # - Sets the transport to DummyTransport, which allows easy access to the captured events.
+    # - Disables background worker.
+    # - Makes sure the SDK is enabled under the current environment ("test" in most cases).
+    #
+    # It should be called **before** every test case.
+    #
+    # @yieldparam config [Configuration]
+    # @return [void]
+    def setup_sentry_test(&block)
+      raise "please make sure the SDK is initialized for testing" unless Sentry.initialized?
+      dummy_config = Sentry.configuration.dup
+      # configure dummy DSN, so the events will not be sent to the actual service
+      dummy_config.dsn = DUMMY_DSN
+      # set transport to DummyTransport, so we can easily intercept the captured events
+      dummy_config.transport.transport_class = Sentry::DummyTransport
+      # make sure SDK allows sending under the current environment
+      dummy_config.enabled_environments << dummy_config.environment unless dummy_config.enabled_environments.include?(dummy_config.environment)
+      # disble async event sending
+      dummy_config.background_worker_threads = 0
+
+      # user can overwrite some of the configs, with a few exceptions like:
+      # - include_local_variables
+      # - auto_session_tracking
+      block&.call(dummy_config)
+
+      # the base layer's client should already use the dummy config so nothing will be sent by accident
+      base_client = Sentry::Client.new(dummy_config)
+      Sentry.get_current_hub.bind_client(base_client)
+      # create a new layer so mutations made to the testing scope or configuration could be simply popped later
+      Sentry.get_current_hub.push_scope
+      test_client = Sentry::Client.new(dummy_config.dup)
+      Sentry.get_current_hub.bind_client(test_client)
+    end
+
+    # Clears all stored events and envelopes.
+    # It should be called **after** every test case.
+    # @return [void]
+    def teardown_sentry_test
+      return unless Sentry.initialized?
+
+      # pop testing layer created by `setup_sentry_test`
+      # but keep the base layer to avoid nil-pointer errors
+      # TODO: find a way to notify users if they somehow popped the test layer before calling this method
+      if Sentry.get_current_hub.instance_variable_get(:@stack).size > 1
+        Sentry.get_current_hub.pop_scope
+      end
+    end
+
+    # @return [Transport]
+    def sentry_transport
+      Sentry.get_current_client.transport
+    end
+
+    # Returns the captured event objects.
+    # @return [Array<Event>]
+    def sentry_events
+      sentry_transport.events
+    end
+
+    # Returns the captured envelope objects.
+    # @return [Array<Envelope>]
+    def sentry_envelopes
+      sentry_transport.envelopes
+    end
+
+    # Returns the last captured event object.
+    # @return [Event, nil]
+    def last_sentry_event
+      sentry_events.last
+    end
+
+    # Extracts SDK's internal exception container (not actual exception objects) from an given event.
+    # @return [Array<Sentry::SingleExceptionInterface>]
+    def extract_sentry_exceptions(event)
+      event&.exception&.values || []
+    end
+  end
+end