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
}
|