querysub 0.394.0 → 0.396.0

package/src/diagnostics/logs/lifeCycleAnalysis/NestedLifeCycleInfo.tsx

@@ -0,0 +1,151 @@
+import { SocketFunction } from "socket-function/SocketFunction";
+import { css } from "typesafecss";
+import { t } from "../../../2-proxy/schema2";
+import { qreact } from "../../../4-dom/qreact";
+import { formatValue } from "../../../5-diagnostics/GenericFormat";
+import { Button } from "../../../library-components/Button";
+import { niceStringify } from "../../../niceStringify";
+import { LogDatum } from "../diskLogger";
+import { LifeCycle, LifeCyclesController, getVariables } from "./lifeCycles";
+import { createLifeCycleSearch, LifecycleInstance } from "./lifeCycleSearch";
+import { IndexedLogResults } from "../IndexedLogs/BufferIndexHelpers";
+import { formatSearchString } from "../IndexedLogs/LogViewerParams";
+import { getPathStr, getPathStr2 } from "../../../path";
+
+export class NestedLifeCycleInfo extends qreact.Component<{
+    keyName: string;
+    value: unknown;
+    aliases: string[];
+    currentLifeCycleId: string;
+}> {
+    state = t.state({
+        searchingLifeCycleId: t.atomic<string | undefined>(undefined),
+        phase1Results: t.atomic<LogDatum[]>([]),
+        phase1InvalidResults: t.atomic<Array<{ datum: LogDatum; missingKeys: string[] }>>([]),
+        phase1Stats: t.atomic<IndexedLogResults | undefined>(undefined),
+        phase1Searching: t.boolean(false),
+        phase2Results: t.atomic<LogDatum[]>([]),
+        phase2Stats: t.atomic<IndexedLogResults | undefined>(undefined),
+        phase2Searching: t.boolean(false),
+        phase2HitLimit: t.boolean(false),
+        lifecycleInstances: t.atomic<LifecycleInstance[]>([]),
+    });
+
+    controller = LifeCyclesController(SocketFunction.browserNodeId());
+    search = createLifeCycleSearch(this);
+
+    render() {
+        let lifeCycles = this.controller.getLifeCycles();
+        if (!lifeCycles) return null;
+
+        let { keyName, value, aliases, currentLifeCycleId } = this.props;
+
+        let allKeysToMatch = [keyName, ...aliases].filter(x => !["__threadId", "__machineId"].includes(x));
+        let matchingLifeCycles: Array<{ lifecycle: LifeCycle; matchedKey: string }> = [];
+
+        for (let lifecycle of lifeCycles) {
+            if (lifecycle.id === currentLifeCycleId) continue;
+
+            let matchedKey: string | undefined = undefined;
+            for (let entry of lifecycle.entries) {
+                for (let groupByKey of entry.groupByKeys) {
+                    if (allKeysToMatch.includes(groupByKey.ourKey)) {
+                        matchedKey = groupByKey.ourKey;
+                        break;
+                    }
+                }
+                if (matchedKey !== undefined) break;
+            }
+
+            if (matchedKey !== undefined) {
+                matchingLifeCycles.push({ lifecycle, matchedKey });
+            }
+        }
+
+        if (matchingLifeCycles.length === 0) return null;
+
+        return <>
+            {matchingLifeCycles.map(({ lifecycle, matchedKey }) => {
+                let isSearchingThis = this.state.searchingLifeCycleId === lifecycle.id;
+                let isSearching = isSearchingThis && (this.state.phase1Searching || this.state.phase2Searching);
+                let hasSearched = isSearchingThis && !isSearching;
+
+                let instances = hasSearched && this.state.lifecycleInstances.filter(inst =>
+                    inst.keys.some(k => k.key === matchedKey && k.value === value)
+                ) || [];
+                let hasResults = instances.length > 0;
+
+                let progressText = "";
+                if (isSearching && isSearchingThis) {
+                    let parts: string[] = [];
+
+                    if (this.state.phase1Searching || this.state.phase1Stats) {
+                        let stats = this.state.phase1Stats;
+                        let blocksScanned = stats && (stats.localFilesSearched + stats.backblazeFilesSearched) || 0;
+                        let resultsCount = this.state.phase1Results.length;
+                        parts.push(`${blocksScanned} > ${resultsCount}`);
+                    }
+
+                    if (this.state.phase2Searching) {
+                        let stats = this.state.phase2Stats;
+                        let blocksScanned = stats && (stats.localFilesSearched + stats.backblazeFilesSearched) || 0;
+                        let resultsCount = this.state.phase2Results.length;
+                        parts.push(`${blocksScanned} > ${resultsCount}`);
+                    }
+
+                    progressText = parts.length > 0 && `(${parts.join(" | ")})` || "(...)";
+                }
+
+                return <>
+                    <Button
+                        hue={180}
+                        onClick={() => {
+                            void this.search.searchLifeCycle({
+                                lifeCycleId: lifecycle.id,
+                                limit: 10,
+                                additionalSearch: formatSearchString({ [matchedKey]: value })
+                            });
+                        }}
+                    >
+                        {lifecycle.title} {isSearching && "⏳" || ""} {progressText} {hasSearched && `(${instances.length})` || ""}
+                    </Button>
+                    {hasSearched && !hasResults && (
+                        <div className={css.pad2(4).colorhsl(0, 0, 50)}>No results found</div>
+                    )}
+                    {hasResults && (() => {
+                        let firstInstance = instances[0];
+                        let totalCount = instances.length;
+                        let hitLimit = totalCount >= 10;
+
+                        let keys = lifecycle.entries.map(x => x.groupByKeys.map(y => y.ourKey).concat(Object.keys(x.variables))).flat();
+
+                        function valueHash(key: string, value: unknown) {
+                            return getPathStr2(key, String(value));
+                        }
+                        let values = new Map<string, { key: string; value: unknown }>();
+                        for (let entry of firstInstance.entries) {
+                            for (let [key, value] of Object.entries(entry.datum)) {
+                                if (!keys.includes(key)) continue;
+                                if (key === matchedKey) continue;
+                                if (["__threadId", "__machineId"].includes(key)) continue;
+                                values.set(valueHash(key, value), { key, value });
+                            }
+                        }
+
+                        return <>
+                            <div className={css.hbox(4)}>
+                                {hitLimit && <span className={css.colorhsl(30, 80, 40).boldStyle}>(hit limit!)</span>}
+                            </div>
+                            {Array.from(values.values()).map(({ key, value }, idx) => (
+                                <div key={idx} className={css.hbox(4)}>
+                                    <span className={css.colorhsl(200, 50, 60).boldStyle}>{key}:</span>
+                                    <span className={css.colorhsl(0, 0, 50)}>{niceStringify(value)}</span>
+                                </div>
+                            ))}
+                        </>;
+                    })()}
+                </>;
+            })}
+        </>;
+    }
+}

package/src/diagnostics/logs/lifeCycleAnalysis/lifeCycleMatching.ts

@@ -0,0 +1,49 @@
+import { LifeCycle, LifeCycleEntry } from "./lifeCycles";
+import { LogDatum } from "../diskLogger";
+import { createMatchesPatternCached } from "../IndexedLogs/bufferSearchFindMatcher";
+
+export type LifecycleMatch = {
+    lifecycle: LifeCycle;
+    entry: LifeCycleEntry;
+    datum: Record<string, unknown>;
+};
+
+export function getLifecycleMatchesForDatum(
+    lifecycles: LifeCycle[],
+    datum: LogDatum
+): LifecycleMatch[] {
+    let matches: LifecycleMatch[] = [];
+
+    let matchStr = String(datum.param0);
+    let matchBuffer = Buffer.from(matchStr, "utf8");
+
+    for (let lifecycle of lifecycles) {
+        for (let entry of lifecycle.entries) {
+            let matcher = createMatchesPatternCached(entry.matchPattern);
+            if (!matcher(matchBuffer)) continue;
+
+            let extractedDatum: Record<string, unknown> = {};
+            let hasAllKeys = true;
+
+            for (let keyConfig of entry.groupByKeys) {
+                let keyToLookup = keyConfig.startKey || keyConfig.ourKey;
+                let value = datum[keyToLookup];
+                if (value === undefined) {
+                    hasAllKeys = false;
+                    break;
+                }
+                extractedDatum[keyConfig.ourKey] = value;
+            }
+
+            if (!hasAllKeys || entry.groupByKeys.length === 0) continue;
+
+            matches.push({
+                lifecycle,
+                entry,
+                datum: extractedDatum,
+            });
+        }
+    }
+
+    return matches;
+}