@output.ai/core 0.3.9-dev.pr306-0a74ef2 → 0.3.11-dev.pr311-3950092

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.3.9-dev.pr306-0a74ef2",
+  "version": "0.3.11-dev.pr311-3950092",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {

package/src/tracing/processors/s3/redis_client.js

@@ -1,19 +1,63 @@
 import { createClient } from 'redis';
 import { throws } from '#utils';
+import { createChildLogger } from '#logger';
 
-const state = { client: null };
+const log = createChildLogger( 'RedisClient' );
+
+const state = {
+  client: null,
+  connectPromise: null
+};
+
+async function connect( url ) {
+  if ( state.client ) {
+    log.warn( 'Closing stale Redis client before reconnecting' );
+    await state.client.quit().catch( quitErr => {
+      log.warn( 'Failed to quit stale Redis client', { error: quitErr.message } );
+    } );
+    state.client = null;
+  }
+
+  const client = createClient( { url, socket: { keepAlive: 15000 } } );
+  try {
+    await client.connect();
+    return state.client = client;
+  } catch ( err ) {
+    await client.quit().catch( () => {} );
+    throw new Error( `Failed to connect to Redis: ${err.message} (${err.code || 'UNKNOWN'})`, { cause: err } );
+  }
+}
 
 /**
- * Return a connected Redis instance
- * @returns {redis.RedisClientType}
+ * Return a connected Redis instance with automatic reconnection.
+ *
+ * Performs health check on cached client via ping(). If healthy, returns cached
+ * instance. Otherwise, closes stale client before creating new connection.
+ * Concurrent calls during connection will receive the same pending promise.
+ *
+ * @returns {Promise<redis.RedisClientType>} Connected Redis client
+ * @throws {Error} If REDIS_URL env var is missing
+ * @throws {Error} If connection fails (wrapped with context)
  */
 export async function getRedisClient() {
   const url = process.env.REDIS_URL ?? throws( new Error( 'Missing REDIS_URL environment variable' ) );
-  if ( await state.client?.ping().catch( _ => 0 ) === 'PONG' ) {
+
+  const pingResult = await state.client?.ping().catch( err => {
+    log.error( 'Redis ping failed', { error: err.message, code: err.code } );
+    return null;
+  } );
+
+  if ( pingResult === 'PONG' ) {
     return state.client;
-  };
+  }
 
-  const client = createClient( { url, socket: { keepAlive: 15000 } } );
-  await client.connect();
-  return state.client = client;
-};
+  if ( state.connectPromise ) {
+    return state.connectPromise;
+  }
+
+  state.connectPromise = connect( url ).finally( () => {
+    state.connectPromise = null;
+  } );
+
+  return state.connectPromise;
+}

package/src/tracing/processors/s3/redis_client.spec.js

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
 vi.mock( '#utils', () => ( {
   throws: e => {
@@ -6,6 +6,14 @@ vi.mock( '#utils', () => ( {
   }
 } ) );
 
+const logCalls = { warn: [], error: [] };
+vi.mock( '#logger', () => ( {
+  createChildLogger: () => ( {
+    warn: ( ...args ) => logCalls.warn.push( args ),
+    error: ( ...args ) => logCalls.error.push( args )
+  } )
+} ) );
+
 const createClientImpl = vi.fn();
 vi.mock( 'redis', () => ( { createClient: opts => createClientImpl( opts ) } ) );
 
@@ -18,6 +26,12 @@ describe( 'tracing/processors/s3/redis_client', () => {
   beforeEach( () => {
     vi.clearAllMocks();
     delete process.env.REDIS_URL;
+    logCalls.warn = [];
+    logCalls.error = [];
+  } );
+
+  afterEach( () => {
+    vi.useRealTimers();
   } );
 
   it( 'throws if REDIS_URL is missing', async () => {
@@ -47,4 +61,121 @@ describe( 'tracing/processors/s3/redis_client', () => {
     expect( c1 ).toBe( c2 );
     expect( created[0] ).toMatchObject( { url: 'redis://localhost:6379', socket: { keepAlive: 15000 } } );
   } );
+
+  it( 'closes stale client and reconnects when ping fails', async () => {
+    process.env.REDIS_URL = 'redis://localhost:6379';
+
+    const quitMock = vi.fn().mockResolvedValue();
+    const connectMock = vi.fn().mockResolvedValue();
+    const pingMock = vi.fn()
+      .mockResolvedValueOnce( 'PONG' )
+      .mockRejectedValueOnce( new Error( 'Connection lost' ) )
+      .mockResolvedValueOnce( 'PONG' );
+
+    const created = [];
+    createClientImpl.mockImplementation( opts => {
+      created.push( opts );
+      return { connect: connectMock, ping: pingMock, quit: quitMock };
+    } );
+
+    const { getRedisClient } = await loadModule();
+
+    const c1 = await getRedisClient();
+    const c2 = await getRedisClient();
+    expect( c1 ).toBe( c2 );
+    expect( created ).toHaveLength( 1 );
+
+    const c3 = await getRedisClient();
+    expect( quitMock ).toHaveBeenCalledTimes( 1 );
+    expect( created ).toHaveLength( 2 );
+    expect( c3 ).not.toBe( c1 );
+  } );
+
+  it( 'reconnects successfully even when quit() on stale client rejects', async () => {
+    process.env.REDIS_URL = 'redis://localhost:6379';
+
+    const quitMock = vi.fn().mockRejectedValue( new Error( 'Quit failed' ) );
+    const connectMock = vi.fn().mockResolvedValue();
+    const pingMock = vi.fn()
+      .mockResolvedValueOnce( 'PONG' )
+      .mockRejectedValueOnce( new Error( 'Connection lost' ) )
+      .mockResolvedValueOnce( 'PONG' );
+
+    const created = [];
+    createClientImpl.mockImplementation( opts => {
+      created.push( opts );
+      return { connect: connectMock, ping: pingMock, quit: quitMock };
+    } );
+
+    const { getRedisClient } = await loadModule();
+
+    const c1 = await getRedisClient();
+    const c1again = await getRedisClient();
+    expect( c1 ).toBe( c1again );
+    expect( created ).toHaveLength( 1 );
+
+    const c2 = await getRedisClient();
+    expect( quitMock ).toHaveBeenCalledTimes( 1 );
+    expect( created ).toHaveLength( 2 );
+    expect( c2 ).not.toBe( c1 );
+  } );
+
+  it( 'wraps connect() errors with code and cleans up failed client', async () => {
+    process.env.REDIS_URL = 'redis://localhost:6379';
+
+    const connectErr = new Error( 'Connection refused' );
+    connectErr.code = 'ECONNREFUSED';
+    const connectMock = vi.fn().mockRejectedValue( connectErr );
+    const quitMock = vi.fn().mockResolvedValue();
+
+    createClientImpl.mockImplementation( () => ( {
+      connect: connectMock,
+      quit: quitMock
+    } ) );
+
+    const { getRedisClient } = await loadModule();
+
+    try {
+      await getRedisClient();
+      expect.fail( 'Should have thrown' );
+    } catch ( err ) {
+      expect( err.message ).toBe( 'Failed to connect to Redis: Connection refused (ECONNREFUSED)' );
+      expect( err.cause ).toBe( connectErr );
+    }
+
+    expect( quitMock ).toHaveBeenCalledTimes( 1 );
+  } );
+
+  it( 'logs ping failures with error level', async () => {
+    process.env.REDIS_URL = 'redis://localhost:6379';
+
+    const pingErr = new Error( 'Connection reset' );
+    pingErr.code = 'ECONNRESET';
+    const pingMock = vi.fn()
+      .mockResolvedValueOnce( 'PONG' )
+      .mockRejectedValueOnce( pingErr )
+      .mockResolvedValueOnce( 'PONG' );
+    const connectMock = vi.fn().mockResolvedValue();
+    const quitMock = vi.fn().mockResolvedValue();
+
+    createClientImpl.mockImplementation( () => ( {
+      connect: connectMock,
+      ping: pingMock,
+      quit: quitMock
+    } ) );
+
+    const { getRedisClient } = await loadModule();
+
+    // First call: state.client is null, creates client (no ping)
+    await getRedisClient();
+    // Second call: pings existing client, returns PONG
+    await getRedisClient();
+    // Third call: pings existing client, fails with pingErr, reconnects
+    await getRedisClient();
+
+    expect( logCalls.error ).toContainEqual( [
+      'Redis ping failed',
+      { error: 'Connection reset', code: 'ECONNRESET' }
+    ] );
+  } );
 } );