tango-app-api-trax 3.9.38 → 3.9.39

package/src/logging/activityLogFlusher.js

@@ -1,59 +0,0 @@
-import { insertOpenSearchData, logger } from 'tango-app-api-middleware';
-import { loggingConfig } from './config.js';
-import { compressBatches } from './compressBatches.js';
-
-export async function flushActivityLog( ctx, status ) {
-  if ( !loggingConfig.enabled ) return;
-  if ( !ctx ) return;
-
-  if ( ctx.steps.length === 0 && !ctx.error ) return;
-
-  const compressedSteps = safeCompress( ctx.steps );
-
-  const doc = {
-    version: loggingConfig.version,
-    requestId: ctx.requestId,
-    timestamp: new Date( ctx.startTime ).toISOString(),
-    duration: Date.now() - ctx.startTime,
-    user: ctx.user,
-    api: {
-      method: ctx.api.method,
-      path: ctx.api.path,
-      action: ctx.api.action,
-      body: stringifyBody( ctx.api.body ),
-    },
-    response: {
-      code: ctx.response?.code ?? null,
-      body: stringifyBody( ctx.response?.body ),
-    },
-    status,
-    steps: compressedSteps,
-    error: ctx.error,
-  };
-
-  try {
-    await insertOpenSearchData( loggingConfig.index, doc );
-  } catch ( e ) {
-    logger.error( { functionName: 'flushActivityLog', error: e } );
-  }
-}
-
-function safeCompress( steps ) {
-  try {
-    return compressBatches( steps );
-  } catch ( _e ) {
-    // Never let compression failure block log delivery — fall back to raw steps.
-    return steps;
-  }
-}
-
-function stringifyBody( body ) {
-  if ( body === null || body === undefined ) return null;
-  if ( typeof body === 'string' ) return body;
-  if ( body instanceof Error ) return body.message || String( body );
-  try {
-    return JSON.stringify( body );
-  } catch ( _e ) {
-    return '[unserializable]';
-  }
-}

package/src/logging/activityLogMiddleware.js

@@ -1,45 +0,0 @@
-import { activityLogStore, createLogContext } from './activityLogStore.js';
-import { flushActivityLog } from './activityLogFlusher.js';
-import { loggingConfig } from './config.js';
-
-function refreshUser( ctx, req ) {
-  if ( req?.user ) {
-    ctx.user = {
-      _id: req.user._id,
-      userName: req.user.userName,
-      email: req.user.email,
-    };
-  }
-}
-
-export default function traxActivityLogMiddleware( req, res, next ) {
-  if ( !loggingConfig.enabled ) return next();
-
-  const WRITE_METHODS = [ 'POST', 'PUT', 'PATCH', 'DELETE' ];
-  if ( !WRITE_METHODS.includes( req.method ) ) return next();
-
-  const ctx = createLogContext( req );
-
-  activityLogStore.run( ctx, () => {
-    const originalSendSuccess = res.sendSuccess;
-    const originalSendError = res.sendError;
-
-    res.sendSuccess = ( data ) => {
-      refreshUser( ctx, req );
-      ctx.response.code = 200;
-      ctx.response.body = data;
-      originalSendSuccess( data );
-      setImmediate( () => flushActivityLog( ctx, 'success' ).catch( () => {} ) );
-    };
-
-    res.sendError = ( message, code ) => {
-      refreshUser( ctx, req );
-      ctx.response.code = code ?? 500;
-      ctx.response.body = message;
-      originalSendError( message, code );
-      setImmediate( () => flushActivityLog( ctx, 'failed' ).catch( () => {} ) );
-    };
-
-    next();
-  } );
-}

package/src/logging/activityLogStore.js

@@ -1,91 +0,0 @@
-import { AsyncLocalStorage } from 'async_hooks';
-import { randomUUID } from 'crypto';
-
-export const activityLogStore = new AsyncLocalStorage();
-
-const SENSITIVE_KEYS = [ 'password', 'token', 'secret', 'authorization' ];
-
-export function createLogContext( req ) {
-  return {
-    requestId: randomUUID(),
-    startTime: Date.now(),
-    user: req.user ? {
-      _id: req.user._id,
-      userName: req.user.userName,
-      email: req.user.email,
-    } : null,
-    api: {
-      method: req.method,
-      path: req.path,
-      action: `${ req.method } ${ req.path }`,
-      body: sanitizeBody( req.body ),
-    },
-    response: {
-      code: null,
-      body: null,
-    },
-    steps: [],
-    stepCounter: 0,
-    error: null,
-  };
-}
-
-export function getLogContext() {
-  return activityLogStore.getStore();
-}
-
-export function pushStep( entry ) {
-  const ctx = getLogContext();
-  if ( !ctx ) return;
-
-  const last = ctx.steps[ctx.steps.length - 1];
-  if (
-    last &&
-    last.name === entry.name &&
-    last.type === entry.type &&
-    last.status === 'success' &&
-    entry.status === 'success'
-  ) {
-    last.count = ( last.count || 1 ) + 1;
-    last.ms += entry.ms;
-    return;
-  }
-
-  ctx.stepCounter++;
-  ctx.steps.push( {
-    stepIndex: ctx.stepCounter,
-    name: entry.name,
-    type: entry.type,
-    status: entry.status,
-    ms: entry.ms,
-  } );
-}
-
-export function pushStepFailure( entry, error ) {
-  const ctx = getLogContext();
-  if ( !ctx ) return;
-  ctx.stepCounter++;
-  const message = error?.message || String( error );
-  ctx.steps.push( {
-    stepIndex: ctx.stepCounter,
-    name: entry.name,
-    type: entry.type,
-    status: 'failed',
-    ms: entry.ms,
-    error: message,
-  } );
-  ctx.error = {
-    message,
-    failedAtStepIndex: ctx.stepCounter,
-    failedStepName: entry.name,
-  };
-}
-
-function sanitizeBody( body ) {
-  if ( !body || typeof body !== 'object' ) return body;
-  const cleaned = { ...body };
-  for ( const key of SENSITIVE_KEYS ) {
-    if ( cleaned[key] !== undefined ) cleaned[key] = '[REDACTED]';
-  }
-  return cleaned;
-}

package/src/logging/compressBatches.js

@@ -1,83 +0,0 @@
-/**
- * Post-process a steps array to compress repeated adjacent cycles into a single
- * "batch" entry. Complements the push-time collapse of identical adjacent
- * steps (which merges A,A,A into A×3) by merging repeated *sequences*
- * (A,B,C,A,B,C,A,B,C → batch[A→B→C]×3).
- *
- * Rules:
- * - A cycle is detected only if the same ordered sequence of step names/types
- *   appears ≥ 2 times back-to-back.
- * - Failed steps are never included in cycles — each failure stands alone so
- *   you can see exactly which iteration broke.
- * - Greedy: smallest cycle length (≥ 2) wins. This gives the most compact,
- *   most readable output.
- * - Cycle length is bounded to keep the O(n·k) scan cheap.
- */
-
-const MIN_CYCLE_LEN = 2;
-const MAX_CYCLE_LEN = 10;
-
-export function compressBatches( rawSteps ) {
-  if ( !Array.isArray( rawSteps ) || rawSteps.length < MIN_CYCLE_LEN * 2 ) return rawSteps;
-
-  const out = [];
-  let i = 0;
-  while ( i < rawSteps.length ) {
-    let absorbed = false;
-    const maxK = Math.min( MAX_CYCLE_LEN, Math.floor( ( rawSteps.length - i ) / 2 ) );
-
-    for ( let k = MIN_CYCLE_LEN; k <= maxK; k++ ) {
-      if ( !cycleEquals( rawSteps, i, k, i + k ) ) continue;
-
-      // At least 2 repeats confirmed. Count forward.
-      let repeats = 2;
-      let j = i + 2 * k;
-      while ( cycleEquals( rawSteps, i, k, j ) ) {
-        repeats++;
-        j += k;
-      }
-
-      const patternSteps = rawSteps.slice( i, i + k );
-      const totalMs = rawSteps.slice( i, j ).reduce( ( sum, s ) => sum + ( s.ms || 0 ), 0 );
-
-      out.push( {
-        stepIndex: out.length + 1,
-        name: patternSteps.map( ( s ) => s.count ? `${ s.name }×${ s.count }` : s.name ).join( ' → ' ),
-        type: 'batch',
-        status: 'success',
-        count: repeats,
-        ms: totalMs,
-        pattern: patternSteps.map( ( s ) => ( {
-          name: s.name,
-          type: s.type,
-          count: s.count ?? 1,
-        } ) ),
-      } );
-
-      i = j;
-      absorbed = true;
-      break;
-    }
-
-    if ( !absorbed ) {
-      out.push( { ...rawSteps[i], stepIndex: out.length + 1 } );
-      i++;
-    }
-  }
-
-  return out;
-}
-
-function cycleEquals( steps, patternStart, patternLen, checkStart ) {
-  if ( checkStart + patternLen > steps.length ) return false;
-  for ( let i = 0; i < patternLen; i++ ) {
-    const a = steps[patternStart + i];
-    const b = steps[checkStart + i];
-    if ( !a || !b ) return false;
-    if ( a.status === 'failed' || b.status === 'failed' ) return false;
-    if ( a.name !== b.name ) return false;
-    if ( a.type !== b.type ) return false;
-    if ( a.status !== b.status ) return false;
-  }
-  return true;
-}

package/src/logging/config.js

@@ -1,24 +0,0 @@
-/**
- * Self-contained configuration for the activity logging module.
- *
- * Read directly from process.env so this module has zero dependency on
- * consumers' env.js layout. Getters (not cached values) so dotenv can load
- * after this module is imported.
- */
-
-const DEFAULT_INDEX = 'trax-activity-logs-test';
-const LOG_VERSION = 'v1';
-
-export const loggingConfig = {
-  get enabled() {
-    return process.env.TRAX_ACTIVITY_LOGGING === 'true';
-  },
-  get index() {
-    try {
-      return JSON.parse( process.env.OPENSEARCH || '{}' )?.traxActivityLog || DEFAULT_INDEX;
-    } catch ( _e ) {
-      return DEFAULT_INDEX;
-    }
-  },
-  version: LOG_VERSION,
-};

package/src/logging/createLoggableService.js

@@ -1,46 +0,0 @@
-import { getLogContext, pushStep, pushStepFailure } from './activityLogStore.js';
-import { loggingConfig } from './config.js';
-
-const WRITE_OPS = [
-  'create',
-  'updateOne',
-  'updateMany',
-  'deleteOne',
-  'deleteMany',
-  'upsertOne',
-  'insertMany',
-  'bulkUpsert',
-  'bulkWrite',
-  'removeKeys',
-  'findOneAndUpdate',
-  'findOneAndUpdate2',
-  'updateOneArrayItem',
-  'update',
-];
-
-export function createLoggableService( serviceModule, collectionName ) {
-  // Install the proxy unconditionally. The enabled-check happens at call time
-  // inside the `get` trap so env vars loaded after module import (via dotenv)
-  // are observed correctly.
-  return new Proxy( serviceModule, {
-    get( target, prop ) {
-      const original = target[prop];
-      if ( !WRITE_OPS.includes( prop ) || typeof original !== 'function' ) return original;
-      if ( !loggingConfig.enabled ) return original;
-
-      return async function( ...args ) {
-        const ctx = getLogContext();
-        const start = Date.now();
-        const stepName = `${ collectionName }.${ prop }`;
-        try {
-          const result = await original.apply( target, args );
-          if ( ctx ) pushStep( { name: stepName, type: 'db', status: 'success', ms: Date.now() - start } );
-          return result;
-        } catch ( e ) {
-          if ( ctx ) pushStepFailure( { name: stepName, type: 'db', ms: Date.now() - start }, e );
-          throw e;
-        }
-      };
-    },
-  } );
-}

package/src/logging/logExternalCall.js

@@ -1,37 +0,0 @@
-import { pushStep, pushStepFailure } from './activityLogStore.js';
-
-export async function logExternalCall( serviceName, url, options = {} ) {
-  const start = Date.now();
-  const stepName = `external.${ serviceName }`;
-  try {
-    const res = await fetch( url, options );
-    pushStep( {
-      name: stepName,
-      type: 'external',
-      status: res.ok ? 'success' : 'failed',
-      ms: Date.now() - start,
-    } );
-    return res;
-  } catch ( e ) {
-    pushStepFailure( { name: stepName, type: 'external', ms: Date.now() - start }, e );
-    throw e;
-  }
-}
-
-export async function logQueueMessage( serviceName, queueUrl, messageBody, sendMessageToQueueFn ) {
-  const start = Date.now();
-  const stepName = `external.${ serviceName }`;
-  try {
-    const result = await sendMessageToQueueFn( queueUrl, messageBody );
-    pushStep( {
-      name: stepName,
-      type: 'external',
-      status: 'success',
-      ms: Date.now() - start,
-    } );
-    return result;
-  } catch ( e ) {
-    pushStepFailure( { name: stepName, type: 'external', ms: Date.now() - start }, e );
-    throw e;
-  }
-}