feat: New set_attribute api (#2998)

set_attribute(key, value, unit: nil)
set_attributes(attributes_hash)
remove_attribute(key)


Claude-Session: https://claude.ai/code/session_01AtcJFmXABtrEgpwngfZxq5

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: sl0thentr0py

sentry-ruby/lib/sentry-ruby.rb

@@ -220,6 +220,35 @@ def set_context(*args)
       get_current_scope.set_context(*args)
     end
 
+    # @!method set_attributes
+    #   Updates the current scope's attributes by merging with the old value.
+    #   @param attributes_hash [Hash]
+    #   @return [Hash]
+    def set_attributes(attributes_hash)
+      return unless initialized?
+      get_current_scope.set_attributes(attributes_hash)
+    end
+
+    # @!method set_attribute
+    #   Sets a single attribute on the current scope.
+    #   @param key [String, Symbol]
+    #   @param value [Object]
+    #   @param unit [String, Symbol, nil] an optional measurement unit for the value
+    #   @return [Hash]
+    def set_attribute(key, value, unit: nil)
+      return unless initialized?
+      get_current_scope.set_attribute(key, value, unit: unit)
+    end
+
+    # @!method remove_attribute
+    #   Removes a single attribute from the current scope.
+    #   @param key [String, Symbol]
+    #   @return [void]
+    def remove_attribute(key)
+      return unless initialized?
+      get_current_scope.remove_attribute(key)
+    end
+
     # @!method add_attachment
     #   @!macro add_attachment
     def add_attachment(**opts)

sentry-ruby/lib/sentry/scope.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "set"
 require "sentry/breadcrumb_buffer"
 require "sentry/propagation_context"
 require "sentry/attachment"
@@ -24,7 +25,8 @@ class Scope
       :span,
       :session,
       :attachments,
-      :propagation_context
+      :propagation_context,
+      :attributes
     ]
 
     attr_reader(*ATTRIBUTES)
@@ -84,7 +86,15 @@ def apply_to_event(event, hint = nil)
     # @param telemetry [MetricEvent, LogEvent] the telemetry event to apply scope context to
     # @return [MetricEvent, LogEvent] the telemetry event with scope context applied
     def apply_to_telemetry(telemetry)
-      # TODO-neel when new scope set_attribute api is added: add them here
+      # Compare as strings since String and Symbol keys serialize to the same wire key.
+      existing_keys = telemetry.attributes.keys.map(&:to_s).to_set
+
+      attributes.each do |key, value|
+        next if existing_keys.include?(key)
+
+        telemetry.attributes[key] = value
+      end
+
       trace_context = get_trace_context
       telemetry.trace_id = trace_context[:trace_id]
       telemetry.span_id = trace_context[:span_id]
@@ -136,6 +146,7 @@ def dup
       copy.propagation_context = propagation_context.deep_dup
       copy.attachments = attachments.dup
       copy.event_processors = event_processors.dup
+      copy.attributes = attributes.deep_dup
       copy
     end
 
@@ -154,6 +165,7 @@ def update_from_scope(scope)
       self.span = scope.span
       self.propagation_context = scope.propagation_context
       self.attachments = scope.attachments
+      self.attributes = scope.attributes
     end
 
     # Updates the scope's data from the given options.
@@ -256,6 +268,32 @@ def set_context(key, value)
       set_contexts(key => value)
     end
 
+    # Updates the scope's attributes by merging with the old value.
+    # @param attributes_hash [Hash]
+    # @return [Hash]
+    def set_attributes(attributes_hash)
+      check_argument_type!(attributes_hash, Hash)
+      attributes_hash.each { |key, value| @attributes[key.to_s] = value }
+      @attributes
+    end
+
+    # Sets a single attribute on the scope.
+    # @param key [String, Symbol]
+    # @param value [Object]
+    # @param unit [String, Symbol, nil] an optional measurement unit for the value
+    # @return [Hash]
+    def set_attribute(key, value, unit: nil)
+      value = { value: value, unit: unit } unless unit.nil?
+      set_attributes(key => value)
+    end
+
+    # Removes a single attribute from the scope. No-op if the attribute is not set.
+    # @param key [String, Symbol]
+    # @return [void]
+    def remove_attribute(key)
+      @attributes.delete(key.to_s)
+    end
+
     # Sets the scope's level attribute.
     # @param level [String, Symbol]
     # @return [void]
@@ -361,6 +399,7 @@ def set_default_value
       @span = nil
       @session = nil
       @attachments = []
+      @attributes = {}
       generate_propagation_context
       set_new_breadcrumb_buffer
     end

sentry-ruby/lib/sentry/utils/telemetry_attributes.rb

@@ -7,23 +7,35 @@ module Utils
     module TelemetryAttributes
       private
 
-      def attribute_hash(value)
-        case value
-        when String
-          { value: value, type: "string" }
-        when TrueClass, FalseClass
-          { value: value, type: "boolean" }
-        when Integer
-          { value: value, type: "integer" }
-        when Float
-          { value: value, type: "double" }
+      def attribute_hash(raw_value)
+        if raw_value.is_a?(Hash) && (raw_value.key?(:value) || raw_value.key?("value"))
+          value = raw_value.key?(:value) ? raw_value[:value] : raw_value["value"]
+          unit = raw_value.key?(:unit) ? raw_value[:unit] : raw_value["unit"]
         else
-          begin
-            { value: JSON.generate(value), type: "string" }
-          rescue
+          value = raw_value
+          unit = nil
+        end
+
+        result =
+          case value
+          when String
             { value: value, type: "string" }
+          when TrueClass, FalseClass
+            { value: value, type: "boolean" }
+          when Integer
+            { value: value, type: "integer" }
+          when Float
+            { value: value, type: "double" }
+          else
+            begin
+              { value: JSON.generate(value), type: "string" }
+            rescue
+              { value: value, type: "string" }
+            end
           end
-        end
+
+        result[:unit] = unit.to_s if unit.is_a?(String) || unit.is_a?(Symbol)
+        result
       end
     end
   end

sentry-ruby/spec/sentry/metric_event_spec.rb

@@ -117,6 +117,59 @@
       expect(attributes["unknown"][:value]).to include("Object")
     end
 
+    it "carries units through the object form" do
+      event = described_class.new(
+        name: "test.metric",
+        type: "counter",
+        value: 1.0,
+        attributes: {
+          "duration_int" => { value: 3600, unit: "second" },
+          "duration_float" => { value: 1.5, unit: "millisecond" },
+          "version" => { value: "v1", unit: "version" },
+          "symbol_unit" => { value: 3600, unit: :second },
+          "invalid_unit" => { value: 1, unit: 5 }
+        }
+      )
+
+      attributes = event.to_h[:attributes]
+
+      expect(attributes["duration_int"]).to eq({ type: "integer", value: 3600, unit: "second" })
+      expect(attributes["duration_float"]).to eq({ type: "double", value: 1.5, unit: "millisecond" })
+      expect(attributes["version"]).to eq({ type: "string", value: "v1", unit: "version" })
+      expect(attributes["symbol_unit"]).to eq({ type: "integer", value: 3600, unit: "second" })
+      expect(attributes["invalid_unit"]).to eq({ type: "integer", value: 1 })
+    end
+
+    it "carries units through the object form with string keys" do
+      event = described_class.new(
+        name: "test.metric",
+        type: "counter",
+        value: 1.0,
+        attributes: {
+          "duration" => { "value" => 3600, "unit" => "second" },
+          "version" => { "value" => "v1" }
+        }
+      )
+
+      attributes = event.to_h[:attributes]
+
+      expect(attributes["duration"]).to eq({ type: "integer", value: 3600, unit: "second" })
+      expect(attributes["version"]).to eq({ type: "string", value: "v1" })
+    end
+
+    it "treats a hash without a value key as a plain JSON string value" do
+      event = described_class.new(
+        name: "test.metric",
+        type: "counter",
+        value: 1.0,
+        attributes: { "obj" => { "foo" => "bar" } }
+      )
+
+      attributes = event.to_h[:attributes]
+
+      expect(attributes["obj"]).to eq({ type: "string", value: "{\"foo\":\"bar\"}" })
+    end
+
     it "does not mutate the original attributes hash" do
       attributes = { "foo" => "bar" }
       event1 = described_class.new(name: "test.metric", type: :counter, value: 1, attributes: attributes)

sentry-ruby/spec/sentry/metrics_spec.rb

@@ -188,6 +188,34 @@
         end
       end
 
+      context "with attributes on scope" do
+        it "includes scope attributes with inferred types in the metric" do
+          Sentry.set_attribute("app.flag", true)
+          Sentry.set_attribute("app.duration", 3600, unit: "second")
+
+          Sentry.metrics.count("test.counter")
+
+          Sentry.get_current_client.flush
+
+          attributes = sentry_metrics.first[:attributes]
+
+          expect(attributes["app.flag"]).to eq({ type: "boolean", value: true })
+          expect(attributes["app.duration"]).to eq({ type: "integer", value: 3600, unit: "second" })
+        end
+
+        it "lets metric attributes take precedence over scope attributes" do
+          Sentry.set_attribute("shared", "from_scope")
+
+          Sentry.metrics.count("test.counter", attributes: { "shared" => "from_metric" })
+
+          Sentry.get_current_client.flush
+
+          attributes = sentry_metrics.first[:attributes]
+
+          expect(attributes["shared"]).to eq({ type: "string", value: "from_metric" })
+        end
+      end
+
       it "includes default attributes from configuration" do
         Sentry.metrics.count("test.counter")
 

sentry-ruby/spec/sentry/scope/setters_spec.rb

@@ -228,4 +228,85 @@
       expect(subject.fingerprint).to eq(["bar"])
     end
   end
+
+  describe "#set_attributes" do
+    it "merges the given attributes into the scope" do
+      subject.set_attributes("foo" => "bar")
+      subject.set_attributes("baz" => 42)
+
+      expect(subject.attributes).to eq({ "foo" => "bar", "baz" => 42 })
+    end
+
+    it "overwrites an existing attribute with the same key" do
+      subject.set_attributes("foo" => "bar")
+      subject.set_attributes("foo" => "qux")
+
+      expect(subject.attributes).to eq({ "foo" => "qux" })
+    end
+
+    it "normalizes symbol keys to strings" do
+      subject.set_attributes(foo: "bar")
+      subject.set_attributes("foo" => "qux")
+
+      expect(subject.attributes).to eq({ "foo" => "qux" })
+    end
+
+    it "raises when the argument is not a Hash" do
+      expect { subject.set_attributes("foo") }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#set_attribute" do
+    it "sets a single attribute" do
+      subject.set_attribute("foo", "bar")
+
+      expect(subject.attributes).to eq({ "foo" => "bar" })
+    end
+
+    it "overwrites an existing attribute" do
+      subject.set_attribute("foo", "bar")
+      subject.set_attribute("foo", "qux")
+
+      expect(subject.attributes).to eq({ "foo" => "qux" })
+    end
+
+    it "supports the object form with a unit" do
+      subject.set_attribute("duration", { value: 3600, unit: "second" })
+
+      expect(subject.attributes).to eq({ "duration" => { value: 3600, unit: "second" } })
+    end
+
+    it "wraps the value when given the optional unit: param" do
+      subject.set_attribute("duration", 3600, unit: "second")
+
+      expect(subject.attributes).to eq({ "duration" => { value: 3600, unit: "second" } })
+    end
+
+    it "normalizes a symbol key to a string" do
+      subject.set_attribute(:foo, "bar")
+
+      expect(subject.attributes).to eq({ "foo" => "bar" })
+    end
+  end
+
+  describe "#remove_attribute" do
+    it "removes the attribute" do
+      subject.set_attribute("foo", "bar")
+      subject.remove_attribute("foo")
+
+      expect(subject.attributes).to eq({})
+    end
+
+    it "is a no-op when the attribute is not set" do
+      expect { subject.remove_attribute("missing") }.not_to raise_error
+      expect(subject.attributes).to eq({})
+    end
+
+    it "removes an attribute set with a symbol key" do
+      subject.set_attribute(:foo, "bar")
+      subject.remove_attribute(:foo)
+
+      expect(subject.attributes).to eq({})
+    end
+  end
 end