File size: 11,015 Bytes
e48a2d8
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
// Package jsonscan 从**原始 JSON 字节**里读取少数几个字段,不做整棵树的解析。
//
// 为什么需要它:网关每处理一个 chat 请求,会对同一个 body 做 4~6 次
// json.Unmarshal(会话键、首条 role、kimi 工具、body 归一化、会话字段注入),
// 而线上代理负载的 body 常在 100~500KB。整棵树解析要给每个字符串解转义、
// 建 map、分配几十万对象;其中大部分字段根本没人看。
//
// 本包遍历一次、只解出被问到的少数几个字符串,其余值按 JSON 语法跳过(零分配)。
// 语义与 encoding/json 一致:解出来的值走 json.Unmarshal 解转义;跳过只看语法。
// 任何解析不了的情况都返回 Ok=false,调用方**必须**回落到整树解析。
//
// 性能要点(都是实测踩出来的):
//   - 不要为「查一个键」扫整个 body 多次——一次遍历收集所有想要的键;
//   - 不要对跳过的字符串调用 json.Unmarshal(第一版的致命错误:600KB 历史消息里
//     几千个字符串各解一次,比整树解析还慢 4 倍);
//   - 字符串边界用 bytes.IndexByte,只在疑似反斜杠时才回退逐字节。
package jsonscan

import (
	"bytes"
	"encoding/json"
	"fmt"
	"unicode/utf8"
)

// Query 描述要读的字段。
type Query struct {
	// Top 顶层键(只取值是字符串的那些)。
	Top []string
	// Nested 顶层子对象键(例如 "metadata");与 NestedKeys 都非空时才生效。
	Nested     string
	NestedKeys []string
}

// Result 读取结果。Ok=false 表示 body 不是本包能完整走完的 JSON 对象,
// 调用方应回落整树解析(此时其它字段的值不可信)。
type Result struct {
	Top    map[string]string
	Nested map[string]string
	Ok     bool
}

// Get 取顶层键的值(未命中 / 非字符串 → "")。
func (r Result) Get(key string) string { return r.Top[key] }

// GetNested 取顶层子对象里的键值(未命中 / 非字符串 → "")。
func (r Result) GetNested(key string) string { return r.Nested[key] }

// Lookup 单遍遍历顶层对象,收集 Query 要求的字符串值。
//
// 大数据量的字段(messages/tools)在这里只是被跳过,不做任何解码。
func Lookup(body []byte, q Query) Result {
	res := Result{Top: map[string]string{}, Nested: map[string]string{}}
	i := skipSpace(body, 0)
	if i >= len(body) || body[i] != '{' {
		return res
	}
	i++
	for {
		i = skipSpace(body, i)
		if i >= len(body) {
			return res
		}
		if body[i] == '}' {
			res.Ok = true
			return res
		}
		key, next, ok := readKey(body, i)
		if !ok {
			return res
		}
		i = skipSpace(body, next)
		if i >= len(body) || body[i] != ':' {
			return res
		}
		i = skipSpace(body, i+1)
		if q.Nested != "" && len(q.NestedKeys) > 0 && string(key) == q.Nested {
			res.Nested = collect(body, i, q.NestedKeys)
			j, ok := skipValue(body, i)
			if !ok {
				return res
			}
			i = skipSpace(body, j)
		} else if matchAny(key, q.Top) {
			if v, after, ok := readStrValue(body, i); ok {
				res.Top[string(key)] = v
				i = skipSpace(body, after)
			} else {
				j, ok := skipValue(body, i)
				if !ok {
					return res
				}
				i = skipSpace(body, j)
			}
		} else {
			j, ok := skipValue(body, i)
			if !ok {
				return res
			}
			i = skipSpace(body, j)
		}
		if i >= len(body) {
			return res
		}
		switch body[i] {
		case ',':
			i++
		case '}':
			res.Ok = true
			return res
		default:
			return res
		}
	}
}

// collect 在 body[i] 处的对象里收集 keys 的字符串值(未命中留空)。
func collect(body []byte, i int, keys []string) map[string]string {
	out := map[string]string{}
	i = skipSpace(body, i)
	if i >= len(body) || body[i] != '{' {
		return out
	}
	i++
	for {
		i = skipSpace(body, i)
		if i >= len(body) || body[i] == '}' {
			return out
		}
		key, next, ok := readKey(body, i)
		if !ok {
			return out
		}
		i = skipSpace(body, next)
		if i >= len(body) || body[i] != ':' {
			return out
		}
		i = skipSpace(body, i+1)
		if matchAny(key, keys) {
			if v, after, ok := readStrValue(body, i); ok {
				out[string(key)] = v
				i = skipSpace(body, after)
			} else {
				j, ok := skipValue(body, i)
				if !ok {
					return out
				}
				i = skipSpace(body, j)
			}
		} else {
			j, ok := skipValue(body, i)
			if !ok {
				return out
			}
			i = skipSpace(body, j)
		}
		if i >= len(body) {
			return out
		}
		switch body[i] {
		case ',':
			i++
		case '}':
			return out
		default:
			return out
		}
	}
}

// TopLevelString 取顶层对象里某个键的字符串值(便捷入口;查多个键时直接用 Lookup)。
func TopLevelString(body []byte, key string) (string, bool) {
	res := Lookup(body, Query{Top: []string{key}})
	if !res.Ok {
		return "", false
	}
	v, ok := res.Top[key]
	return v, ok
}

// NestedString 取顶层对象.objKey 这个子对象里 key 的字符串值。
func NestedString(body []byte, objKey, key string) (string, bool) {
	res := Lookup(body, Query{Nested: objKey, NestedKeys: []string{key}})
	if !res.Ok {
		return "", false
	}
	v, ok := res.Nested[key]
	return v, ok
}

// FirstMessageRole 取 messages[0].role。语义与整树解析一致:
// messages 不是非空数组 / 首元素不是对象 / role 缺失或不是字符串 → ok=false。
func FirstMessageRole(body []byte) (string, bool) {
	i := skipSpace(body, 0)
	if i >= len(body) || body[i] != '{' {
		return "", false
	}
	i++
	for {
		i = skipSpace(body, i)
		if i >= len(body) || body[i] == '}' {
			return "", false
		}
		key, next, ok := readKey(body, i)
		if !ok {
			return "", false
		}
		i = skipSpace(body, next)
		if i >= len(body) || body[i] != ':' {
			return "", false
		}
		i = skipSpace(body, i+1)
		if string(key) == "messages" {
			i = skipSpace(body, i)
			if i >= len(body) || body[i] != '[' {
				return "", false
			}
			i = skipSpace(body, i+1)
			if i < len(body) && body[i] == ']' {
				return "", false
			}
			first := collect(body, i, []string{"role"})
			role, ok := first["role"]
			return role, ok
		}
		j, ok := skipValue(body, i)
		if !ok {
			return "", false
		}
		i = skipSpace(body, j)
		if i >= len(body) {
			return "", false
		}
		switch body[i] {
		case ',':
			i++
		case '}':
			return "", false
		default:
			return "", false
		}
	}
}

// IsObject 报告扫描器能否完整走完这个 body 的顶层对象。
//
// 用途:调用方用它决定「扫描结果可信」还是「回落整树解析」。走不通说明 body
// 不是合法对象或形态超出本包假设——此时不要相信「没找到键」的结论。
func IsObject(body []byte) bool {
	i := skipSpace(body, 0)
	if i >= len(body) || body[i] != '{' {
		return false
	}
	i++
	for {
		i = skipSpace(body, i)
		if i >= len(body) {
			return false
		}
		if body[i] == '}' {
			return true
		}
		_, next, ok := readKey(body, i)
		if !ok {
			return false
		}
		i = skipSpace(body, next)
		if i >= len(body) || body[i] != ':' {
			return false
		}
		j, ok := skipValue(body, i+1)
		if !ok {
			return false
		}
		i = skipSpace(body, j)
		if i >= len(body) {
			return false
		}
		switch body[i] {
		case ',':
			i++
		case '}':
			return true
		default:
			return false
		}
	}
}

// matchAny 报告 key 是否在 want 里。
func matchAny(key []byte, want []string) bool {
	for _, w := range want {
		if string(key) == w {
			return true
		}
	}
	return false
}

// skipSpace 跳过 JSON 空白。
func skipSpace(b []byte, i int) int {
	for i < len(b) {
		switch b[i] {
		case ' ', '\t', '\n', '\r':
			i++
		default:
			return i
		}
	}
	return i
}

// readKey 读一个对象键(b[i] 必须是 '"'),返回**未解转义**的原始字节与结束偏移。
// 键几乎总是纯 ASCII,原始字节可直接与候选键比较;含转义的键由调用方按原文比较
// (对候选键无转义这一前提成立)。这里不做解码,避免为每个键付一次 Unmarshal。
func readKey(b []byte, i int) ([]byte, int, bool) {
	if i >= len(b) || b[i] != '"' {
		return nil, i, false
	}
	j := i + 1
	for {
		n := bytes.IndexByte(b[j:], '"')
		if n < 0 {
			return nil, i, false
		}
		j += n
		if !escaped(b, i, j) {
			return b[i+1 : j], j + 1, true
		}
		j++
	}
}

// escaped 报告 b[pos] 处的引号是否被反斜杠转义(数前面连续反斜杠的奇偶)。
func escaped(b []byte, start, pos int) bool {
	bs := 0
	for k := pos - 1; k > start && b[k] == '\\'; k-- {
		bs++
	}
	return bs%2 == 1
}

// readStrValue 读一个字符串值并解转义。b[i] 必须是 '"'。
func readStrValue(b []byte, i int) (string, int, bool) {
	raw, end, ok := readKey(b, i)
	if !ok {
		return "", i, false
	}
	// 快路径只处理「无转义 + 合法 UTF-8」的字符串(绝大多数情况)。
	// 其余一律交给 encoding/json:它会把非法 UTF-8 字节替换成 U+FFFD、把 \uXXXX
	// 解成对应字符——直接 string(raw) 会漏掉前者(fuzz 抓到的真实差异)。
	if bytes.IndexByte(raw, '\\') < 0 && utf8.Valid(raw) {
		return string(raw), end, true
	}
	var s string
	if err := json.Unmarshal(b[i:end], &s); err != nil {
		return "", i, false
	}
	return s, end, true
}

// skipString 跳过一个字符串(不解转义、不分配),返回结束偏移。
func skipString(b []byte, i int) (int, bool) {
	if i >= len(b) || b[i] != '"' {
		return i, false
	}
	j := i + 1
	for {
		n := bytes.IndexByte(b[j:], '"')
		if n < 0 {
			return i, false
		}
		j += n
		if !escaped(b, i, j) {
			return j + 1, true
		}
		j++
	}
}

// skipValue 从 b[i] 起跳过一个完整 JSON 值,返回其后的偏移。零分配、不解转义。
func skipValue(b []byte, i int) (int, bool) {
	i = skipSpace(b, i)
	if i >= len(b) {
		return i, false
	}
	switch b[i] {
	case '"':
		return skipString(b, i)
	case '{', '[':
		depth := 0
		for i < len(b) {
			switch b[i] {
			case '"':
				next, ok := skipString(b, i)
				if !ok {
					return i, false
				}
				i = next
				continue
			case '{', '[':
				depth++
			case '}', ']':
				depth--
				if depth == 0 {
					return i + 1, true
				}
			}
			i++
		}
		return i, false
	default:
		// 数字 / true / false / null:扫到分隔符为止。
		start := i
		for i < len(b) {
			switch b[i] {
			case ',', '}', ']', ' ', '\t', '\n', '\r':
				if i == start {
					return i, false
				}
				return i, true
			}
			i++
		}
		return i, i > start
	}
}

// Validate 只在测试里用:确认扫描器与整树解析对同一 body 的判定一致。
func Validate(body []byte) error {
	var obj map[string]any
	if err := json.Unmarshal(body, &obj); err != nil {
		return nil // 坏 body 不是本函数的关注点
	}
	keys := []string{"model", "conversation_id", "conversationId", "user_id", "prompt_cache_key"}
	res := Lookup(body, Query{Top: keys})
	if !res.Ok {
		return fmt.Errorf("scanner could not walk object: %s", body)
	}
	for _, k := range keys {
		want, _ := obj[k].(string)
		if want != res.Top[k] {
			return fmt.Errorf("key %q: got %q want %q", k, res.Top[k], want)
		}
	}
	return nil
}