Files
gods-eye-view/src/voice/realtimeDiagnostics.js
T
Sameh Khamis 73e789489b chore: drop exports nothing imports
Knip, configured with the application, package exports, scripts, QA
harnesses, workers, tools and tests as entry points, reports exports
that no module imports. Each was checked by hand against string-based
and namespace imports.

- Symbols that are still used inside their own module lose only the
  `export` keyword (176 constants and helpers).
- Unused re-exports are removed from barrel modules (flight, military,
  vessel, CCTV, directions, transit history, local ADS-B and street-level
  policy modules).
- Declarations that nothing uses at all are deleted, among them
  AIS_WATCHDOG_STATUSES, applyFilter, isRadioCountryCode, compactText,
  DENSITY_STOPS, the unused CCTV endpoint constants, and the SDR band
  constants.
- Default exports that nothing imports are removed. The ones in
  src/data/earthquakes.js, src/data/telegeographySubmarineCables.js,
  src/data/wind.js and src/data/bhoteKoshiLocator.js each constructed a
  layer instance at import time that nothing used; those instances are
  no longer created.

Every export of a package.json entry stays, as does TOMTOM_CREDIT,
which the traffic layer reads from the credits namespace it is given.
2026-10-22 19:00:40 -07:00

220 lines
6.2 KiB
JavaScript

const ERROR_LOG_LIMIT = 30;
const ERROR_STORAGE_KEY = 'gev-realtime-errors';
const DEBUG_LOG_URL = '/api/realtime/debug-log';
function createDebugSessionId() {
const randomPart = Math.random().toString(36).slice(2, 10);
return `gev-${Date.now().toString(36)}-${randomPart}`;
}
export function postDebugLog(record) {
try {
const body = JSON.stringify(record);
if (navigator.sendBeacon) {
const blob = new Blob([body], { type: 'application/json' });
if (navigator.sendBeacon(DEBUG_LOG_URL, blob)) return;
}
fetch(DEBUG_LOG_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body,
keepalive: body.length < 60000,
}).catch(() => {});
} catch {
// Debug logging must never affect voice control.
}
}
export function sanitizeDebugValue(value, depth = 0) {
if (depth > 10) return '[MaxDepth]';
if (value == null || typeof value === 'number' || typeof value === 'boolean')
return value;
if (typeof value === 'string') return sanitizeDebugString(value);
if (Array.isArray(value))
return value.map((item) => sanitizeDebugValue(item, depth + 1));
if (typeof value !== 'object') return String(value);
const output = {};
for (const [key, item] of Object.entries(value)) {
if (isSecretLikeKey(key)) {
output[key] = '[Redacted]';
continue;
}
output[key] = sanitizeDebugValue(item, depth + 1);
}
return output;
}
function sanitizeDebugString(value) {
if (value.startsWith('data:image/')) {
return `[Redacted image data URL, ${value.length} chars]`;
}
const redacted = value
.replace(/sk-(?:proj-)?[A-Za-z0-9_-]{20,}/g, '[Redacted OpenAI API key]')
.replace(/Bearer\s+[A-Za-z0-9._~+/-]+=*/gi, 'Bearer [Redacted]')
.replace(/"client_secret"\s*:\s*"[^"]+"/gi, '"client_secret":"[Redacted]"')
.replace(
/"value"\s*:\s*"ek_[^"]+"/gi,
'"value":"[Redacted ephemeral key]"',
);
const maxLength = 50000;
return redacted.length > maxLength
? `${redacted.slice(0, maxLength)}...[Truncated ${redacted.length - maxLength} chars]`
: redacted;
}
function isSecretLikeKey(key) {
return /(?:api[_-]?key|authorization|bearer|client[_-]?secret|token|secret|password)/i.test(
key,
);
}
function createErrorRecord(source, error, extra = {}) {
const rtcError = error?.error || error;
return {
timestamp: new Date().toISOString(),
source,
name: rtcError?.name || null,
message:
rtcError?.message ||
extra.errorText ||
String(error?.message || '').trim() ||
'No browser error message supplied',
errorDetail: rtcError?.errorDetail || null,
sctpCauseCode: rtcError?.sctpCauseCode ?? null,
receivedAlert: rtcError?.receivedAlert ?? null,
sentAlert: rtcError?.sentAlert ?? null,
...removeEmptyValues(extra),
};
}
function formatErrorForDisplay(record) {
const primary = [record.source, record.message].filter(Boolean).join(': ');
const state = [
record.errorDetail && `detail=${record.errorDetail}`,
record.code && `code=${record.code}`,
record.sctpCauseCode != null && `sctp=${record.sctpCauseCode}`,
record.connectionState && `pc=${record.connectionState}`,
record.iceConnectionState && `ice=${record.iceConnectionState}`,
record.dataChannelState && `dc=${record.dataChannelState}`,
]
.filter(Boolean)
.join(' | ');
return state ? `${primary}\n${state}` : primary;
}
function removeEmptyValues(value) {
return Object.fromEntries(
Object.entries(value || {}).filter(
([, item]) => item !== null && item !== undefined && item !== '',
),
);
}
function loadStoredErrors() {
try {
const value = JSON.parse(localStorage.getItem(ERROR_STORAGE_KEY) || '[]');
return Array.isArray(value) ? value.slice(0, ERROR_LOG_LIMIT) : [];
} catch {
return [];
}
}
function storeErrors(errors) {
try {
localStorage.setItem(
ERROR_STORAGE_KEY,
JSON.stringify(errors.slice(0, ERROR_LOG_LIMIT)),
);
} catch {
// Diagnostics still remain available in memory and the console.
}
}
/** Own bounded error history and sanitized optional diagnostics. */
export class RealtimeDiagnostics {
constructor({
readStatus,
readChannel,
readPeer,
readCostTracker,
debugSink,
operations,
}) {
Object.assign(
this,
{ readStatus, readChannel, readPeer, readCostTracker },
operations,
);
this.debugSink = debugSink;
this.errors = loadStoredErrors();
this.sessionId = createDebugSessionId();
}
get status() {
return this.readStatus();
}
get dc() {
return this.readChannel();
}
get pc() {
return this.readPeer();
}
get costTracker() {
return this.readCostTracker();
}
reportError(source, error = null, extra = {}) {
const record = createErrorRecord(source, error, extra);
this.errors.unshift(record);
this.errors.length = Math.min(this.errors.length, ERROR_LOG_LIMIT);
storeErrors(this.errors);
console.error('[GEV Realtime]', record);
this.debugLog('error', record);
this.setStatus('error', formatErrorForDisplay(record));
return record;
}
connectionDiagnostics(dataChannel = this.dc) {
return {
dataChannelState: dataChannel?.readyState || null,
connectionState: this.pc?.connectionState || null,
iceConnectionState: this.pc?.iceConnectionState || null,
iceGatheringState: this.pc?.iceGatheringState || null,
signalingState: this.pc?.signalingState || null,
sctpState: this.pc?.sctp?.transport?.state || null,
};
}
getDiagnostics() {
return {
status: this.status,
connection: this.connectionDiagnostics(),
recentErrors: this.errors.slice(),
debugLog: this.debugSink
? {
endpoint: DEBUG_LOG_URL,
file: '.gev-logs/realtime-conversations.jsonl',
sessionId: this.sessionId,
}
: null,
cost: this.costTracker.state(),
};
}
debugLog(event, payload = {}) {
try {
this.debugSink?.({
timestamp: new Date().toISOString(),
sessionId: this.sessionId,
event,
status: this.status,
payload: sanitizeDebugValue(payload),
});
} catch {
/* Diagnostics cannot interrupt voice. */
}
}
}