@aj-archipelago/cortex 1.0.25 → 1.1.0-beta.0

package/.eslintrc

@@ -16,7 +16,7 @@
     ],
     "rules": {
         "import/no-unresolved": "error",
-        "import/no-extraneous-dependencies": ["error", {"devDependencies": true}],
+        "import/no-extraneous-dependencies": ["error", {"devDependencies": true, "dependencies": true}],
         "no-unused-vars": ["error", { "argsIgnorePattern": "^_" }]
     },
     "settings": {

package/config.js

@@ -4,11 +4,17 @@ import HandleBars from './lib/handleBars.js';
 import fs from 'fs';
 import { fileURLToPath, pathToFileURL } from 'url';
 import GcpAuthTokenHelper from './lib/gcpAuthTokenHelper.js';
+import logger from './lib/logger.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 // Schema for config
 var config = convict({
+    env: {
+        format: String,
+        default: 'development',
+        env: 'NODE_ENV'
+    },
     cortexId: {
         format: String,
         default: 'local',
@@ -195,14 +201,16 @@ const configFile = config.get('cortexConfigFile');
 
 // Load config file
 if (configFile && fs.existsSync(configFile)) {
-    console.log('Loading config from', configFile);
+    logger.info(`Loading config from ${configFile}`);
     config.loadFile(configFile);
 } else {
     const openaiApiKey = config.get('openaiApiKey');
     if (!openaiApiKey) {
-        throw console.log('No config file or api key specified. Please set the OPENAI_API_KEY to use OAI or use CORTEX_CONFIG_FILE environment variable to point at the Cortex configuration for your project.');
+        const errorString = 'No config file or api key specified. Please set the OPENAI_API_KEY to use OAI or use CORTEX_CONFIG_FILE environment variable to point at the Cortex configuration for your project.';
+        logger.error(errorString);
+        throw new Error(errorString);
     } else {
-        console.log(`Using default model with OPENAI_API_KEY environment variable`)
+        logger.info(`Using default model with OPENAI_API_KEY environment variable`)
     }
 }
 
@@ -223,12 +231,12 @@ const buildPathways = async (config) => {
     const basePathway = await import(basePathwayURL).then(module => module.default);
 
     // Load core pathways, default from the Cortex package
-    console.log('Loading core pathways from', corePathwaysPath)
+    logger.info(`Loading core pathways from ${corePathwaysPath}`)
     let loadedPathways = await import(`${corePathwaysURL}/index.js`).then(module => module);
 
     // Load custom pathways and override core pathways if same
     if (pathwaysPath && fs.existsSync(pathwaysPath)) {
-        console.log('Loading custom pathways from', pathwaysPath)
+        logger.info(`Loading custom pathways from ${pathwaysPath}`)
         const customPathways = await import(`${pathwaysURL}/index.js`).then(module => module);
         loadedPathways = { ...loadedPathways, ...customPathways };
     }
@@ -263,12 +271,14 @@ const buildModels = (config) => {
 
     // Check that models are specified, Cortex cannot run without a model
     if (Object.keys(config.get('models')).length <= 0) {
-        throw console.log('No models specified! Please set the models in your config file or via CORTEX_MODELS environment variable to point at the models for your project.');
+        const errorString = 'No models specified! Please set the models in your config file or via CORTEX_MODELS environment variable to point at the models for your project.';
+        logger.error(errorString);
+        throw new Error(errorString);
     }
 
     // Set default model name to the first model in the config in case no default is specified
     if (!config.get('defaultModelName')) {
-        console.log('No default model specified, using first model as default.');
+        logger.warn('No default model specified, using first model as default.');
         config.load({ defaultModelName: Object.keys(config.get('models'))[0] });
     }
 

package/lib/logger.js

@@ -0,0 +1,29 @@
+// logger.js
+import winston from 'winston';
+
+const format = winston.format.combine(
+    //winston.format.timestamp(),
+    winston.format.colorize({ all: true }),
+    winston.format.simple()
+);
+
+const transports = [
+    new winston.transports.Console({ format })
+];
+
+const logger = winston.createLogger({
+    level: process.env.NODE_ENV === 'production' ? 'info' : 'debug',
+    format: format,
+    transports: transports
+});
+
+winston.addColors({
+    debug: 'green',
+    verbose: 'blue',
+    http: 'gray',
+    info: 'cyan',
+    warn: 'yellow',
+    error: 'red'
+});
+
+export default logger;

package/lib/redisSubscription.js

@@ -1,39 +1,47 @@
 import Redis from 'ioredis';
 import { config } from '../config.js';
 import pubsub from '../server/pubsub.js';
+import { requestState } from '../server/requestState.js';
+import logger from '../lib/logger.js';
 
 const connectionString = config.get('storageConnectionString');
-const channel = 'requestProgress';
+const channels = ['requestProgress', 'requestProgressSubscriptions'];
 let client;
 
 if (connectionString) {
-    console.log(`Using Redis subscription for channel ${channel}`);
+    logger.info(`Using Redis subscription for channel(s) ${channels.join(', ')}`);
     try {
         client = connectionString && new Redis(connectionString);
     } catch (error) {
-        console.error('Redis connection error: ', error);
+        logger.error(`Redis connection error: ${JSON.stringify(error)}`);
     }
 
     if (client) {
-        const channel = 'requestProgress';
 
         client.on('error', (error) => {
-            console.error(`Redis client error: ${error}`);
+            logger.error(`Redis client error: ${JSON.stringify(error)}`);
         });
 
         client.on('connect', () => {
-            client.subscribe(channel, (error) => {
+            client.subscribe('requestProgress', (error) => {
                 if (error) {
-                    console.error(`Error subscribing to channel ${channel}: ${error}`);
+                    logger.error(`Error subscribing to redis channel requestProgress: ${JSON.stringify(error)}`);
                 } else {
-                    console.log(`Subscribed to channel ${channel}`);
+                    logger.info(`Subscribed to channel requestProgress`);
+                }
+            });
+            client.subscribe('requestProgressSubscriptions', (error) => {
+                if (error) {
+                    logger.error(`Error subscribing to redis channel requestProgressSubscriptions: ${JSON.stringify(error)}`);
+                } else {
+                    logger.info(`Subscribed to channel requestProgressSubscriptions`);
                 }
             });
         });
 
         client.on('message', (channel, message) => {
             if (channel === 'requestProgress') {
-                console.log(`Received message from ${channel}: ${message}`);
+                logger.debug(`Received message from ${channel}: ${message}`);
                 let parsedMessage;
 
                 try {
@@ -42,22 +50,86 @@ if (connectionString) {
                     parsedMessage = message;
                 }
 
-                handleMessage(parsedMessage);
+                pubsubHandleMessage(parsedMessage);
+            } else {
+                if (channel === 'requestProgressSubscriptions') {
+                    logger.debug(`Received message from ${channel}: ${message}`);
+                    let parsedMessage;
+
+                    try {
+                        parsedMessage = JSON.parse(message);
+                    } catch (error) {
+                        parsedMessage = message;
+                    }
+
+                    handleSubscription(parsedMessage);
+                }
             }
         });
+    }
+}
 
-        const handleMessage = (data) => {
-            // Process the received data
-            console.log('Processing data:', data);
-            try {
-                pubsub.publish('REQUEST_PROGRESS', { requestProgress: data });
-            } catch (error) {
-                console.error(`Error publishing data to pubsub: ${error}`);
-            }
-        };
+
+let publisherClient;
+
+if (connectionString) {
+    logger.info(`Using Redis publish for channel(s) ${channels.join(', ')}`);
+    publisherClient = Redis.createClient(connectionString);
+} else {
+    logger.info(`Using pubsub publish for channel ${channels[0]}`);
+}
+
+async function publishRequestProgress(data) {
+    if (publisherClient) {
+        try {
+            const message = JSON.stringify(data);
+            logger.debug(`Publishing message ${message} to channel ${channels[0]}`);
+            await publisherClient.publish(channels[0], message);
+        } catch (error) {
+            logger.error(`Error publishing message: ${JSON.stringify(error)}`);
+        }
+    } else {
+        pubsubHandleMessage(data);
+    }
+}
+
+async function publishRequestProgressSubscription(data) {
+    if (publisherClient) {
+        try {
+            const message = JSON.stringify(data);
+            logger.debug(`Publishing message ${message} to channel ${channels[1]}`);
+            await publisherClient.publish(channels[1], message);
+        } catch (error) {
+            logger.error(`Error publishing message: ${JSON.stringify(error)}`);
+        }
+    } else {
+        handleSubscription(data);
     }
 }
 
+function pubsubHandleMessage(data){
+    const message = JSON.stringify(data);
+    logger.debug(`Publishing message to pubsub: ${message}`);
+    try {
+        pubsub.publish('REQUEST_PROGRESS', { requestProgress: data });
+    } catch (error) {
+        logger.error(`Error publishing data to pubsub: ${JSON.stringify(error)}`);
+    }
+}
+
+function handleSubscription(data){
+    const requestIds = data;
+    for (const requestId of requestIds) {
+        if (requestState[requestId] && !requestState[requestId].started) {
+            requestState[requestId].started = true;
+            logger.info(`Subscription starting async requestProgress, requestId: ${requestId}`);
+            const { resolver, args } = requestState[requestId];
+            resolver(args);
+        }
+    }
+}
+
+
 export {
-    client as subscriptionClient,
+    client as subscriptionClient, publishRequestProgress, publishRequestProgressSubscription
 };

package/lib/request.js

@@ -4,13 +4,14 @@ import { config } from '../config.js';
 import axios from 'axios';
 import { setupCache } from 'axios-cache-interceptor';
 import Redis from 'ioredis';
+import logger from './logger.js';
 
 const connectionString = config.get('storageConnectionString');
 
 if (!connectionString) {
-    console.log('No STORAGE_CONNECTION_STRING found in environment. Redis features (caching, pubsub, clustered limiters) disabled.')
+    logger.info('No STORAGE_CONNECTION_STRING found in environment. Redis features (caching, pubsub, clustered limiters) disabled.')
 } else {
-    console.log('Using Redis connection specified in STORAGE_CONNECTION_STRING.');
+    logger.info('Using Redis connection specified in STORAGE_CONNECTION_STRING.');
 }   
 
 let client;
@@ -19,7 +20,7 @@ if (connectionString) {
     try {
         client = new Redis(connectionString);
     } catch (error) {
-        console.error('Redis connection error: ', error);
+        logger.error(`Redis connection error: ${error}`);
     }
 }
 
@@ -30,7 +31,7 @@ const limiters = {};
 const monitors = {};
 
 const buildLimiters = (config) => {
-    console.log(`Building ${connection ? 'Redis clustered' : 'local'} model rate limiters for ${cortexId}...`);
+    logger.info(`Building ${connection ? 'Redis clustered' : 'local'} model rate limiters for ${cortexId}...`);
     for (const [name, model] of Object.entries(config.get('models'))) {
         const rps = model.requestsPerSecond ?? 100;
         let limiterOptions = {
@@ -50,7 +51,7 @@ const buildLimiters = (config) => {
 
         limiters[name] = new Bottleneck(limiterOptions);
         limiters[name].on('error', (err) => {
-            console.error(`Limiter error for ${cortexId}-${name}:`, err);
+            logger.error(`Limiter error for ${cortexId}-${name}: ${err}`);
         });
         monitors[name] = new RequestMonitor();
     }
@@ -81,9 +82,9 @@ setInterval(() => {
         const callRate = monitor.getPeakCallRate();
         const error429Rate = monitor.getError429Rate();
         if (callRate > 0) {
-            console.log('------------------------');
-            console.log(`${monitorName} Call rate: ${callRate} calls/sec, 429 errors: ${error429Rate * 100}%`);
-            console.log('------------------------');
+            logger.info('------------------------');
+            logger.info(`${monitorName} Call rate: ${callRate} calls/sec, 429 errors: ${error429Rate * 100}%`);
+            logger.info('------------------------');
             // Reset the rate monitor to start a new monitoring interval.
             monitor.reset();
         }
@@ -109,7 +110,7 @@ const postRequest = async ({ url, data, params, headers, cache }, model, request
         let duplicateRequestAfter = (pathway?.duplicateRequestAfter || DUPLICATE_REQUEST_AFTER) * 1000;
 
         if (enableDuplicateRequests) {
-            //console.log(`>>> [${requestId}] Duplicate requests enabled after ${duplicateRequestAfter / 1000} seconds`);
+            //logger.info(`>>> [${requestId}] Duplicate requests enabled after ${duplicateRequestAfter / 1000} seconds`);
         }
 
         const axiosConfigObj = { params, headers, cache };
@@ -119,7 +120,7 @@ const postRequest = async ({ url, data, params, headers, cache }, model, request
             promises.push(limiters[model].schedule(() => postWithMonitor(model, url, data, axiosConfigObj)));
         } else {
             if (streamRequested) {
-                console.log(`>>> [${requestId}] ${model} does not support streaming - sending non-streaming request`);
+                logger.info(`>>> [${requestId}] ${model} does not support streaming - sending non-streaming request`);
                 axiosConfigObj.params.stream = false;
                 data.stream = false;
             }
@@ -144,7 +145,7 @@ const postRequest = async ({ url, data, params, headers, cache }, model, request
                                 axiosConfigObj.headers['X-Cortex-Request-Index'] = index;
 
                                 if (index === 0) {
-                                    //console.log(`>>> [${requestId}] sending request to ${model} API ${axiosConfigObj.responseType === 'stream' ? 'with streaming' : ''}`);
+                                    //logger.info(`>>> [${requestId}] sending request to ${model} API ${axiosConfigObj.responseType === 'stream' ? 'with streaming' : ''}`);
                                 } else {
                                     if (modelProperties.supportsStreaming) {
                                         axiosConfigObj.responseType = 'stream';
@@ -152,23 +153,23 @@ const postRequest = async ({ url, data, params, headers, cache }, model, request
                                     }
                                     const logMessage = `>>> [${requestId}] taking too long - sending duplicate request ${index} to ${model} API ${axiosConfigObj.responseType === 'stream' ? 'with streaming' : ''}`;
                                     const header = '>'.repeat(logMessage.length);
-                                    console.log(`\n${header}\n${logMessage}`);
+                                    logger.info(`\n${header}\n${logMessage}`);
                                 }
 
                                 response = await limiters[model].schedule(() => postWithMonitor(model, url, data, axiosConfigObj));
 
                                 if (!controller.signal?.aborted) {
 
-                                    //console.log(`<<< [${requestId}] received response for request ${index}`);
+                                    //logger.info(`<<< [${requestId}] received response for request ${index}`);
 
                                     if (axiosConfigObj.responseType === 'stream') {
                                         // Buffering and collecting the stream data
-                                        console.log(`<<< [${requestId}] buffering streaming response for request ${index}`);
+                                        logger.info(`<<< [${requestId}] buffering streaming response for request ${index}`);
                                         response = await new Promise((resolve, reject) => {
                                             let responseData = '';
                                             response.data.on('data', (chunk) => {
                                                 responseData += chunk;
-                                                //console.log(`<<< [${requestId}] received chunk for request ${index}`);
+                                                //logger.info(`<<< [${requestId}] received chunk for request ${index}`);
                                             });
                                             response.data.on('end', () => {
                                                 response.data = JSON.parse(responseData);
@@ -186,10 +187,10 @@ const postRequest = async ({ url, data, params, headers, cache }, model, request
 
                         } catch (error) {
                             if (error.name === 'AbortError' || error.name === 'CanceledError') {
-                                //console.log(`XXX [${requestId}] request ${index} was cancelled`);
+                                //logger.info(`XXX [${requestId}] request ${index} was cancelled`);
                                 reject(error);
                             } else {
-                                console.log(`!!! [${requestId}] request ${index} failed with error: ${error?.response?.data?.error?.message || error}`);
+                                logger.info(`!!! [${requestId}] request ${index} failed with error: ${error?.response?.data?.error?.message || error}`);
                                 reject(error);
                             }
                         } finally {
@@ -210,14 +211,14 @@ const postRequest = async ({ url, data, params, headers, cache }, model, request
                 throw new Error(`Received error response: ${response.status}`);
             }
         } catch (error) {
-            //console.error(`!!! [${requestId}] failed request with data ${JSON.stringify(data)}: ${error}`);
+            //logger.error(`!!! [${requestId}] failed request with data ${JSON.stringify(data)}: ${error}`);
             if (error.response) {
                 const status = error.response.status;
                 if ((status === 429) || (status >= 500 && status < 600)) {
                     if (status === 429) {
                         monitors[model].incrementError429Count();
                     }
-                    console.log(`>>> [${requestId}] retrying request due to ${status} response. Retry count: ${i + 1}`);
+                    logger.info(`>>> [${requestId}] retrying request due to ${status} response. Retry count: ${i + 1}`);
                     if (i < MAX_RETRY - 1) {
                         const backoffTime = 200 * Math.pow(2, i);
                         const jitter = backoffTime * 0.2 * Math.random();
@@ -246,10 +247,10 @@ const request = async (params, model, requestId, pathway) => {
             const lastError = error[error.length - 1];
             return { error: lastError.toJSON() ?? lastError ?? error };
         }
-        //console.log("<<< [${requestId}] response: ", data.choices[0].delta || data.choices[0])
+        //logger.info(`<<< [${requestId}] response: ${data.choices[0].delta || data.choices[0]}`)
         return data;
     } catch (error) {
-        console.error(`Error in request: ${error.message || error}`);
+        logger.error(`Error in request: ${error.message || error}`);
         return { error: error };
     } 
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.0.25",
+  "version": "1.1.0-beta.0",
   "description": "Cortex is a GraphQL API for AI. It provides a simple, extensible interface for using AI services from OpenAI, Azure and others.",
   "private": false,
   "repository": {
@@ -54,6 +54,7 @@
     "langchain": "^0.0.47",
     "subsrt": "^1.1.1",
     "uuid": "^9.0.0",
+    "winston": "^3.11.0",
     "ws": "^8.12.0"
   },
   "devDependencies": {
@@ -62,7 +63,7 @@
     "eslint": "^8.38.0",
     "eslint-plugin-import": "^2.27.5",
     "got": "^13.0.0",
-    "sinon": "^15.0.3"
+    "sinon": "^17.0.1"
   },
   "publishConfig": {
     "access": "restricted"

package/server/graphql.js

@@ -22,6 +22,7 @@ import { buildPathways, buildModels } from '../config.js';
 import { requestState } from './requestState.js';
 import { buildRestEndpoints } from './rest.js';
 import { startTestServer } from '../tests/server.js'
+import logger from '../lib/logger.js';
 
 // Utility functions
 // Server plugins
@@ -41,7 +42,7 @@ const getPlugins = (config) => {
         // TODO: custom cache key:
         // https://www.apollographql.com/docs/apollo-server/performance/cache-backends#implementing-your-own-cache-backend
         plugins.push(responseCachePlugin({ cache }));
-        console.log('Using Redis for GraphQL cache');
+        logger.info('Using Redis for GraphQL cache');
     }
 
     return { plugins, cache };
@@ -146,12 +147,12 @@ const build = async (config) => {
     // Respects the keep alive setting in config in case you want to
     // turn it off for deployments that don't route the ping/pong frames
     const keepAlive = config.get('subscriptionKeepAlive');
-    console.log(`Starting web socket server with subscription keep alive: ${keepAlive}`);
+    logger.info(`Starting web socket server with subscription keep alive: ${keepAlive}`);
     const serverCleanup = useServer({ schema }, wsServer, keepAlive);
 
     const server = new ApolloServer({
         schema,
-        introspection: process.env.NODE_ENV === 'development',
+        introspection: config.get('env') === 'development',
         csrfPrevention: true,
         plugins: plugins.concat([// Proper shutdown for the HTTP server.
             ApolloServerPluginDrainHttpServer({ httpServer }),
@@ -232,7 +233,7 @@ const build = async (config) => {
 
         // Now that our HTTP server is fully set up, we can listen to it.
         httpServer.listen(config.get('PORT'), () => {
-            console.log(`🚀 Server is now running at http://localhost:${config.get('PORT')}/graphql`);
+            logger.info(`🚀 Server is now running at http://localhost:${config.get('PORT')}/graphql`);
         });
     };
 

package/server/pathwayResolver.js

@@ -1,7 +1,6 @@
 import { PathwayPrompter } from './pathwayPrompter.js';
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { v4 as uuidv4 } from 'uuid';
-import pubsub from './pubsub.js';
 import { encode } from 'gpt-3-encoder';
 import { getFirstNToken, getLastNToken, getSemanticChunks } from './chunker.js';
 import { PathwayResponseParser } from './pathwayResponseParser.js';
@@ -9,6 +8,8 @@ import { Prompt } from './prompt.js';
 import { getv, setv } from '../lib/keyValueStorageClient.js';
 import { requestState } from './requestState.js';
 import { callPathway } from '../lib/pathwayTools.js';
+import { publishRequestProgress } from '../lib/redisSubscription.js';
+import logger from '../lib/logger.js';
 
 const modelTypesExcludedFromProgressUpdates = ['OPENAI-DALLE2', 'OPENAI-DALLE3'];
 
@@ -83,12 +84,10 @@ class PathwayResolver {
                 
                 // if model type is OPENAI-IMAGE
                 if (!modelTypesExcludedFromProgressUpdates.includes(this.model.type)) {
-                    pubsub.publish('REQUEST_PROGRESS', {
-                        requestProgress: {
+                    await publishRequestProgress({
                             requestId: this.requestId,
                             progress: completedCount / totalCount,
                             data: JSON.stringify(responseData),
-                        }
                     });
                 }
             } else {
@@ -99,7 +98,7 @@ class PathwayResolver {
 
                     const processData = (data) => {
                         try {
-                            //console.log(`\n\nReceived stream data for requestId ${this.requestId}`, data.toString());
+                            //logger.info(`\n\nReceived stream data for requestId ${this.requestId}: ${data.toString()}`);
                             let events = data.toString().split('\n');
                             
                             //events = "data: {\"id\":\"chatcmpl-20bf1895-2fa7-4ef9-abfe-4d142aba5817\",\"object\":\"chat.completion.chunk\",\"created\":1689303423723,\"model\":\"gpt-4\",\"choices\":[{\"delta\":{\"role\":\"assistant\",\"content\":{\"error\":{\"message\":\"The server had an error while processing your request. Sorry about that!\",\"type\":\"server_error\",\"param\":null,\"code\":null}}},\"finish_reason\":null}]}\n\n".split("\n");
@@ -109,7 +108,7 @@ class PathwayResolver {
                                 
                                 // skip empty events
                                 if (!(event.trim() === '')) {
-                                    //console.log(`Processing stream event for requestId ${this.requestId}`, event);
+                                    //logger.info(`Processing stream event for requestId ${this.requestId}: ${event}`);
                                     messageBuffer += event.replace(/^data: /, '');
 
                                     const requestProgress = {
@@ -133,24 +132,22 @@ class PathwayResolver {
                                         const streamError = parsedMessage?.error || parsedMessage?.choices?.[0]?.delta?.content?.error || parsedMessage?.choices?.[0]?.text?.error;
                                         if (streamError) {
                                             streamErrorOccurred = true;
-                                            console.error(`Stream error: ${streamError.message}`);
+                                            logger.error(`Stream error: ${streamError.message}`);
                                             incomingMessage.off('data', processData); // Stop listening to 'data'
                                             return;
                                         }
                                     }
 
                                     try {
-                                        //console.log(`Publishing stream message to requestId ${this.requestId}`, message);
-                                        pubsub.publish('REQUEST_PROGRESS', {
-                                            requestProgress: requestProgress
-                                        });
+                                        //logger.info(`Publishing stream message to requestId ${this.requestId}: ${message}`);
+                                        publishRequestProgress(requestProgress);
                                     } catch (error) {
-                                        console.error('Could not publish the stream message', messageBuffer, error);
+                                        logger.error(`Could not publish the stream message: "${messageBuffer}", ${error}`);
                                     }
                                 }
                             }
                         } catch (error) {
-                            console.error('Could not process stream data', error);
+                            logger.error(`Could not process stream data: ${error}`);
                         }
                     };
 
@@ -163,25 +160,23 @@ class PathwayResolver {
                     }
 
                 } catch (error) {
-                    console.error('Could not subscribe to stream', error);
+                    logger.error(`Could not subscribe to stream: ${error}`);
                 }
             }
 
             if (streamErrorOccurred) {
                 attempt++;
-                console.error(`Stream attempt ${attempt} failed. Retrying...`);
+                logger.error(`Stream attempt ${attempt} failed. Retrying...`);
                 streamErrorOccurred = false; // Reset the flag for the next attempt
             } else {
                 return;
             }
         }
         // if all retries failed, publish the stream end message
-        pubsub.publish('REQUEST_PROGRESS', {
-            requestProgress: {
+        publishRequestProgress({
                 requestId: this.requestId,
                 progress: 1,
                 data: '[DONE]',
-            }
         });
     }
 
@@ -401,11 +396,9 @@ class PathwayResolver {
         const { completedCount, totalCount } = requestState[this.requestId];
 
         if (completedCount < totalCount) {
-            pubsub.publish('REQUEST_PROGRESS', {
-                requestProgress: {
+            await publishRequestProgress({
                     requestId: this.requestId,
                     progress: completedCount / totalCount,
-                }
             });
         }
 

package/server/plugins/azureCognitivePlugin.js

@@ -5,6 +5,7 @@ import { v4 as uuidv4 } from 'uuid';
 import path from 'path';
 import { config } from '../../config.js';
 import { axios } from '../../lib/request.js';
+import logger from '../../lib/logger.js';
 
 const API_URL = config.get('whisperMediaApiUrl');
 
@@ -24,7 +25,7 @@ class AzureCognitivePlugin extends ModelPlugin {
             }
             return JSON.parse(await callPathway(this.config, 'embeddings', { text }))[0];
         }catch(err){
-            console.log(`Error in calculating input vector for text: ${text}, error: ${err}`);
+            logger.error(`Error in calculating input vector for text: ${text}, error: ${err}`);
         }
     }
 
@@ -134,11 +135,11 @@ class AzureCognitivePlugin extends ModelPlugin {
             if (API_URL) {
                 //call helper api to mark processing as completed
                 const res = await axios.delete(API_URL, { params: { requestId } });
-                console.log(`Marked request ${requestId} as completed:`, res.data);
+                logger.info(`Marked request ${requestId} as completed: ${res.data}`);
                 return res.data;
             }
         } catch (err) {
-            console.log(`Error marking request ${requestId} as completed:`, err);
+            logger.error(`Error marking request ${requestId} as completed: ${err}`);
         }
     }
 
@@ -161,7 +162,7 @@ class AzureCognitivePlugin extends ModelPlugin {
                     const { data }  = await axios.get(API_URL, { params: { uri: file, requestId, save: true } });
                     url = data[0];
                 } catch (error) {
-                    console.error(`Error converting file ${file} to txt:`, error);
+                    logger.error(`Error converting file ${file} to txt: ${error}`);
                     await this.markCompletedForCleanUp(requestId);
                     throw Error(error?.response?.data || error?.message || error);
                 }

package/server/plugins/azureTranslatePlugin.js

@@ -52,8 +52,8 @@ class AzureTranslatePlugin extends ModelPlugin {
     
         const modelInput = data[0].Text;
     
-        console.log(`\x1b[36m${modelInput}\x1b[0m`);
-        console.log(`\x1b[34m> ${this.parseResponse(responseData)}\x1b[0m`);
+        logger.debug(`${modelInput}`);
+        logger.debug(`${this.parseResponse(responseData)}`);
     
         prompt && prompt.debugInfo && (prompt.debugInfo += `\n${JSON.stringify(data)}`);
     }

package/server/plugins/localModelPlugin.js

@@ -54,16 +54,16 @@ class LocalModelPlugin extends ModelPlugin {
         //args.push("--temperature", requestParameters.temperature);
 
         try {
-            console.log(`\x1b[36mRunning local model:\x1b[0m`, executablePath, args);
+            logger.debug(`Running local model: ${executablePath}, ${args}`);
             const result = execFileSync(executablePath, args, { encoding: 'utf8' });
             // Remove only the first occurrence of requestParameters.prompt from the result
             // Could have used regex here but then would need to escape the prompt
             const parts = result.split(requestParameters.prompt, 2);
             const modifiedResult = parts[0] + parts[1];
-            console.log(`\x1b[36mResult:\x1b[0m`, modifiedResult);
+            logger.debug(`Result: ${modifiedResult}`);
             return this.filterFirstResponse(modifiedResult);
         } catch (error) {
-            console.error(`\x1b[31mError running local model:\x1b[0m`, error);
+            logger.error(`Error running local model: ${error}`);
             throw error;
         }
     }

package/server/plugins/modelPlugin.js

@@ -4,6 +4,7 @@ import HandleBars from '../../lib/handleBars.js';
 import { request } from '../../lib/request.js';
 import { encode } from 'gpt-3-encoder';
 import { getFirstNToken } from '../chunker.js';
+import logger from '../../lib/logger.js';
 
 const DEFAULT_MAX_TOKENS = 4096;
 const DEFAULT_MAX_RETURN_TOKENS = 256;
@@ -224,8 +225,9 @@ class ModelPlugin {
         this.lastRequestStartTime = new Date();
         const logMessage = `>>> [${this.requestId}: ${this.pathwayName}.${this.requestCount}] request`;
         const header = '>'.repeat(logMessage.length);
-        console.log(`\n${header}\n${logMessage}`);
-        console.log(`>>> Making API request to ${url}`);
+        logger.info(`${header}`);
+        logger.info(`${logMessage}`);
+        logger.info(`>>> Making API request to ${url}`);
     }
 
     logAIRequestFinished() {
@@ -233,7 +235,8 @@ class ModelPlugin {
         const timeElapsed = (currentTime - this.lastRequestStartTime) / 1000;
         const logMessage = `<<< [${this.requestId}: ${this.pathwayName}] response - complete in ${timeElapsed}s - data:`;
         const header = '<'.repeat(logMessage.length);
-        console.log(`\n${header}\n${logMessage}\n`);
+        logger.info(`${header}`);
+        logger.info(`${logMessage}`);
     }
 
     logRequestData(data, responseData, prompt) {
@@ -241,10 +244,15 @@ class ModelPlugin {
         const modelInput = data.prompt || (data.messages && data.messages[0].content) || (data.length > 0 && data[0].Text) || null;
     
         if (modelInput) {
-            console.log(`\x1b[36m${modelInput}\x1b[0m`);
+            const inputTokens = encode(modelInput).length;
+            logger.info(`[request sent containing ${inputTokens} tokens]`);
+            logger.debug(`${modelInput}`);
         }
     
-        console.log(`\x1b[34m> ${JSON.stringify(this.parseResponse(responseData))}\x1b[0m`);
+        const responseText = JSON.stringify(this.parseResponse(responseData));
+        const responseTokens = encode(responseText).length;
+        logger.info(`[response received containing ${responseTokens} tokens]`);
+        logger.debug(`${responseText}`);
     
         prompt && prompt.debugInfo && (prompt.debugInfo += `\n${JSON.stringify(data)}`);
     }
@@ -264,7 +272,8 @@ class ModelPlugin {
             return this.parseResponse(responseData);
         } catch (error) {
             // Log the error and continue
-            console.error(error);
+            logger.error(error.message || error);
+            throw error;
         }
     }
 

package/server/plugins/openAiChatPlugin.js

@@ -1,6 +1,7 @@
 // OpenAIChatPlugin.js
 import ModelPlugin from './modelPlugin.js';
 import { encode } from 'gpt-3-encoder';
+import logger from '../../lib/logger.js';
 
 class OpenAIChatPlugin extends ModelPlugin {
     constructor(config, pathway, modelName, model) {
@@ -110,6 +111,8 @@ class OpenAIChatPlugin extends ModelPlugin {
     
         const { stream, messages } = data;
         if (messages && messages.length > 1) {
+            logger.info(`[chat request sent containing ${messages.length} messages]`);
+            let totalTokens = 0;
             messages.forEach((message, index) => {
                 //message.content string or array
                 const content = Array.isArray(message.content) ? message.content.map(item => JSON.stringify(item)).join(', ') : message.content;
@@ -117,16 +120,25 @@ class OpenAIChatPlugin extends ModelPlugin {
                 const tokenCount = encode(content).length;
                 const preview = words.length < 41 ? content : words.slice(0, 20).join(" ") + " ... " + words.slice(-20).join(" ");
     
-                console.log(`\x1b[36mMessage ${index + 1}: Role: ${message.role}, Tokens: ${tokenCount}, Content: "${preview}"\x1b[0m`);
+                logger.debug(`Message ${index + 1}: Role: ${message.role}, Tokens: ${tokenCount}, Content: "${preview}"`);
+                totalTokens += tokenCount;
             });
+            logger.info(`[chat request contained ${totalTokens} tokens]`);
         } else {
-            console.log(`\x1b[36m${messages[0].content}\x1b[0m`);
+            const message = messages[0];
+            const content = Array.isArray(message.content) ? message.content.map(item => JSON.stringify(item)).join(', ') : message.content;
+            const tokenCount = encode(content).length;
+            logger.info(`[request sent containing ${tokenCount} tokens]`);
+            logger.debug(`${content}`);
         }
     
         if (stream) {
-            console.log(`\x1b[34m> [response is an SSE stream]\x1b[0m`);
+            logger.info(`[response received as an SSE stream]`);
         } else {
-            console.log(`\x1b[34m> ${this.parseResponse(responseData)}\x1b[0m`);
+            const responseText = this.parseResponse(responseData);
+            const responseTokens = encode(responseText).length;
+            logger.info(`[response received containing ${responseTokens} tokens]`);
+            logger.debug(`${responseText}`);
         }
 
         prompt && prompt.debugInfo && (prompt.debugInfo += `\n${JSON.stringify(data)}`);

package/server/plugins/openAiCompletionPlugin.js

@@ -3,6 +3,7 @@
 import { request } from 'https';
 import ModelPlugin from './modelPlugin.js';
 import { encode } from 'gpt-3-encoder';
+import logger from '../../lib/logger.js';
 
 // Helper function to truncate the prompt if it is too long
 const truncatePromptIfNecessary = (text, textTokenCount, modelMaxTokenCount, targetTextTokenCount, pathwayResolver) => {
@@ -112,12 +113,17 @@ class OpenAICompletionPlugin extends ModelPlugin {
         const stream = data.stream;
         const modelInput = data.prompt;
     
-        console.log(`\x1b[36m${modelInput}\x1b[0m`);
+        const modelInputTokens = encode(modelInput).length;
+        logger.info(`[request sent containing ${modelInputTokens} tokens]`);
+        logger.debug(`${modelInput}`);
 
         if (stream) {
-            console.log(`\x1b[34m> [response is an SSE stream]\x1b[0m`);
+            logger.info(`[response received as an SSE stream]`);
         } else {
-            console.log(`\x1b[34m> ${this.parseResponse(responseData)}\x1b[0m`);
+            const responseText = this.parseResponse(responseData);
+            const responseTokens = encode(responseText).length;
+            logger.info(`[response received containing ${responseTokens} tokens]`);
+            logger.debug(`${responseText}`);
         }
     
         prompt && prompt.debugInfo && (prompt.debugInfo += `\n${JSON.stringify(data)}`);

package/server/plugins/openAiDallE3Plugin.js

@@ -1,7 +1,8 @@
 import RequestDurationEstimator from '../../lib/requestDurationEstimator.js';
-import pubsub from '../pubsub.js';
 import ModelPlugin from './modelPlugin.js';
 import { request } from '../../lib/request.js';
+import { publishRequestProgress } from '../../lib/redisSubscription.js';
+import logger from '../../lib/logger.js';
 
 const requestDurationEstimator = new RequestDurationEstimator(10);
 
@@ -30,7 +31,7 @@ class OpenAIDallE3Plugin extends ModelPlugin {
             return this.parseResponse(responseData);
         } catch (error) {
             // Log the error and continue
-            console.error(error);
+            logger.error(error.message || error);
         }
     }
 
@@ -83,7 +84,7 @@ class OpenAIDallE3Plugin extends ModelPlugin {
 
             state.status = status;
             requestDurationEstimator.endRequest();
-            pubsub.publish("REQUEST_PROGRESS", { requestProgress });
+            publishRequestProgress(requestProgress);
         }
 
         // publish an update every 2 seconds, using the request duration estimator to calculate
@@ -92,14 +93,12 @@ class OpenAIDallE3Plugin extends ModelPlugin {
             let progress =
                 requestDurationEstimator.calculatePercentComplete();
 
-            pubsub.publish('REQUEST_PROGRESS', {
-                requestProgress: {
+                await publishRequestProgress({
                     requestId,
                     status: "pending",
                     progress,
                     data,
-                }
-            });
+                });
 
             if (state.status !== "pending") {
                 break;

package/server/plugins/openAiImagePlugin.js

@@ -1,10 +1,9 @@
 // OpenAIImagePlugin.js
-import FormData from 'form-data';
-import { config } from '../../config.js';
 import ModelPlugin from './modelPlugin.js';
-import pubsub from '../pubsub.js';
 import axios from 'axios';
 import RequestDurationEstimator from '../../lib/requestDurationEstimator.js';
+import { publishRequestProgress } from '../../lib/redisSubscription.js';
+import logger from '../../lib/logger.js';
 
 const requestDurationEstimator = new RequestDurationEstimator(10);
 
@@ -26,7 +25,7 @@ class OpenAIImagePlugin extends ModelPlugin {
             id = (await this.executeRequest(url, data, {}, { ...this.model.headers }, {}, requestId, pathway))?.id;
         } catch (error) {
             const errMsg = `Error generating image: ${error?.message || JSON.stringify(error)}`;
-            console.error(errMsg);
+            logger.error(errMsg);
             return errMsg;
         }
 
@@ -59,13 +58,11 @@ class OpenAIImagePlugin extends ModelPlugin {
                 data = JSON.stringify(response);
             }
 
-            pubsub.publish('REQUEST_PROGRESS', {
-                requestProgress: {
+            await publishRequestProgress({
                     requestId,
                     status,
                     progress,
                     data,
-                }
             });
 
             if (status === "succeeded") {

package/server/plugins/openAiWhisperPlugin.js

@@ -2,7 +2,6 @@
 import ModelPlugin from './modelPlugin.js';
 import FormData from 'form-data';
 import fs from 'fs';
-import pubsub from '../pubsub.js';
 import { axios } from '../../lib/request.js';
 import stream from 'stream';
 import os from 'os';
@@ -14,8 +13,10 @@ import http from 'http';
 import https from 'https';
 import { promisify } from 'util';
 import subsrt from 'subsrt';
-const pipeline = promisify(stream.pipeline);
+import { publishRequestProgress } from '../../lib/redisSubscription.js';
+import logger from '../../lib/logger.js';
 
+const pipeline = promisify(stream.pipeline);
 
 const API_URL = config.get('whisperMediaApiUrl');
 const WHISPER_TS_API_URL  = config.get('whisperTSApiUrl');
@@ -47,7 +48,7 @@ function alignSubtitles(subtitles, format) {
             }
         }
     } catch (error) {
-        console.error("An error occurred in content text parsing: ", error);
+        logger.error(`An error occurred in content text parsing: ${error}`);
     }
     
     return subsrt.build(result, { format: format === 'vtt' ? 'vtt' : 'srt' });
@@ -80,7 +81,7 @@ const downloadFile = async (fileUrl) => {
             });
 
             await pipeline(response, fs.createWriteStream(localFilePath));
-            console.log(`Downloaded file to ${localFilePath}`);
+            logger.info(`Downloaded file to ${localFilePath}`);
             resolve(localFilePath);
         } catch (error) {
             fs.unlink(localFilePath, () => {
@@ -103,11 +104,11 @@ class OpenAIWhisperPlugin extends ModelPlugin {
                 const res = await axios.get(API_URL, { params: { uri: file, requestId } });
                 return res.data;
             } else {
-                console.log(`No API_URL set, returning file as chunk`);
+                logger.info(`No API_URL set, returning file as chunk`);
                 return [file];
             }
         } catch (err) {
-            console.log(`Error getting media chunks list from api:`, err);
+            logger.error(`Error getting media chunks list from api:`, err);
             throw err;
         }
     }
@@ -117,11 +118,11 @@ class OpenAIWhisperPlugin extends ModelPlugin {
             if (API_URL) {
                 //call helper api to mark processing as completed
                 const res = await axios.delete(API_URL, { params: { requestId } });
-                console.log(`Marked request ${requestId} as completed:`, res.data);
+                logger.info(`Marked request ${requestId} as completed: ${res.data}`);
                 return res.data;
             }
         } catch (err) {
-            console.log(`Error marking request ${requestId} as completed:`, err);
+            logger.error(`Error marking request ${requestId} as completed: ${err}`);
         }
     }
 
@@ -149,7 +150,7 @@ class OpenAIWhisperPlugin extends ModelPlugin {
                     const res = await this.executeRequest(WHISPER_TS_API_URL, tsparams, {}, {}, {}, requestId, pathway);
                     return res;
                 } catch (err) {
-                    console.log(`Error getting word timestamped data from api:`, err);
+                    logger.error(`Error getting word timestamped data from api: ${err}`);
                     throw err;
                 }
             }
@@ -169,7 +170,7 @@ class OpenAIWhisperPlugin extends ModelPlugin {
 
                 return this.executeRequest(url, formData, params, { ...this.model.headers, ...formData.getHeaders() }, {}, requestId, pathway);
             } catch (err) {
-                console.log(err);
+                logger.error(err);
                 throw err;
             }
         }
@@ -183,13 +184,12 @@ class OpenAIWhisperPlugin extends ModelPlugin {
         const sendProgress = () => {
             completedCount++;
             if (completedCount >= totalCount) return;
-            pubsub.publish('REQUEST_PROGRESS', {
-                requestProgress: {
+            publishRequestProgress({
                     requestId,
                     progress: completedCount / totalCount,
                     data: null,
-                }
             });
+            
         }
 
         let chunks = []; // array of local file paths
@@ -225,7 +225,7 @@ class OpenAIWhisperPlugin extends ModelPlugin {
 
         } catch (error) {
             const errMsg = `Transcribe error: ${error?.message || JSON.stringify(error)}`;
-            console.error(errMsg);
+            logger.error(errMsg);
             return errMsg;
         }
         finally {
@@ -242,11 +242,11 @@ class OpenAIWhisperPlugin extends ModelPlugin {
                 if (match && match[1]) {
                     const extractedValue = match[1];
                     await this.markCompletedForCleanUp(extractedValue);
-                    console.log(`Cleaned temp whisper file ${file} with request id ${extractedValue}`);
+                    logger.info(`Cleaned temp whisper file ${file} with request id ${extractedValue}`);
                 }
 
             } catch (error) {
-                console.error("An error occurred while deleting:", error);
+                logger.error(`An error occurred while deleting: ${error}`);
             }
         }
 

package/server/plugins/palmChatPlugin.js

@@ -2,6 +2,7 @@
 import ModelPlugin from './modelPlugin.js';
 import { encode } from 'gpt-3-encoder';
 import HandleBars from '../../lib/handleBars.js';
+import logger from '../../lib/logger.js';
 
 class PalmChatPlugin extends ModelPlugin {
     constructor(config, pathway, modelName, model) {
@@ -189,33 +190,40 @@ class PalmChatPlugin extends ModelPlugin {
         const { context, examples } = instances && instances [0] || {};
     
         if (context) {
-            console.log(`\x1b[36mContext: ${context}\x1b[0m`);
+            const contextLength = encode(context).length;
+            logger.info(`[chat request contains context information of length ${contextLength} tokens]`)
+            logger.debug(`Context: ${context}`);
         }
 
         if (examples && examples.length) {
+            logger.info(`[chat request contains ${examples.length} examples]`);
             examples.forEach((example, index) => {
-                console.log(`\x1b[36mExample ${index + 1}: Input: "${example.input.content}", Output: "${example.output.content}"\x1b[0m`);
+                logger.debug(`Example ${index + 1}: Input: "${example.input.content}", Output: "${example.output.content}"`);
             });
         }
         
         if (messages && messages.length > 1) {
+            logger.info(`[chat request contains ${messages.length} messages]`);
             messages.forEach((message, index) => {
                 const words = message.content.split(" ");
                 const tokenCount = encode(message.content).length;
                 const preview = words.length < 41 ? message.content : words.slice(0, 20).join(" ") + " ... " + words.slice(-20).join(" ");
     
-                console.log(`\x1b[36mMessage ${index + 1}: Author: ${message.author}, Tokens: ${tokenCount}, Content: "${preview}"\x1b[0m`);
+                logger.debug(`Message ${index + 1}: Author: ${message.author}, Tokens: ${tokenCount}, Content: "${preview}"`);
             });
         } else if (messages && messages.length === 1) {
-            console.log(`\x1b[36m${messages[0].content}\x1b[0m`);
+            logger.debug(`${messages[0].content}`);
         }
 
         const safetyAttributes = this.getSafetyAttributes(responseData);
 
-        console.log(`\x1b[34m> ${this.parseResponse(responseData)}\x1b[0m`);
+        const responseText = this.parseResponse(responseData);
+        const responseTokens = encode(responseText).length;
+        logger.info(`[response received containing ${responseTokens} tokens]`);
+        logger.debug(`${responseText}`);
 
         if (safetyAttributes) {
-            console.log(`\x1b[33mSafety Attributes: ${JSON.stringify(safetyAttributes, null, 2)}\x1b[0m`);
+            logger.warn(`[response contains safety attributes: ${JSON.stringify(safetyAttributes, null, 2)}]`);
         }
     
         if (prompt && prompt.debugInfo) {

package/server/plugins/palmCompletionPlugin.js

@@ -1,6 +1,8 @@
 // palmCompletionPlugin.js
 
 import ModelPlugin from './modelPlugin.js';
+import { encode } from 'gpt-3-encoder';
+import logger from '../../lib/logger.js';
 
 // PalmCompletionPlugin class for handling requests and responses to the PaLM API Text Completion API
 class PalmCompletionPlugin extends ModelPlugin {
@@ -114,13 +116,18 @@ class PalmCompletionPlugin extends ModelPlugin {
         const modelInput = instances && instances[0] && instances[0].prompt;
 
         if (modelInput) {
-            console.log(`\x1b[36m${modelInput}\x1b[0m`);
+            const inputTokens = encode(modelInput).length;
+            logger.info(`[request sent containing ${inputTokens} tokens]`);
+            logger.debug(`${modelInput}`);
         }
 
-        console.log(`\x1b[34m> ${this.parseResponse(responseData)}\x1b[0m`);
+        const responseText = this.parseResponse(responseData);
+        const responseTokens = encode(responseText).length;
+        logger.info(`[response received containing ${responseTokens} tokens]`);
+        logger.debug(`${responseText}`);
 
         if (safetyAttributes) {
-            console.log(`\x1b[33mSafety Attributes: ${JSON.stringify(safetyAttributes, null, 2)}\x1b[0m`);
+            logger.warn(`[response contains safety attributes: ${JSON.stringify(safetyAttributes, null, 2)}]`);
         }
 
         if (prompt && prompt.debugInfo) {

package/server/pubsub.js

@@ -1,4 +1,5 @@
 import { PubSub } from 'graphql-subscriptions';
 const pubsub = new PubSub();
+pubsub.ee.setMaxListeners(300);
 
 export default pubsub;

package/server/rest.js

@@ -5,6 +5,7 @@ import { json } from 'express';
 import pubsub from './pubsub.js';
 import { requestState } from './requestState.js';
 import { v4 as uuidv4 } from 'uuid';
+import logger from '../lib/logger.js';
 
 
 const processRestRequest = async (server, req, pathway, name, parameterMap = {}) => {
@@ -85,7 +86,7 @@ const processIncomingStream = (requestId, res, jsonResponse) => {
     }
 
     const sendStreamData = (data) => {
-        //console.log(`REST SEND: data: ${JSON.stringify(data)}`);
+        //logger.info(`REST SEND: data: ${JSON.stringify(data)}`);
         const dataString = (data==='[DONE]') ? data : JSON.stringify(data);
 
         if (!res.writableEnded) {
@@ -116,13 +117,13 @@ const processIncomingStream = (requestId, res, jsonResponse) => {
                 try {
                     pubsub.unsubscribe(await subscription);
                 } catch (error) {
-                    console.error(`Error unsubscribing from pubsub: ${error}`);
+                    logger.error(`Error unsubscribing from pubsub: ${error}`);
                 }
             }
         }
 
         if (data.requestProgress.requestId === requestId) {
-            //console.log(`REQUEST_PROGRESS received progress: ${data.requestProgress.progress}, data: ${data.requestProgress.data}`);
+            //logger.info(`REQUEST_PROGRESS received progress: ${data.requestProgress.progress}, data: ${data.requestProgress.data}`);
             
             const progress = data.requestProgress.progress;
             const progressData = data.requestProgress.data;
@@ -130,7 +131,7 @@ const processIncomingStream = (requestId, res, jsonResponse) => {
             try {
                 const messageJson = JSON.parse(progressData);
                 if (messageJson.error) {
-                    console.error(`Stream error REST:`, messageJson?.error?.message);
+                    logger.error(`Stream error REST: ${messageJson?.error?.message || 'unknown error'}`);
                     safeUnsubscribe();
                     finishStream(res, jsonResponse);
                     return;
@@ -146,7 +147,7 @@ const processIncomingStream = (requestId, res, jsonResponse) => {
                     fillJsonResponse(jsonResponse, messageJson, null);
                 }
             } catch (error) {
-                //console.log(`progressData not JSON: ${progressData}`);
+                //logger.info(`progressData not JSON: ${progressData}`);
                 fillJsonResponse(jsonResponse, progressData, "stop");
             }
             if (progress === 1 && progressData.trim() === "[DONE]") {
@@ -165,7 +166,7 @@ const processIncomingStream = (requestId, res, jsonResponse) => {
     });
 
     // Fire the resolver for the async requestProgress
-    console.log(`Rest Endpoint starting async requestProgress, requestId: ${requestId}`);
+    logger.info(`Rest Endpoint starting async requestProgress, requestId: ${requestId}`);
     const { resolver, args } = requestState[requestId];
     resolver(args);
 

package/server/subscriptions.js

@@ -1,25 +1,13 @@
-// TODO: Replace PubSub class with PubSub engine to support
-//       multi-server instance
-// See https://www.apollographql.com/docs/apollo-server/v3/data/subscriptions/#resolving-a-subscription
-
 import pubsub from './pubsub.js';
-
+import logger from '../lib/logger.js';
 import { withFilter } from 'graphql-subscriptions';
-import { requestState } from './requestState.js';
+import { publishRequestProgressSubscription } from '../lib/redisSubscription.js';
 
 const subscriptions = {
     requestProgress: {
         subscribe: withFilter(
             (_, args, __, _info) => {
-                const { requestIds } = args;
-                for (const requestId of requestIds) {
-                    if (requestState[requestId] && !requestState[requestId].started) {
-                        requestState[requestId].started = true;
-                        console.log(`Subscription starting async requestProgress, requestId: ${requestId}`);
-                        const { resolver, args } = requestState[requestId];
-                        resolver(args);
-                    }
-                }
+                publishRequestProgressSubscription(args.requestIds);
                 return pubsub.asyncIterator(['REQUEST_PROGRESS'])
             },
             (payload, variables) => {

package/tests/palmChatPlugin.test.js

@@ -217,41 +217,3 @@ test('parseResponse', (t) => {
 
   t.is(palmChatPlugin.parseResponse(responseData), expectedResult);
 });
-
-test('logRequestData', (t) => {
-  const { palmChatPlugin } = t.context;
-  const data = {
-    instances: [
-      {
-        messages: [
-          { author: 'user', content: 'Hello' },
-          { author: 'assistant', content: 'How can I help you?' },
-        ],
-      },
-    ],
-  };
-  const responseData = {
-    predictions: [
-      {
-        candidates: [
-          {
-            content: 'Hello, how can I help you today?',
-          },
-        ],
-      },
-    ],
-  };
-  const prompt = { debugInfo: '' };
-
-  const consoleLog = console.log;
-  let logOutput = '';
-  console.log = (msg) => (logOutput += msg + '\n');
-
-  palmChatPlugin.logRequestData(data, responseData, prompt);
-
-  console.log = consoleLog;
-
-  t.true(logOutput.includes('Message 1:'));
-  t.true(logOutput.includes('Message 2:'));
-  t.true(logOutput.includes('> Hello, how can I help you today?'));
-});

package/tests/palmCompletionPlugin.test.js

@@ -56,33 +56,3 @@ test('getSafetyAttributes', (t) => {
 
   t.deepEqual(palmCompletionPlugin.getSafetyAttributes(responseData), expectedResult);
 });
-
-test('logRequestData', (t) => {
-  const { palmCompletionPlugin } = t.context;
-  const data = {
-    instances: [
-      {
-        prompt: 'Hello, how can I help you?',
-      },
-    ],
-  };
-  const responseData = {
-    predictions: [
-      {
-        content: 'Hello, how can I help you today?',
-      },
-    ],
-  };
-  const prompt = { debugInfo: '' };
-
-  const consoleLog = console.log;
-  let logOutput = '';
-  console.log = (msg) => (logOutput += msg + '\n');
-
-  palmCompletionPlugin.logRequestData(data, responseData, prompt);
-
-  console.log = consoleLog;
-
-  t.true(logOutput.includes('Hello, how can I help you?'));
-  t.true(logOutput.includes('> Hello, how can I help you today?'));
-});