tracekit 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e67785497c76c4ff7cbeed1a4cd229c5f70fb15a83c4ed1189cb109ad7963dc
-  data.tar.gz: 00a2956e0e8ec619accbc8f033dfe1ef5f09ac8be0d2484d345afbd056ff7bda
+  metadata.gz: 9133bb6f1112ae31a4732cf52a12d209fa908e6f0acb5af92d3bf566ecc99ff5
+  data.tar.gz: dd8eeb7476eef7bc591833194b8805c9f0c74f8c1b8e389a4b34834ceea5c201
 SHA512:
-  metadata.gz: 35bfcf1a1ab26d68b05ca50fff003d8a53f30b4ce42afe69394b57fbe80dcd1b3595568b80545ec45d8bead93e6f1e02ef4f3ec2ebfabd952b37dad587798e60
-  data.tar.gz: 22b9312c9b1af79507f9b240ec98cd4d7c6855484d86703928f74a54a4b1f2558662b78dc6e18ef4ca27dcb72ab5e5d71c36b89a40f1333161fb8973b888c3b7
+  metadata.gz: 10f4ff9f1123866d67485d7b02a1224a22abc9f3e05814064d8057103172c7a13a7a527a8626b612a622df3feed3f9ec0ddb632550d669a1a62f46a18354c86f
+  data.tar.gz: 3b9c8a7b79eb316ef4322b1b54deba4bc9e6b3538ff2c3fdefb6b4cfff5b394e6003d4dcbe225d837f2da5fa6f246044e1c6052d539b6e7a1063317c71b639a8

data/lib/tracekit/evaluator.rb

@@ -0,0 +1,604 @@
+# frozen_string_literal: true
+
+module Tracekit
+  # Expression evaluator for the TraceKit portable expression subset.
+  # Evaluates breakpoint conditions locally to avoid server round-trips.
+  #
+  # Uses a custom recursive-descent parser -- never eval()/instance_eval.
+  # Supports: comparison, logical, arithmetic, string concat, property access,
+  # bracket notation, membership (in), null safety, and grouping.
+  module Evaluator
+    class UnsupportedExpressionError < StandardError; end
+
+    # Returns true if the expression can be evaluated locally by the SDK.
+    # Returns false for expressions containing function calls, regex operators,
+    # assignment, array indexing, ternary, range, template literals, or bitwise operators.
+    def self.sdk_evaluable?(expression)
+      return true if expression.nil? || expression.strip.empty?
+
+      # Function calls: word followed by opening paren
+      return false if expression.match?(/\b[a-zA-Z_]\w*\s*\(/)
+
+      # Regex match keyword
+      return false if expression.match?(/\bmatches\b/)
+
+      # Regex operator =~
+      return false if expression.include?("=~")
+
+      # Bitwise NOT ~ (but not inside =~, already handled above)
+      expression.each_char.with_index do |ch, i|
+        if ch == "~" && (i == 0 || expression[i - 1] != "=")
+          return false
+        end
+      end
+
+      # Bitwise AND: single & not part of &&
+      i = 0
+      while i < expression.length
+        if expression[i] == "&"
+          if i + 1 < expression.length && expression[i + 1] == "&"
+            i += 2
+            next
+          end
+          return false
+        end
+        i += 1
+      end
+
+      # Bitwise OR: single | not part of ||
+      i = 0
+      while i < expression.length
+        if expression[i] == "|"
+          if i + 1 < expression.length && expression[i + 1] == "|"
+            i += 2
+            next
+          end
+          return false
+        end
+        i += 1
+      end
+
+      # Bit shift
+      return false if expression.include?("<<") || expression.include?(">>")
+
+      # Template literals
+      return false if expression.include?("${")
+
+      # Range operator
+      return false if expression.include?("..")
+
+      # Ternary
+      return false if expression.include?("?")
+
+      # Array indexing [N]
+      return false if expression.match?(/\[\d/)
+
+      # Compound assignment
+      return false if expression.match?(/[+\-*\/]=/)
+
+      true
+    end
+
+    # Evaluates an expression string against the given environment
+    # and returns a boolean result. Empty expressions return true.
+    # Raises UnsupportedExpressionError for server-only expressions.
+    def self.evaluate_condition(expression, env)
+      return true if expression.nil? || expression.strip.empty?
+
+      unless sdk_evaluable?(expression)
+        raise UnsupportedExpressionError, "unsupported expression: requires server-side evaluation"
+      end
+
+      result = evaluate_expression(expression, env)
+
+      case result
+      when true, false
+        result
+      when nil
+        false
+      else
+        # Non-boolean result from a condition -- treat as truthy
+        true
+      end
+    end
+
+    # Evaluates an expression and returns the raw result value.
+    # Raises UnsupportedExpressionError for server-only expressions.
+    def self.evaluate_expression(expression, env)
+      return nil if expression.nil? || expression.strip.empty?
+
+      unless sdk_evaluable?(expression)
+        raise UnsupportedExpressionError, "unsupported expression: requires server-side evaluation"
+      end
+
+      tokens = Lexer.tokenize(expression)
+      parser = Parser.new(tokens, env)
+      parser.parse_expression
+    end
+
+    # Evaluates multiple expressions against the given environment.
+    # Results are keyed by expression string. On error, nil is stored.
+    def self.evaluate_expressions(expressions, env)
+      results = {}
+      expressions.each do |expr|
+        results[expr] = evaluate_expression(expr, env)
+      rescue StandardError
+        results[expr] = nil
+      end
+      results
+    end
+
+    # Token types for the lexer
+    module TokenType
+      NUMBER    = :number
+      STRING    = :string
+      BOOL      = :bool
+      NIL       = :nil
+      IDENT     = :ident
+      DOT       = :dot
+      LBRACKET  = :lbracket
+      RBRACKET  = :rbracket
+      LPAREN    = :lparen
+      RPAREN    = :rparen
+      PLUS      = :plus
+      MINUS     = :minus
+      STAR      = :star
+      SLASH     = :slash
+      EQ        = :eq
+      NEQ       = :neq
+      LT        = :lt
+      GT        = :gt
+      LTE       = :lte
+      GTE       = :gte
+      AND       = :and
+      OR        = :or
+      NOT       = :not
+      IN        = :in
+      EOF       = :eof
+    end
+
+    Token = Struct.new(:type, :value, keyword_init: true)
+
+    # Lexer: converts expression string into tokens.
+    module Lexer
+      def self.tokenize(input)
+        tokens = []
+        i = 0
+        while i < input.length
+          ch = input[i]
+
+          # Skip whitespace
+          if ch =~ /\s/
+            i += 1
+            next
+          end
+
+          # Two-character operators
+          if i + 1 < input.length
+            two = input[i, 2]
+            case two
+            when "=="
+              tokens << Token.new(type: TokenType::EQ, value: "==")
+              i += 2
+              next
+            when "!="
+              tokens << Token.new(type: TokenType::NEQ, value: "!=")
+              i += 2
+              next
+            when "<="
+              tokens << Token.new(type: TokenType::LTE, value: "<=")
+              i += 2
+              next
+            when ">="
+              tokens << Token.new(type: TokenType::GTE, value: ">=")
+              i += 2
+              next
+            when "&&"
+              tokens << Token.new(type: TokenType::AND, value: "&&")
+              i += 2
+              next
+            when "||"
+              tokens << Token.new(type: TokenType::OR, value: "||")
+              i += 2
+              next
+            end
+          end
+
+          # Single-character tokens
+          case ch
+          when "."
+            tokens << Token.new(type: TokenType::DOT, value: ".")
+            i += 1
+            next
+          when "["
+            tokens << Token.new(type: TokenType::LBRACKET, value: "[")
+            i += 1
+            next
+          when "]"
+            tokens << Token.new(type: TokenType::RBRACKET, value: "]")
+            i += 1
+            next
+          when "("
+            tokens << Token.new(type: TokenType::LPAREN, value: "(")
+            i += 1
+            next
+          when ")"
+            tokens << Token.new(type: TokenType::RPAREN, value: ")")
+            i += 1
+            next
+          when "+"
+            tokens << Token.new(type: TokenType::PLUS, value: "+")
+            i += 1
+            next
+          when "-"
+            # Check if this is a negative number (unary minus before digits)
+            if (tokens.empty? || [:plus, :minus, :star, :slash, :eq, :neq, :lt, :gt, :lte, :gte, :and, :or, :not, :lparen].include?(tokens.last&.type)) &&
+               i + 1 < input.length && input[i + 1] =~ /\d/
+              # Parse as negative number
+              start = i
+              i += 1
+              i += 1 while i < input.length && (input[i] =~ /\d/ || input[i] == ".")
+              num_str = input[start...i]
+              value = num_str.include?(".") ? num_str.to_f : num_str.to_i
+              tokens << Token.new(type: TokenType::NUMBER, value: value)
+              next
+            end
+            tokens << Token.new(type: TokenType::MINUS, value: "-")
+            i += 1
+            next
+          when "*"
+            tokens << Token.new(type: TokenType::STAR, value: "*")
+            i += 1
+            next
+          when "/"
+            tokens << Token.new(type: TokenType::SLASH, value: "/")
+            i += 1
+            next
+          when "<"
+            tokens << Token.new(type: TokenType::LT, value: "<")
+            i += 1
+            next
+          when ">"
+            tokens << Token.new(type: TokenType::GT, value: ">")
+            i += 1
+            next
+          when "!"
+            tokens << Token.new(type: TokenType::NOT, value: "!")
+            i += 1
+            next
+          end
+
+          # String literals (double or single quoted)
+          if ch == '"' || ch == "'"
+            quote = ch
+            i += 1
+            start = i
+            while i < input.length && input[i] != quote
+              i += 1 if input[i] == "\\" # skip escaped char
+              i += 1
+            end
+            tokens << Token.new(type: TokenType::STRING, value: input[start...i])
+            i += 1 # skip closing quote
+            next
+          end
+
+          # Numbers
+          if ch =~ /\d/
+            start = i
+            i += 1 while i < input.length && (input[i] =~ /\d/ || input[i] == ".")
+            num_str = input[start...i]
+            value = num_str.include?(".") ? num_str.to_f : num_str.to_i
+            tokens << Token.new(type: TokenType::NUMBER, value: value)
+            next
+          end
+
+          # Identifiers and keywords
+          if ch =~ /[a-zA-Z_]/
+            start = i
+            i += 1 while i < input.length && input[i] =~ /[a-zA-Z0-9_]/
+            word = input[start...i]
+            case word
+            when "true"
+              tokens << Token.new(type: TokenType::BOOL, value: true)
+            when "false"
+              tokens << Token.new(type: TokenType::BOOL, value: false)
+            when "nil", "null", "None"
+              tokens << Token.new(type: TokenType::NIL, value: nil)
+            when "in"
+              tokens << Token.new(type: TokenType::IN, value: "in")
+            else
+              tokens << Token.new(type: TokenType::IDENT, value: word)
+            end
+            next
+          end
+
+          raise "unexpected character: #{ch}"
+        end
+
+        tokens << Token.new(type: TokenType::EOF, value: nil)
+        tokens
+      end
+    end
+
+    # Recursive-descent parser and evaluator.
+    # Operator precedence (lowest to highest):
+    #   || -> && -> == != -> < > <= >= -> + - -> * / -> ! (unary) -> primary
+    class Parser
+      def initialize(tokens, env)
+        @tokens = tokens
+        @env = env
+        @pos = 0
+      end
+
+      def parse_expression
+        parse_or
+      end
+
+      private
+
+      def current
+        @tokens[@pos]
+      end
+
+      def advance
+        t = @tokens[@pos]
+        @pos += 1
+        t
+      end
+
+      def match(*types)
+        if types.include?(current.type)
+          advance
+        end
+      end
+
+      def expect(type)
+        if current.type == type
+          advance
+        else
+          raise "expected #{type}, got #{current.type} (#{current.value})"
+        end
+      end
+
+      # OR: expr || expr
+      def parse_or
+        left = parse_and
+        while current.type == TokenType::OR
+          advance
+          right = parse_and
+          left = left || right
+        end
+        left
+      end
+
+      # AND: expr && expr
+      def parse_and
+        left = parse_equality
+        while current.type == TokenType::AND
+          advance
+          right = parse_equality
+          left = left && right
+        end
+        left
+      end
+
+      # Equality: == !=
+      def parse_equality
+        left = parse_comparison
+        while (op = match(TokenType::EQ, TokenType::NEQ))
+          right = parse_comparison
+          left = case op.type
+                 when TokenType::EQ then safe_equal?(left, right)
+                 when TokenType::NEQ then !safe_equal?(left, right)
+                 end
+        end
+        left
+      end
+
+      # Comparison: < > <= >=
+      def parse_comparison
+        left = parse_membership
+        while (op = match(TokenType::LT, TokenType::GT, TokenType::LTE, TokenType::GTE))
+          right = parse_membership
+          left = safe_compare(op.type, left, right)
+        end
+        left
+      end
+
+      # Membership: "key" in map
+      def parse_membership
+        left = parse_addition
+        if current.type == TokenType::IN
+          advance
+          right = parse_addition
+          return membership_check(left, right)
+        end
+        left
+      end
+
+      # Addition/subtraction/string concatenation
+      def parse_addition
+        left = parse_multiplication
+        while (op = match(TokenType::PLUS, TokenType::MINUS))
+          right = parse_multiplication
+          if op.type == TokenType::PLUS
+            if left.is_a?(String) || right.is_a?(String)
+              left = "#{left}#{right}"
+            else
+              left = numeric_val(left) + numeric_val(right)
+            end
+          else
+            left = numeric_val(left) - numeric_val(right)
+          end
+        end
+        left
+      end
+
+      # Multiplication/division
+      def parse_multiplication
+        left = parse_unary
+        while (op = match(TokenType::STAR, TokenType::SLASH))
+          right = parse_unary
+          if op.type == TokenType::STAR
+            left = numeric_val(left) * numeric_val(right)
+          else
+            divisor = numeric_val(right)
+            return nil if divisor == 0
+            left = numeric_val(left) / divisor
+          end
+        end
+        left
+      end
+
+      # Unary: ! (NOT)
+      def parse_unary
+        if current.type == TokenType::NOT
+          advance
+          val = parse_unary
+          return !val
+        end
+        parse_primary
+      end
+
+      # Primary: literals, identifiers (with property access), grouping
+      def parse_primary
+        tok = current
+
+        case tok.type
+        when TokenType::NUMBER
+          advance
+          resolve_postfix(tok.value)
+        when TokenType::STRING
+          advance
+          resolve_postfix(tok.value)
+        when TokenType::BOOL
+          advance
+          resolve_postfix(tok.value)
+        when TokenType::NIL
+          advance
+          resolve_postfix(nil)
+        when TokenType::IDENT
+          advance
+          value = resolve_identifier(tok.value)
+          resolve_postfix(value)
+        when TokenType::LPAREN
+          advance
+          result = parse_expression
+          expect(TokenType::RPAREN)
+          resolve_postfix(result)
+        else
+          raise "unexpected token: #{tok.type} (#{tok.value})"
+        end
+      end
+
+      # Handle dot notation and bracket notation after a value
+      def resolve_postfix(value)
+        loop do
+          if current.type == TokenType::DOT
+            advance
+            if current.type == TokenType::IDENT
+              key = advance.value
+              value = safe_access(value, key)
+            else
+              raise "expected identifier after dot"
+            end
+          elsif current.type == TokenType::LBRACKET
+            advance
+            key = parse_expression
+            expect(TokenType::RBRACKET)
+            value = safe_access(value, key.to_s)
+          else
+            break
+          end
+        end
+        value
+      end
+
+      # Resolve a top-level identifier from the environment
+      def resolve_identifier(name)
+        if @env.key?(name)
+          @env[name]
+        elsif @env.key?(name.to_sym)
+          @env[name.to_sym]
+        else
+          nil
+        end
+      end
+
+      # Null-safe property access: accessing a key on nil returns nil
+      def safe_access(obj, key)
+        return nil if obj.nil?
+
+        if obj.is_a?(Hash)
+          if obj.key?(key)
+            obj[key]
+          elsif obj.key?(key.to_sym)
+            obj[key.to_sym]
+          else
+            nil
+          end
+        else
+          nil
+        end
+      end
+
+      # Safe equality with type coercion rules:
+      # - Integer/Float promotion allowed
+      # - No other implicit coercion
+      def safe_equal?(a, b)
+        # nil handling
+        return true if a.nil? && b.nil?
+        return false if a.nil? || b.nil?
+
+        # Integer/Float promotion
+        if numeric?(a) && numeric?(b)
+          return a.to_f == b.to_f
+        end
+
+        a == b
+      end
+
+      # Safe comparison for < > <= >=
+      # Returns false for incompatible types
+      def safe_compare(op, a, b)
+        return false if a.nil? || b.nil?
+
+        # Both numeric
+        if numeric?(a) && numeric?(b)
+          a_val = a.to_f
+          b_val = b.to_f
+          case op
+          when TokenType::LT then a_val < b_val
+          when TokenType::GT then a_val > b_val
+          when TokenType::LTE then a_val <= b_val
+          when TokenType::GTE then a_val >= b_val
+          end
+        elsif a.is_a?(String) && b.is_a?(String)
+          case op
+          when TokenType::LT then a < b
+          when TokenType::GT then a > b
+          when TokenType::LTE then a <= b
+          when TokenType::GTE then a >= b
+          end
+        else
+          false
+        end
+      end
+
+      # Check if "key" in map
+      def membership_check(key, map)
+        return false unless map.is_a?(Hash)
+        map.key?(key) || map.key?(key.to_s) || map.key?(key.to_sym)
+      end
+
+      def numeric?(val)
+        val.is_a?(Integer) || val.is_a?(Float)
+      end
+
+      def numeric_val(val)
+        return 0 if val.nil?
+        val
+      end
+    end
+  end
+end

data/lib/tracekit/snapshots/client.rb

@@ -91,9 +91,31 @@ module Tracekit
         return if breakpoint.expire_at && Time.now > breakpoint.expire_at
         return if breakpoint.max_captures > 0 && breakpoint.capture_count >= breakpoint.max_captures
 
-        # Apply opt-in capture depth limit
-        if @capture_depth && @capture_depth > 0
-          variables = limit_depth(variables, 0)
+        # Evaluate breakpoint condition locally for sdk-evaluable expressions
+        if breakpoint.condition && !breakpoint.condition.empty? && breakpoint.condition_eval == "sdk-evaluable"
+          begin
+            result = Tracekit::Evaluator.evaluate_condition(breakpoint.condition, variables)
+            return unless result # Condition false, skip capture
+          rescue Tracekit::Evaluator::UnsupportedExpressionError
+            # Classified as sdk-evaluable but failed locally, fall through to server
+            warn "TraceKit: expression classified as sdk-evaluable but failed locally, falling back to server" if ENV["DEBUG"]
+          rescue => e
+            # Other evaluation error, log and fall through to server
+            warn "TraceKit: condition evaluation error, falling back to server: #{e.message}" if ENV["DEBUG"]
+          end
+        end
+
+        # Logpoint mode: capture only expression results, skip locals/stack/request
+        if breakpoint.mode == "logpoint"
+          snapshot = build_logpoint_snapshot(breakpoint, file_path, line_number, function_name, label, variables)
+          Thread.new { submit_snapshot_with_payload_limit(snapshot, breakpoint.max_payload_bytes) }
+          return
+        end
+
+        # Apply per-breakpoint capture depth limit (with SDK-level fallback)
+        effective_depth = breakpoint.max_depth || @capture_depth
+        if effective_depth && effective_depth > 0
+          variables = limit_depth(variables, 0, effective_depth)
         end
 
         # Scan for security issues
@@ -104,14 +126,23 @@ module Tracekit
         span_id = nil
         if defined?(OpenTelemetry::Trace)
           span = OpenTelemetry::Trace.current_span
-          if span && span.context.valid? && (span.context.trace_flags & OpenTelemetry::Trace::TraceFlags::SAMPLED) != 0
-            trace_id = span.context.hex_trace_id
-            span_id = span.context.hex_span_id
+          if span && span.context.valid?
+            sampled = begin
+              span.context.trace_flags.sampled?
+            rescue NoMethodError
+              # Fallback for older OTel versions
+              (span.context.trace_flags.to_i & 0x01) != 0 rescue false
+            end
+            if sampled
+              trace_id = span.context.hex_trace_id
+              span_id = span.context.hex_span_id
+            end
           end
         end
 
-        # Get stack trace
-        stack_trace = caller.join("\n")
+        # Get stack trace with dynamic depth from per-breakpoint config
+        effective_stack_depth = breakpoint.stack_depth || 50
+        stack_trace = caller(1, effective_stack_depth).join("\n")
 
         snapshot = Snapshot.new(
           breakpoint_id: breakpoint.id,
@@ -128,24 +159,9 @@ module Tracekit
           captured_at: Time.now.utc.iso8601
         )
 
-        # Apply opt-in max payload limit
-        serialized = JSON.generate(snapshot.to_h)
-        if @max_payload && @max_payload > 0 && serialized.bytesize > @max_payload
-          snapshot = Snapshot.new(
-            breakpoint_id: breakpoint.id,
-            service_name: @service_name,
-            file_path: file_path,
-            function_name: function_name,
-            label: label,
-            line_number: line_number,
-            variables: { "_truncated" => true, "_payload_size" => serialized.bytesize, "_max_payload" => @max_payload },
-            security_flags: [],
-            stack_trace: stack_trace,
-            trace_id: trace_id,
-            span_id: span_id,
-            captured_at: Time.now.utc.iso8601
-          )
-        end
+        # Apply per-breakpoint max payload limit (with SDK-level fallback)
+        effective_max_payload = breakpoint.max_payload_bytes || @max_payload
+        submit_snapshot_with_payload_limit(snapshot, effective_max_payload)
 
         # Submit asynchronously (with optional timeout)
         if @capture_timeout && @capture_timeout > 0
@@ -169,24 +185,77 @@ module Tracekit
 
       private
 
-      # Limit variable nesting depth (opt-in)
-      def limit_depth(data, current_depth)
-        return { "_truncated" => true, "_depth" => current_depth } if current_depth >= @capture_depth
+      # Limit variable nesting depth (opt-in, supports per-breakpoint override)
+      def limit_depth(data, current_depth, max_depth = nil)
+        effective_depth = max_depth || @capture_depth
+        return { "_truncated" => true, "_depth" => current_depth } if current_depth >= effective_depth
 
         case data
         when Hash
           result = {}
           data.each do |k, v|
-            result[k] = limit_depth(v, current_depth + 1)
+            result[k] = limit_depth(v, current_depth + 1, effective_depth)
           end
           result
         when Array
-          data.map { |item| limit_depth(item, current_depth + 1) }
+          data.map { |item| limit_depth(item, current_depth + 1, effective_depth) }
         else
           data
         end
       end
 
+      # Build a logpoint snapshot: expression results only, no locals/stack
+      def build_logpoint_snapshot(breakpoint, file_path, line_number, function_name, label, variables)
+        expression_results = {}
+        if breakpoint.capture_expressions && !breakpoint.capture_expressions.empty?
+          expression_results = Tracekit::Evaluator.evaluate_expressions(
+            breakpoint.capture_expressions, variables
+          )
+        end
+
+        Snapshot.new(
+          breakpoint_id: breakpoint.id,
+          service_name: @service_name,
+          file_path: file_path,
+          function_name: function_name,
+          label: label,
+          line_number: line_number,
+          variables: {},
+          security_flags: [],
+          stack_trace: "",
+          trace_id: nil,
+          span_id: nil,
+          captured_at: Time.now.utc.iso8601,
+          expression_results: expression_results,
+          mode: "logpoint"
+        )
+      end
+
+      # Submit snapshot with payload limit check
+      def submit_snapshot_with_payload_limit(snapshot, max_payload_bytes)
+        effective_limit = max_payload_bytes || @max_payload
+        if effective_limit && effective_limit > 0
+          serialized = JSON.generate(snapshot.to_h)
+          if serialized.bytesize > effective_limit
+            snapshot = Snapshot.new(
+              breakpoint_id: snapshot.breakpoint_id,
+              service_name: snapshot.service_name,
+              file_path: snapshot.file_path,
+              function_name: snapshot.function_name,
+              label: snapshot.label,
+              line_number: snapshot.line_number,
+              variables: { "_truncated" => true, "_payload_size" => serialized.bytesize, "_max_payload" => effective_limit },
+              security_flags: [],
+              stack_trace: snapshot.stack_trace,
+              trace_id: snapshot.trace_id,
+              span_id: snapshot.span_id,
+              captured_at: snapshot.captured_at
+            )
+          end
+        end
+        Thread.new { submit_snapshot(snapshot) }
+      end
+
       def fetch_active_breakpoints
         url = "#{@base_url}/sdk/snapshots/active/#{@service_name}"
         uri = URI(url)
@@ -237,17 +306,7 @@ module Tracekit
         @breakpoints_cache.clear
 
         breakpoints.each do |bp_data|
-          bp = BreakpointConfig.new(
-            id: bp_data[:id],
-            file_path: bp_data[:file_path],
-            line_number: bp_data[:line_number],
-            function_name: bp_data[:function_name],
-            label: bp_data[:label],
-            enabled: bp_data[:enabled],
-            max_captures: bp_data[:max_captures] || 0,
-            capture_count: bp_data[:capture_count] || 0,
-            expire_at: bp_data[:expire_at] ? Time.parse(bp_data[:expire_at]) : nil
-          )
+          bp = build_breakpoint_config(bp_data)
 
           # Key by function + label
           if bp.label && bp.function_name
@@ -303,6 +362,7 @@ module Tracekit
       end
 
       def submit_snapshot(snapshot)
+        # Circuit breaker check
         # Circuit breaker check
         return unless circuit_breaker_should_allow?
 
@@ -455,9 +515,9 @@ module Tracekit
         warn "TraceKit: SSE event handling error: #{e.message}" if ENV["DEBUG"]
       end
 
-      # Upsert a single breakpoint into the cache
-      def upsert_breakpoint(bp_data)
-        bp = BreakpointConfig.new(
+      # Build a BreakpointConfig from parsed payload data
+      def build_breakpoint_config(bp_data)
+        BreakpointConfig.new(
           id: bp_data[:id],
           file_path: bp_data[:file_path],
           line_number: bp_data[:line_number],
@@ -466,8 +526,21 @@ module Tracekit
           enabled: bp_data[:enabled],
           max_captures: bp_data[:max_captures] || 0,
           capture_count: bp_data[:capture_count] || 0,
-          expire_at: bp_data[:expire_at] ? Time.parse(bp_data[:expire_at]) : nil
+          expire_at: bp_data[:expire_at] ? Time.parse(bp_data[:expire_at]) : nil,
+          condition: bp_data[:condition],
+          condition_eval: bp_data[:condition_eval],
+          mode: bp_data[:mode],
+          stack_depth: bp_data[:stack_depth],
+          max_depth: bp_data[:max_depth],
+          max_payload_bytes: bp_data[:max_payload_bytes],
+          capture_expressions: bp_data[:capture_expressions],
+          idle_timeout_hours: bp_data[:idle_timeout_hours]
         )
+      end
+
+      # Upsert a single breakpoint into the cache
+      def upsert_breakpoint(bp_data)
+        bp = build_breakpoint_config(bp_data)
 
         # Key by function + label
         if bp.label && bp.function_name

data/lib/tracekit/snapshots/models.rb

@@ -6,6 +6,10 @@ module Tracekit
     BreakpointConfig = Struct.new(
       :id, :file_path, :line_number, :function_name, :label,
       :enabled, :max_captures, :capture_count, :expire_at,
+      # v25 capture features
+      :condition, :condition_eval, :mode, :stack_depth,
+      :max_depth, :max_payload_bytes, :capture_expressions,
+      :idle_timeout_hours,
       keyword_init: true
     )
 
@@ -14,6 +18,8 @@ module Tracekit
       :breakpoint_id, :service_name, :file_path, :function_name, :label,
       :line_number, :variables, :security_flags, :stack_trace,
       :trace_id, :span_id, :captured_at,
+      # v25 capture features
+      :expression_results, :mode,
       keyword_init: true
     )
 

data/lib/tracekit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tracekit
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

data/lib/tracekit.rb

@@ -3,6 +3,7 @@
 require_relative "tracekit/version"
 require_relative "tracekit/config"
 require_relative "tracekit/endpoint_resolver"
+require_relative "tracekit/evaluator"
 
 # Metrics
 require_relative "tracekit/metrics/metric_data_point"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tracekit
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - TraceKit
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-03-21 00:00:00.000000000 Z
+date: 2026-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-sdk
@@ -150,6 +150,7 @@ files:
 - lib/tracekit.rb
 - lib/tracekit/config.rb
 - lib/tracekit/endpoint_resolver.rb
+- lib/tracekit/evaluator.rb
 - lib/tracekit/llm/anthropic_instrumentation.rb
 - lib/tracekit/llm/common.rb
 - lib/tracekit/llm/openai_instrumentation.rb