feat(billing): highlight matched conditional multipliers in logs (#6561)

* feat(billing): highlight matched conditional multipliers in usage logs * fix(billing): make request rule tracing stable and type-safe
2026-08-10 12:50:27 +08:00
parent d49160f0e5
commit 4cf9107f04
12 changed files with 400 additions and 110 deletions
@@ -16,6 +16,11 @@ const maxCacheSize = 256
 // DefaultExprVersion is used when an expression string has no version prefix.
 const DefaultExprVersion = 1

+const (
+	requestRuleTraceFunction    = "_trace"
+	requestRuleTraceIntFunction = "_trace_int"
+)
+
 // ParseExprVersion extracts the version tag and body from an expression string.
 // Format: "v1:tier(...)" → version=1, body="tier(...)".
 // No prefix defaults to DefaultExprVersion.
@@ -26,10 +31,88 @@ func ParseExprVersion(exprStr string) (version int, body string) {
 	return DefaultExprVersion, exprStr
 }

+// requestRulePatcher adds trace side effects to existing request multipliers
+// without changing the stored expression or its numeric result.
+type requestRulePatcher struct {
+	requestRules         []RequestRuleTrace
+	restrictedIdentifier string
+}
+
+func (p *requestRulePatcher) Visit(node *ast.Node) {
+	if identifier, ok := (*node).(*ast.IdentifierNode); ok {
+		switch identifier.Value {
+		case requestRuleTraceFunction, requestRuleTraceIntFunction:
+			p.restrictedIdentifier = identifier.Value
+		}
+		return
+	}
+
+	conditional, ok := (*node).(*ast.ConditionalNode)
+	if !ok || !conditional.Ternary || !usesRequestProbe(conditional.Cond) {
+		return
+	}
+	multiplier, ok := requestRuleNumber(conditional.Exp1)
+	fallback, fallbackOK := requestRuleNumber(conditional.Exp2)
+	if !ok || !fallbackOK || fallback != 1 {
+		return
+	}
+
+	ruleIndex := len(p.requestRules)
+	p.requestRules = append(p.requestRules, RequestRuleTrace{
+		Cond:       conditional.Cond.String(),
+		Multiplier: multiplier,
+	})
+
+	traceFunction := requestRuleTraceFunction
+	var multiplierNode ast.Node = &ast.FloatNode{Value: multiplier}
+	if _, multiplierIsInt := conditional.Exp1.(*ast.IntegerNode); multiplierIsInt {
+		if _, fallbackIsInt := conditional.Exp2.(*ast.IntegerNode); fallbackIsInt {
+			traceFunction = requestRuleTraceIntFunction
+			multiplierNode = conditional.Exp1
+		}
+	}
+
+	ast.Patch(node, &ast.CallNode{
+		Callee: &ast.IdentifierNode{Value: traceFunction},
+		Arguments: []ast.Node{
+			&ast.IntegerNode{Value: ruleIndex},
+			conditional.Cond,
+			multiplierNode,
+		},
+	})
+}
+
+func requestRuleNumber(node ast.Node) (float64, bool) {
+	switch value := node.(type) {
+	case *ast.IntegerNode:
+		return float64(value.Value), true
+	case *ast.FloatNode:
+		return value.Value, true
+	default:
+		return 0, false
+	}
+}
+
+func usesRequestProbe(node ast.Node) bool {
+	return ast.Find(node, func(node ast.Node) bool {
+		identifier, ok := node.(*ast.IdentifierNode)
+		if !ok {
+			return false
+		}
+		switch identifier.Value {
+		case "param", "header", "hour", "minute", "weekday", "month", "day":
+			return true
+		default:
+			return false
+		}
+	}) != nil
+}
+
 type cachedEntry struct {
-	prog     *vm.Program
-	usedVars map[string]bool
-	version  int
+	prog         *vm.Program
+	usedVars     map[string]bool
+	requestRules []RequestRuleTrace
+	version      int
 }

 var (
@@ -39,30 +122,32 @@ var (

 // compileEnvPrototypeV1 is the v1 type-checking prototype used at compile time.
 var compileEnvPrototypeV1 = map[string]interface{}{
-	"p":       float64(0),
-	"c":       float64(0),
-	"len":     float64(0),
-	"cr":      float64(0),
-	"cc":      float64(0),
-	"cc1h":    float64(0),
-	"img":     float64(0),
-	"img_o":   float64(0),
-	"ai":      float64(0),
-	"ao":      float64(0),
-	"tier":    func(string, float64) float64 { return 0 },
-	"header":  func(string) string { return "" },
-	"param":   func(string) interface{} { return nil },
-	"has":     func(interface{}, string) bool { return false },
-	"hour":    func(string) int { return 0 },
-	"minute":  func(string) int { return 0 },
-	"weekday": func(string) int { return 0 },
-	"month":   func(string) int { return 0 },
-	"day":     func(string) int { return 0 },
-	"max":     math.Max,
-	"min":     math.Min,
-	"abs":     math.Abs,
-	"ceil":    math.Ceil,
-	"floor":   math.Floor,
+	"p":          float64(0),
+	"c":          float64(0),
+	"len":        float64(0),
+	"cr":         float64(0),
+	"cc":         float64(0),
+	"cc1h":       float64(0),
+	"img":        float64(0),
+	"img_o":      float64(0),
+	"ai":         float64(0),
+	"ao":         float64(0),
+	"tier":       func(string, float64) float64 { return 0 },
+	"_trace":     func(int, bool, float64) float64 { return 1 },
+	"_trace_int": func(int, bool, int) int { return 1 },
+	"header":     func(string) string { return "" },
+	"param":      func(string) interface{} { return nil },
+	"has":        func(interface{}, string) bool { return false },
+	"hour":       func(string) int { return 0 },
+	"minute":     func(string) int { return 0 },
+	"weekday":    func(string) int { return 0 },
+	"month":      func(string) int { return 0 },
+	"day":        func(string) int { return 0 },
+	"max":        math.Max,
+	"min":        math.Min,
+	"abs":        math.Abs,
+	"ceil":       math.Ceil,
+	"floor":      math.Floor,
 }

 func getCompileEnv(version int) map[string]interface{} {
@@ -85,29 +170,45 @@ func CompileFromCacheByHash(exprStr, hash string) (*vm.Program, error) {
 }

 func compileFromCacheByHash(exprStr, hash string) (*vm.Program, error) {
+	entry, err := compileEntryFromCacheByHash(exprStr, hash)
+	if err != nil {
+		return nil, err
+	}
+	return entry.prog, nil
+}
+
+func compileEntryFromCacheByHash(exprStr, hash string) (*cachedEntry, error) {
 	cacheMu.RLock()
 	if entry, ok := cache[hash]; ok {
 		cacheMu.RUnlock()
-		return entry.prog, nil
+		return entry, nil
 	}
 	cacheMu.RUnlock()

 	version, body := ParseExprVersion(exprStr)
-	prog, err := expr.Compile(body, expr.Env(getCompileEnv(version)), expr.AsFloat64())
+	patcher := &requestRulePatcher{}
+	prog, err := expr.Compile(body, expr.Env(getCompileEnv(version)), expr.Patch(patcher), expr.AsFloat64())
+	if patcher.restrictedIdentifier != "" {
+		return nil, fmt.Errorf("expr compile error: identifier %q is reserved for internal use", patcher.restrictedIdentifier)
+	}
 	if err != nil {
 		return nil, fmt.Errorf("expr compile error: %w", err)
 	}

-	vars := extractUsedVars(prog)
-
+	entry := &cachedEntry{
+		prog:         prog,
+		usedVars:     extractUsedVars(prog),
+		requestRules: patcher.requestRules,
+		version:      version,
+	}
 	cacheMu.Lock()
 	if len(cache) >= maxCacheSize {
 		cache = make(map[string]*cachedEntry, 64)
 	}
-	cache[hash] = &cachedEntry{prog: prog, usedVars: vars, version: version}
+	cache[hash] = entry
 	cacheMu.Unlock()

-	return prog, nil
+	return entry, nil
 }

 // ExprVersion returns the version of a cached expression. Returns DefaultExprVersion
@@ -132,6 +233,10 @@ func extractUsedVars(prog *vm.Program) map[string]bool {
 	node := prog.Node()
 	ast.Find(node, func(n ast.Node) bool {
 		if id, ok := n.(*ast.IdentifierNode); ok {
+			switch id.Value {
+			case requestRuleTraceFunction, requestRuleTraceIntFunction:
+				return false
+			}
 			vars[id.Value] = true
 		}
 		return false