Add more e2e coverage for DSC

Author: solnic

spec/apps/rails-mini/app.rb

@@ -17,6 +17,14 @@ class RailsMiniApp < Rails::Application
   config.api_only = true
   config.force_ssl = false
 
+  def debug_log_path
+    @log_path ||= begin
+      path = Pathname(__dir__).join("../../../log")
+      FileUtils.mkdir_p(path) unless path.exist?
+      path.realpath
+    end
+  end
+
   initializer :configure_sentry do
     Sentry.init do |config|
       config.dsn = ENV["SENTRY_DSN"]
@@ -28,9 +36,8 @@ class RailsMiniApp < Rails::Application
       config.debug = true
       config.include_local_variables = true
       config.release = "sentry-ruby-rails-mini-#{Time.now.utc}"
-
       config.transport.transport_class = Sentry::DebugTransport
-      config.sdk_debug_transport_log_file = "/workspace/sentry/log/sentry_debug_events.log"
+      config.sdk_debug_transport_log_file = debug_log_path.join("sentry_debug_events.log")
       config.background_worker_threads = 0
     end
   end
@@ -57,11 +64,22 @@ class EventsController < ActionController::Base
   before_action :set_cors_headers
 
   def health
+    sentry_initialized = Sentry.initialized?
+    sentry_dsn = ENV["SENTRY_DSN"]
+
     render json: {
       status: "ok",
       timestamp: Time.now.utc.iso8601,
-      sentry_initialized: Sentry.initialized?,
-      log_file_writable: check_log_file_writable
+      sentry_initialized: sentry_initialized,
+      sentry_dsn_configured: !sentry_dsn.nil? && !sentry_dsn.empty?,
+      sentry_dsn: sentry_dsn,
+      sentry_environment: sentry_initialized ? Sentry.configuration.environment : nil,
+      debug_info: {
+        sentry_loaded: defined?(Sentry),
+        configuration_present: Sentry.respond_to?(:configuration),
+        dsn_configured: Sentry.respond_to?(:configuration) && Sentry.configuration&.dsn.present?,
+        env_dsn_value: sentry_dsn
+      }
     }
   end
 
@@ -72,14 +90,6 @@ def trace_headers
 
   private
 
-  def check_log_file_writable
-    log_file_path = "/workspace/sentry/log/sentry_debug_events.log"
-    File.writable?(File.dirname(log_file_path)) &&
-      (!File.exist?(log_file_path) || File.writable?(log_file_path))
-  rescue
-    false
-  end
-
   def set_cors_headers
     response.headers['Access-Control-Allow-Origin'] = '*'
     response.headers['Access-Control-Allow-Methods'] = 'GET, POST, PUT, DELETE, OPTIONS'
@@ -94,7 +104,6 @@ def set_cors_headers
   get '/error', to: 'error#error'
   get '/trace_headers', to: 'events#trace_headers'
 
-  # Add CORS headers for cross-origin requests from JS app
   match '*path', to: proc { |env|
     [200, {
       'Access-Control-Allow-Origin' => '*',

spec/features/tracing_spec.rb

@@ -1,7 +1,51 @@
 # frozen_string_literal: true
 
-RSpec.describe "Tracing", type: :feature do
-  it "works" do
+RSpec.describe "Tracing", type: :e2e do
+  def expect_valid_sample_rand(sample_rand)
+    expect(sample_rand).not_to be_nil
+    expect(sample_rand).to match(/^\d+\.\d{1,6}$/)
+    sample_rand_value = sample_rand.to_f
+    expect(sample_rand_value).to be >= 0.0
+    expect(sample_rand_value).to be < 1.0
+  end
+
+  def expect_dsc_in_envelope_headers
+    envelopes_with_dsc = logged_events[:envelopes].select do |envelope|
+      envelope["headers"] && envelope["headers"]["trace"]
+    end
+
+    expect(envelopes_with_dsc).not_to be_empty
+
+    dsc_metadata = envelopes_with_dsc.map { |envelope| envelope["headers"]["trace"] }
+
+    envelopes_with_sample_rand = dsc_metadata.select { |dsc| dsc["sample_rand"] }
+    expect(envelopes_with_sample_rand).not_to be_empty
+
+    envelopes_with_sample_rand.each do |dsc|
+      expect_valid_sample_rand(dsc["sample_rand"])
+    end
+
+    dsc_metadata
+  end
+
+  def get_http_server_transactions_with_headers
+    transaction_events = logged_events[:events].select { |event| event["type"] == "transaction" }
+    expect(transaction_events).not_to be_empty
+
+    http_server_transactions = transaction_events.select { |event|
+      event.dig("contexts", "trace", "op") == "http.server"
+    }
+    expect(http_server_transactions).not_to be_empty
+
+    transactions_with_headers = http_server_transactions.select { |transaction|
+      headers = transaction.dig("request", "headers")
+      headers && (headers["Sentry-Trace"] || headers["sentry-trace"])
+    }
+    expect(transactions_with_headers).not_to be_empty
+
+    transactions_with_headers
+  end
+  it "validates basic tracing functionality" do
     visit "/error"
 
     expect(page).to have_content("Svelte Mini App")
@@ -16,46 +60,79 @@
     error_events = logged_events[:events].select { |event| event["exception"] }
     expect(error_events).not_to be_empty
 
-    error_event = error_events.first
+    error_event = error_events.last
     exception_values = error_event.dig("exception", "values")
     expect(exception_values).not_to be_empty
     expect(exception_values.first["type"]).to eq("ZeroDivisionError")
 
-    transaction_events = logged_events[:events].select { |event| event["type"] == "transaction" }
-
     expect(error_event.dig("contexts", "trace")).not_to be_nil
     error_trace_id = error_event.dig("contexts", "trace", "trace_id")
-    expect(error_trace_id).to_not be(nil)
+    expect(error_trace_id).not_to be_nil
+
+    transaction_events = logged_events[:events].select { |event| event["type"] == "transaction" }
+    expect(transaction_events).not_to be_empty
+
+    transactions_with_dsc = transaction_events.select { |event|
+      event.dig("_meta", "dsc", "sample_rand")
+    }
+
+    transactions_with_dsc.each do |transaction|
+      expect_valid_sample_rand(transaction.dig("_meta", "dsc", "sample_rand"))
+    end
+  end
+
+  describe "propagated sample_rand behavior" do
+    it "validates DSC metadata is properly generated and included in envelope headers" do
+      visit "/error"
+
+      expect(page).to have_content("Svelte Mini App")
+      expect(page).to have_button("Trigger Error")
 
-    if transaction_events.any?
-      transaction_event = transaction_events.first
-      trace_context = transaction_event.dig("contexts", "trace")
+      click_button "trigger-error-btn"
 
-      expect(trace_context).not_to be_nil
+      expect(page).to have_content("Error:")
 
-      transaction_trace_id = trace_context["trace_id"]
+      dsc_envelopes = expect_dsc_in_envelope_headers
 
-      expect(transaction_trace_id).to_not be(nil)
-      expect(error_trace_id).to eq(transaction_trace_id)
+      dsc_envelopes.each do |dsc|
+        expect(dsc["trace_id"]).not_to be_nil
+        expect(dsc["trace_id"]).to match(/^[a-f0-9]{32}$/)
 
-      if transaction_event["_meta"] && transaction_event["_meta"]["dsc"]
-        dsc = transaction_event["_meta"]["dsc"]
-        expect(dsc).to include("sample_rand")
+        expect(dsc["sample_rate"]).not_to be_nil
+        expect(dsc["sample_rate"].to_f).to be > 0.0
 
-        sample_rand = dsc["sample_rand"]
-        expect(sample_rand).to_not be(nil)
+        expect(dsc["sample_rand"]).not_to be_nil
+        expect_valid_sample_rand(dsc["sample_rand"])
+
+        expect(dsc["sampled"]).to eq("true")
+        expect(dsc["environment"]).to eq("development")
+        expect(dsc["public_key"]).to eq("user")
       end
     end
 
-    logged_events[:envelopes].each do |envelope|
-      envelope["items"].each do |item|
-        if item["payload"] && item["payload"]["_meta"] && item["payload"]["_meta"]["dsc"]
-          dsc = item["payload"]["_meta"]["dsc"]
+    it "validates DSC sample_rand generation across multiple requests" do
+      visit "/error"
+
+      expect(page).to have_content("Svelte Mini App")
+
+      3.times do |i|
+        click_button "trigger-error-btn"
+        sleep 0.1
+      end
+
+      expect(page).to have_content("Error:")
+
+      dsc_envelopes = expect_dsc_in_envelope_headers
+      expect(dsc_envelopes.length).to be >= 2
+
+      trace_ids = dsc_envelopes.map { |dsc| dsc["trace_id"] }.uniq
+      sample_rands = dsc_envelopes.map { |dsc| dsc["sample_rand"] }.uniq
+
+      expect(trace_ids.length).to be >= 2
+      expect(sample_rands.length).to be >= 2
 
-          if dsc["sample_rand"]
-            expect(dsc["sample_rand"]).to_not be(nil)
-          end
-        end
+      sample_rands.each do |sample_rand|
+        expect_valid_sample_rand(sample_rand)
       end
     end
   end

spec/support/test_helper.rb

@@ -16,7 +16,7 @@ def logged_events
           }
 
           event_data["items"].each do |item|
-            if item["headers"]["type"] == "event"
+            if ["event", "transaction"].include?(item["headers"]["type"])
               extracted_events << item["payload"]
             end
           end