hiperf_txt_parser 1.0.12 → 1.0.14

package/dist/index.d.ts

@@ -2,6 +2,6 @@ export { parsePerfData, filterByTgid } from "./parser.js";
 export { formatPerfDataToText, formatPerfDataToJson } from "./serializer.js";
 export { toBackTraceStack, toBackTraceStacks } from "./backtrace.js";
 export { parseTraceFormat, parseCommonFieldsFromRaw, parseAllFieldsFromRaw, rawHexLinesToBuffer, bufferToRawHexLines, buildTraceParserRegistry, decodeRawByRegistry, decodePerfRawData, } from "./traceFormat.js";
-export type { ParsedTraceFormat, TraceFormatField, TraceParserRegistry, DecodedRawSample, DecodePerfRawDataOptions, Endian, } from "./traceFormat.js";
+export type { ParsedTraceFormat, TraceFormatField, TraceParserRegistry, DecodedRawSample, DecodePerfRawDataOptions, DecodeRawByRegistryOptions, TracePrintMode, Endian, } from "./traceFormat.js";
 export type { PerfData, RecordSample } from "./types.js";
 export type { RecordSampleJsonExportItem } from "./serializer.js";

package/dist/serializer.d.ts

@@ -3,13 +3,15 @@ import type { PerfData } from "./types.js";
  * 将 PerfData 导出为与 sample/perf_data.txt 相同格式的文本（含缩进与每行前缀）
  */
 export declare function formatPerfDataToText(data: PerfData): string;
-/** 导出用 JSON 的单项：issuce 固定为 "unknow"，call_chain 为 frames 逐行拼接 */
-export interface RecordSampleJsonExportItem {
+/**
+ * 导出用 JSON 单项：固定含 `issuce`、`call_chain`；若存在 `traceFieldDict`，其键值对与二者**同级**平铺。
+ */
+export type RecordSampleJsonExportItem = {
     issuce: "unknow";
     call_chain: string;
-}
+} & Record<string, string>;
 /**
- * 将 PerfData 转为导出用 JSON 结构：顶层为数组，每项为 { issuce: "unknow", call_chain: "" }，
- * call_chain 由对应 record sample 的 callchainFrames.frames 逐行拼接得到，无则为空字符串。
+ * 将 PerfData 转为导出用 JSON 结构：顶层为数组。
+ * call_chain 由 callchainFrames.frames 拼接；有 traceFieldDict 时各字段平铺在对象顶层（与 call_chain 同级）。
  */
 export declare function formatPerfDataToJson(data: PerfData): RecordSampleJsonExportItem[];

package/dist/serializer.js

@@ -19,7 +19,18 @@ function serializeOneSample(sample) {
             lines.push(`    ${addr}`);
         }
     }
-    if (sample.raw) {
+    if (sample.traceFieldDict && Object.keys(sample.traceFieldDict).length > 0 && sample.raw) {
+        lines.push(`  raw size=${sample.raw.size}`);
+        for (const [k, v] of Object.entries(sample.traceFieldDict)) {
+            lines.push(`    ${k}: ${v}`);
+        }
+        const n = Object.keys(sample.traceFieldDict).length;
+        for (let i = n; i < sample.raw.lines.length; i++) {
+            const { hex, short } = sample.raw.lines[i];
+            lines.push(short ? `    ${hex} (${short})` : `    ${hex}`);
+        }
+    }
+    else if (sample.raw) {
         lines.push(`  raw size=${sample.raw.size}`);
         for (const { hex, short } of sample.raw.lines) {
             lines.push(short ? `    ${hex} (${short})` : `    ${hex}`);
@@ -47,12 +58,20 @@ export function formatPerfDataToText(data) {
     return data.recordSamples.map(serializeOneSample).join("\n\n");
 }
 /**
- * 将 PerfData 转为导出用 JSON 结构：顶层为数组，每项为 { issuce: "unknow", call_chain: "" }，
- * call_chain 由对应 record sample 的 callchainFrames.frames 逐行拼接得到，无则为空字符串。
+ * 将 PerfData 转为导出用 JSON 结构：顶层为数组。
+ * call_chain 由 callchainFrames.frames 拼接；有 traceFieldDict 时各字段平铺在对象顶层（与 call_chain 同级）。
  */
 export function formatPerfDataToJson(data) {
-    return data.recordSamples.map((s) => ({
-        issuce: "unknow",
-        call_chain: s.callchainFrames ? s.callchainFrames.frames.join("\n") : "",
-    }));
+    return data.recordSamples.map((s) => {
+        const item = {
+            issuce: "unknow",
+            call_chain: s.callchainFrames ? s.callchainFrames.frames.join("\n") : "",
+        };
+        if (s.traceFieldDict) {
+            for (const [k, v] of Object.entries(s.traceFieldDict)) {
+                item[k] = v;
+            }
+        }
+        return item;
+    });
 }

package/dist/traceFormat.d.ts

@@ -28,11 +28,19 @@ export interface DecodedRawSample {
     commonFields: Record<string, number | bigint>;
     eventName?: string;
     renderedText?: string;
+    /** 当 tracePrintMode 为 fieldDict 时：各 print 参数按对应格式符格式化后的键值对 */
+    renderedFieldDict?: Record<string, string>;
     skipped: boolean;
 }
+/** printf：整条 print fmt 渲染为一句；fieldDict：按格式符逐项生成字段名 → 格式化字符串 */
+export type TracePrintMode = "printf" | "fieldDict";
+export interface DecodeRawByRegistryOptions {
+    tracePrintMode?: TracePrintMode;
+}
 export interface DecodePerfRawDataOptions {
     /** 是否在替换后的 raw 内容中保留 common_* 信息 */
     keepCommonFields?: boolean;
+    tracePrintMode?: TracePrintMode;
 }
 export type Endian = "le" | "be";
 /**
@@ -71,7 +79,7 @@ export declare function buildTraceParserRegistry(formatTexts: string[]): TracePa
  * 对一条 raw 数据先解 common_*，再按 common_type 选择解析器，最后按 print fmt 渲染。
  * 找不到解析器时返回 skipped=true，并打印 common_type。
  */
-export declare function decodeRawByRegistry(raw: Uint8Array, registry: TraceParserRegistry): Omit<DecodedRawSample, "sampleIndex">;
+export declare function decodeRawByRegistry(raw: Uint8Array, registry: TraceParserRegistry, options?: DecodeRawByRegistryOptions): Omit<DecodedRawSample, "sampleIndex">;
 /**
  * 批量处理 perfData 的 raw 数据。仅处理有 raw 的 sample。
  */
@@ -80,6 +88,7 @@ export declare function decodeRawByRegistry(raw: Uint8Array, registry: TracePars
  *
  * 规则：
  * - 若找到 common_type 对应解析器：将 print fmt 渲染结果写入 `sample.raw.lines`（一行）。
+ * - fieldDict：写入 `traceFieldDict`，`raw.lines` 为每行一条 `key: value`；`raw.size` 为行数（含可选 common 行）。
  * - 若找不到解析器：放弃解析，并将 `common_type` 写入 `sample.raw.lines`（一行）。
  */
 export declare function decodePerfRawData(perfData: PerfData, registry: TraceParserRegistry, options?: DecodePerfRawDataOptions): PerfData;

package/dist/traceFormat.js

@@ -274,6 +274,7 @@ export function buildTraceParserRegistry(formatTexts) {
     }
     return { byEventId, commonFormat };
 }
+const PRINT_FMT_SPEC_RE = /%[0-9]*[lh]*([duxXsS])/g;
 function formatArgBySpecifier(value, spec) {
     if (spec.toLowerCase() === "s") {
         return typeof value === "string" ? value : String(value);
@@ -290,79 +291,107 @@ function formatArgBySpecifier(value, spec) {
     }
     return isBig ? value.toString(10) : Math.trunc(value).toString(10);
 }
-function renderPrintFmt(printFmt, printArgs, fieldMap) {
-    const values = [];
-    function normalizeExpr(exprRaw) {
-        let expr = exprRaw.trim();
-        // 去掉外层括号（可能不止一层，也可能只有一侧被 match 捕获到）
-        while (expr.startsWith("("))
-            expr = expr.slice(1).trim();
-        while (expr.endsWith(")"))
-            expr = expr.slice(0, -1).trim();
-        expr = expr.replace(/\s+/g, "");
-        return expr;
+function normalizePrintExpr(exprRaw) {
+    let expr = exprRaw.trim();
+    while (expr.startsWith("("))
+        expr = expr.slice(1).trim();
+    while (expr.endsWith(")"))
+        expr = expr.slice(0, -1).trim();
+    expr = expr.replace(/\s+/g, "");
+    return expr;
+}
+function evalPrintArgExpr(exprRaw, fieldMap) {
+    const expr = normalizePrintExpr(exprRaw);
+    let m = expr.match(/^REC->(\w+)&0xffff$/);
+    if (m) {
+        const v = fieldMap[m[1]];
+        const n = typeof v === "number" ? v : 0;
+        return n & 0xffff;
     }
-    function evalExpr(exprRaw) {
-        // 允许表达式带括号与空格
-        const expr = normalizeExpr(exprRaw);
-        // (REC->__data_loc_reason&0xffff) / (REC->__data_loc_reason>>16)
-        let m = expr.match(/^REC->(\w+)&0xffff$/);
-        if (m) {
-            const v = fieldMap[m[1]];
-            const n = typeof v === "number" ? v : 0;
-            return n & 0xffff;
+    m = expr.match(/^REC->(\w+)>>16$/);
+    if (m) {
+        const v = fieldMap[m[1]];
+        const n = typeof v === "number" ? v : 0;
+        return (n >>> 16) & 0xffff;
+    }
+    m = expr.match(/^REC->(\w+)(?:\[(\d+)])?$/);
+    if (!m)
+        return 0;
+    const name = m[1];
+    const idxRaw = m[2];
+    const v = fieldMap[name];
+    if (idxRaw !== undefined) {
+        const idx = parseInt(idxRaw, 10);
+        if (Array.isArray(v) && idx >= 0 && idx < v.length) {
+            return v[idx];
         }
-        m = expr.match(/^REC->(\w+)>>16$/);
+        return 0;
+    }
+    if (Array.isArray(v))
+        return v[0] ?? 0;
+    return v ?? 0;
+}
+function buildPrintArgValues(printArgs, fieldMap) {
+    const normalizedArgs = (printArgs ?? []).map(normalizePrintExpr);
+    const values = (printArgs ?? []).map((e) => evalPrintArgExpr(e, fieldMap));
+    return { normalizedArgs, values };
+}
+/** 与 renderPrintFmt 中 replace 顺序一致：依次取出每个格式符的类型字母 */
+function extractPrintfSpecChars(printFmt) {
+    const specs = [];
+    printFmt.replace(PRINT_FMT_SPEC_RE, (_all, spec) => {
+        specs.push(spec);
+        return _all;
+    });
+    return specs;
+}
+function formatOnePrintArg(idx, spec, fieldMap, normalizedArgs, values) {
+    const v = values[idx] ?? 0;
+    const argExpr = normalizedArgs[idx] ?? "";
+    if (spec.toLowerCase() === "s") {
+        const m = argExpr.match(/^REC->__data_loc_(\w+)(?:&0xffff)?(?:>>16)?$/);
         if (m) {
-            const v = fieldMap[m[1]];
-            const n = typeof v === "number" ? v : 0;
-            return (n >>> 16) & 0xffff;
-        }
-        // REC->field 或 REC->field[idx]
-        m = expr.match(/^REC->(\w+)(?:\[(\d+)])?$/);
-        if (!m)
-            return 0;
-        const name = m[1];
-        const idxRaw = m[2];
-        const v = fieldMap[name];
-        if (idxRaw !== undefined) {
-            const idx = parseInt(idxRaw, 10);
-            if (Array.isArray(v) && idx >= 0 && idx < v.length) {
-                return v[idx];
+            const s = fieldMap[m[1]];
+            if (typeof s === "string") {
+                return s;
             }
-            return 0;
         }
-        if (Array.isArray(v))
-            return v[0] ?? 0;
-        return v ?? 0;
     }
-    const normalizedArgs = (printArgs ?? []).map(normalizeExpr);
-    for (const expr of printArgs ?? []) {
-        values.push(evalExpr(expr));
+    return formatArgBySpecifier(v, spec);
+}
+function fieldKeyFromNormalizedArg(normalizedArg, index) {
+    let k = normalizedArg;
+    if (k.startsWith("REC->"))
+        k = k.slice(5);
+    return k.length > 0 ? k : `arg${index}`;
+}
+function renderPrintFmtAsFieldDict(printFmt, printArgs, fieldMap) {
+    const { normalizedArgs, values } = buildPrintArgValues(printArgs, fieldMap);
+    const specs = extractPrintfSpecChars(printFmt);
+    const out = {};
+    const seen = new Map();
+    for (let i = 0; i < specs.length; i++) {
+        const base = fieldKeyFromNormalizedArg(normalizedArgs[i] ?? "", i);
+        const n = (seen.get(base) ?? 0) + 1;
+        seen.set(base, n);
+        const key = n === 1 ? base : `${base}__${n}`;
+        out[key] = formatOnePrintArg(i, specs[i], fieldMap, normalizedArgs, values);
     }
+    return out;
+}
+function renderPrintFmt(printFmt, printArgs, fieldMap) {
+    const { normalizedArgs, values } = buildPrintArgValues(printArgs, fieldMap);
     let valueIdx = 0;
-    return printFmt.replace(/%[0-9]*[lh]*([duxXsS])/g, (_all, spec) => {
+    return printFmt.replace(PRINT_FMT_SPEC_RE, (_all, spec) => {
         const idx = valueIdx++;
-        const v = values[idx] ?? 0;
-        const argExpr = normalizedArgs[idx] ?? "";
-        // %s + REC->__data_loc_xxx 时，优先打印已解析出来的 xxx 字符串
-        if (spec.toLowerCase() === "s") {
-            const m = argExpr.match(/^REC->__data_loc_(\w+)(?:&0xffff)?(?:>>16)?$/);
-            if (m) {
-                const s = fieldMap[m[1]];
-                if (typeof s === "string") {
-                    return s;
-                }
-            }
-        }
-        return formatArgBySpecifier(v, spec);
+        return formatOnePrintArg(idx, spec, fieldMap, normalizedArgs, values);
     });
 }
 /**
  * 对一条 raw 数据先解 common_*，再按 common_type 选择解析器，最后按 print fmt 渲染。
  * 找不到解析器时返回 skipped=true，并打印 common_type。
  */
-export function decodeRawByRegistry(raw, registry) {
+export function decodeRawByRegistry(raw, registry, options = {}) {
     const commonType = raw.length >= 2 ? Number(new DataView(raw.buffer, raw.byteOffset, raw.byteLength).getUint16(0, true)) : undefined;
     const commonFields = registry.commonFormat !== undefined
         ? parseCommonFieldsFromRaw(raw, registry.commonFormat)
@@ -383,9 +412,19 @@ export function decodeRawByRegistry(raw, registry) {
     }
     const fmt = registry.byEventId.get(eventId);
     const allFields = parseAllFieldsFromRaw(raw, fmt);
-    const renderedText = fmt.printFmt
-        ? renderPrintFmt(fmt.printFmt, fmt.printArgs, allFields)
-        : undefined;
+    const mode = options.tracePrintMode ?? "printf";
+    if (fmt.printFmt && mode === "fieldDict") {
+        const renderedFieldDict = renderPrintFmtAsFieldDict(fmt.printFmt, fmt.printArgs, allFields);
+        return {
+            commonType: eventId,
+            commonFields,
+            eventName: fmt.eventName,
+            renderedFieldDict,
+            renderedText: JSON.stringify(renderedFieldDict),
+            skipped: false,
+        };
+    }
+    const renderedText = fmt.printFmt ? renderPrintFmt(fmt.printFmt, fmt.printArgs, allFields) : undefined;
     return {
         commonType: eventId,
         commonFields,
@@ -402,6 +441,7 @@ export function decodeRawByRegistry(raw, registry) {
  *
  * 规则：
  * - 若找到 common_type 对应解析器：将 print fmt 渲染结果写入 `sample.raw.lines`（一行）。
+ * - fieldDict：写入 `traceFieldDict`，`raw.lines` 为每行一条 `key: value`；`raw.size` 为行数（含可选 common 行）。
  * - 若找不到解析器：放弃解析，并将 `common_type` 写入 `sample.raw.lines`（一行）。
  */
 export function decodePerfRawData(perfData, registry, options = {}) {
@@ -410,7 +450,9 @@ export function decodePerfRawData(perfData, registry, options = {}) {
             if (!sample.raw || sample.raw.lines.length === 0)
                 return sample;
             const raw = rawHexLinesToBuffer(sample.raw.lines);
-            const decoded = decodeRawByRegistry(raw, registry);
+            const decoded = decodeRawByRegistry(raw, registry, {
+                tracePrintMode: options.tracePrintMode,
+            });
             const base = decoded.renderedText ??
                 (decoded.commonType !== undefined ? String(decoded.commonType) : "");
             if (!base)
@@ -420,8 +462,30 @@ export function decodePerfRawData(perfData, registry, options = {}) {
                     .map(([k, v]) => `${k}:${typeof v === "bigint" ? v.toString(10) : v}`)
                     .join(" ")
                 : "";
+            const dict = decoded.renderedFieldDict;
+            const useFieldDict = options.tracePrintMode === "fieldDict" &&
+                dict !== undefined &&
+                Object.keys(dict).length > 0;
+            if (useFieldDict) {
+                const kvLines = Object.entries(dict).map(([k, v]) => ({
+                    hex: `${k}: ${v}`,
+                }));
+                const lines = options.keepCommonFields && commonLine.length > 0
+                    ? [...kvLines, { hex: commonLine }]
+                    : kvLines;
+                return {
+                    ...sample,
+                    traceFieldDict: dict,
+                    raw: {
+                        ...sample.raw,
+                        size: lines.length,
+                        lines,
+                    },
+                };
+            }
             return {
                 ...sample,
+                traceFieldDict: undefined,
                 raw: {
                     ...sample.raw,
                     lines: options.keepCommonFields && commonLine.length > 0

package/dist/types.d.ts

@@ -39,6 +39,8 @@ export interface RecordSample {
     period: number;
     callchain?: CallchainEntry;
     raw?: RawEntry;
+    /** tracePrintMode 为 fieldDict 且解码成功时：print 各参数键值（用于导出 txt/json） */
+    traceFieldDict?: Record<string, string>;
     server?: ServerEntry;
     callchainFrames?: CallchainFramesEntry;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hiperf_txt_parser",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "Parse perf data.txt and output structured TypeScript data",
   "type": "module",
   "main": "dist/index.js",