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

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',
@@ -168,6 +174,12 @@ var config = convict({
         sensitive: true,
         env: 'STORAGE_CONNECTION_STRING'
     },
+    redisEncryptionKey: {
+        format: String,
+        default: null,
+        env: 'REDIS_ENCRYPTION_KEY',
+        sensitive: true
+    },
     dalleImageApiUrl: {
         format: String,
         default: 'null',
@@ -195,14 +207,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 +237,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 +277,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/crypto.js

@@ -0,0 +1,46 @@
+// This file is used to encrypt and decrypt data using the crypto library
+import logger from './logger.js';
+import crypto from 'crypto';
+
+// Encryption function
+function encrypt(text, key) {
+    if (!key) { return text; }
+    try {
+        key = tryBufferKey(key);
+        let iv = crypto.randomBytes(16);
+        let cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
+        let encrypted = cipher.update(text, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        return iv.toString('hex') + ':' + encrypted;
+    } catch (error) {
+        logger.error(`Encryption failed: ${error.message}`);
+        return null;
+    }
+}
+
+// Decryption function
+function decrypt(message, key) {
+    if (!key) { return message; }
+    try {
+        key = tryBufferKey(key);
+        let parts = message.split(':');
+        let iv = Buffer.from(parts.shift(), 'hex');
+        let encrypted = parts.join(':');
+        let decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
+        let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+    } catch (error) {
+        logger.error(`Decryption failed: ${error.message}`);
+        return null;
+    }
+}
+
+function tryBufferKey(key) {
+    if (key.length === 64) {
+        return Buffer.from(key, 'hex');
+    }   
+    return key;
+}
+
+export { encrypt, decrypt };

package/lib/keyValueStorageClient.js

@@ -1,15 +1,32 @@
 import Keyv from 'keyv';
 import { config } from '../config.js';
+import { encrypt, decrypt } from './crypto.js';
+import logger from './logger.js';
 
 const storageConnectionString = config.get('storageConnectionString');
 const cortexId = config.get('cortexId');
+const redisEncryptionKey = config.get('redisEncryptionKey');
 
 // Create a keyv client to store data
 const keyValueStorageClient = new Keyv(storageConnectionString, {
     ssl: true,
     abortConnect: false,
-    serialize: JSON.stringify,
-    deserialize: JSON.parse,
+    serialize: (data) => redisEncryptionKey ? encrypt(JSON.stringify(data), redisEncryptionKey) : JSON.stringify(data),
+    deserialize: (data) => {
+        try {
+            // Try to parse the data normally
+            return JSON.parse(data);
+        } catch (error) {
+            // If it fails, the data may be encrypted so attempt to decrypt it if we have a key
+            try {
+                return JSON.parse(decrypt(data, redisEncryptionKey));
+            } catch (decryptError) {
+                // If decryption also fails, log an error and return an empty object
+                logger.error(`Failed to parse or decrypt stored key value data: ${decryptError}`);
+                return {};
+            }
+        }
+    },
     namespace: `${cortexId}-cortex-context`
 });
 

package/lib/logger.js

@@ -0,0 +1,48 @@
+// logger.js
+import winston from 'winston';
+
+winston.addColors({
+    debug: 'green',
+    verbose: 'blue',
+    http: 'gray',
+    info: 'cyan',
+    warn: 'yellow',
+    error: 'red'
+});
+
+const debugFormat = winston.format.combine(
+    winston.format.colorize({ all: true }),
+    winston.format.cli()
+);
+
+const prodFormat = winston.format.combine(
+    winston.format.simple()
+);
+
+const transports = process.env.NODE_ENV === 'production' ?
+    new winston.transports.Console({ level: 'info', format: prodFormat }) :
+    new winston.transports.Console({ level: 'debug', format: debugFormat });
+
+const logger = winston.createLogger({ transports });
+
+// Function to obscure sensitive URL parameters
+export const obscureUrlParams = url => {
+    try {
+        const urlObject = new URL(url);
+        urlObject.searchParams.forEach((value, name) => {
+            if (/token|key|password|secret|auth|apikey|access|passwd|credential/i.test(name)) {
+                urlObject.searchParams.set(name, '******');
+            }
+        });
+        return urlObject.toString();
+    } catch (e) {
+        if (e instanceof TypeError) {
+            logger.error('Error obscuring URL parameters - invalid URL.');
+            return url;
+        } else {
+            throw e;
+        }
+    }
+};
+
+export default logger;

package/lib/redisSubscription.js

@@ -1,63 +1,154 @@
 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';
+import { encrypt, decrypt } from '../lib/crypto.js';
 
 const connectionString = config.get('storageConnectionString');
-const channel = 'requestProgress';
-let client;
+const redisEncryptionKey = config.get('redisEncryptionKey');
+const requestProgressChannel = 'requestProgress';
+const requestProgressSubscriptionsChannel = 'requestProgressSubscriptions';
+
+let subscriptionClient;
+let publisherClient;
 
 if (connectionString) {
-    console.log(`Using Redis subscription for channel ${channel}`);
+    logger.info(`Using Redis subscription for channel(s) ${requestProgressChannel}, ${requestProgressSubscriptionsChannel}`);
+    try {
+        subscriptionClient = connectionString && new Redis(connectionString);
+    } catch (error) {
+        logger.error(`Redis connection error: ${error}`);
+    }
+
+    logger.info(`Using Redis publish for channel(s) ${requestProgressChannel}, ${requestProgressSubscriptionsChannel}`);
     try {
-        client = connectionString && new Redis(connectionString);
+        publisherClient = connectionString && new Redis(connectionString);
     } catch (error) {
-        console.error('Redis connection error: ', error);
+        logger.error(`Redis connection error: ${error}`);
+    }
+
+    if (redisEncryptionKey) {
+        logger.info('Using encryption for Redis');
+    } else {
+        logger.warn('REDIS_ENCRYPTION_KEY not set. Data stored in Redis will not be encrypted.');
     }
 
-    if (client) {
-        const channel = 'requestProgress';
+    if (subscriptionClient) {
 
-        client.on('error', (error) => {
-            console.error(`Redis client error: ${error}`);
+        subscriptionClient.on('error', (error) => {
+            logger.error(`Redis subscriptionClient error: ${error}`);
         });
 
-        client.on('connect', () => {
-            client.subscribe(channel, (error) => {
-                if (error) {
-                    console.error(`Error subscribing to channel ${channel}: ${error}`);
-                } else {
-                    console.log(`Subscribed to channel ${channel}`);
-                }
+        subscriptionClient.on('connect', () => {
+            const channels = [requestProgressChannel, requestProgressSubscriptionsChannel];
+
+            channels.forEach(channel => {
+                subscriptionClient.subscribe(channel, (error) => {
+                    if (error) {
+                        logger.error(`Error subscribing to redis channel ${channel}: ${error}`);
+                    } else {
+                        logger.info(`Subscribed to channel ${channel}`);
+                    }
+                });
             });
         });
 
-        client.on('message', (channel, message) => {
-            if (channel === 'requestProgress') {
-                console.log(`Received message from ${channel}: ${message}`);
-                let parsedMessage;
+        subscriptionClient.on('message', (channel, message) => {
+            logger.debug(`Received message from ${channel}: ${message}`);
+            
+            let decryptedMessage = message;
 
+            if (channel === requestProgressChannel && redisEncryptionKey) {
                 try {
-                    parsedMessage = JSON.parse(message);
+                    decryptedMessage = decrypt(message, redisEncryptionKey);
                 } catch (error) {
-                    parsedMessage = message;
+                    logger.error(`Error decrypting message: ${error}`);
                 }
-
-                handleMessage(parsedMessage);
             }
-        });
 
-        const handleMessage = (data) => {
-            // Process the received data
-            console.log('Processing data:', data);
+            let parsedMessage = decryptedMessage;
             try {
-                pubsub.publish('REQUEST_PROGRESS', { requestProgress: data });
+                parsedMessage = JSON.parse(decryptedMessage);
             } catch (error) {
-                console.error(`Error publishing data to pubsub: ${error}`);
+                logger.error(`Error parsing message: ${error}`);
+            }
+
+            switch(channel) {
+                case requestProgressChannel:
+                    pubsubHandleMessage(parsedMessage);
+                    break;
+                case requestProgressSubscriptionsChannel:
+                    handleSubscription(parsedMessage);
+                    break;
+                default:
+                    logger.error(`Unsupported channel: ${channel}`);
+                    break;
             }
-        };
+        });
+    }   
+} else {
+    // No Redis connection, use pubsub for communication
+    logger.info(`Using pubsub publish for channel ${requestProgressChannel}`);
+}
+
+async function publishRequestProgress(data) {
+    if (publisherClient) {
+        try {
+            let message = JSON.stringify(data);
+            if (redisEncryptionKey) {
+                try {
+                    message = encrypt(message, redisEncryptionKey);
+                } catch (error) {
+                    logger.error(`Error encrypting message: ${error}`);
+                }
+            }
+            logger.debug(`Publishing message ${message} to channel ${requestProgressChannel}`);
+            await publisherClient.publish(requestProgressChannel, message);
+        } catch (error) {
+            logger.error(`Error publishing message: ${error}`);
+        }
+    } else {
+        pubsubHandleMessage(data);
+    }
+}
+
+async function publishRequestProgressSubscription(data) {
+    if (publisherClient) {
+        try {
+            const message = JSON.stringify(data);
+            logger.debug(`Publishing message ${message} to channel ${requestProgressSubscriptionsChannel}`);
+            await publisherClient.publish(requestProgressSubscriptionsChannel, message);
+        } catch (error) {
+            logger.error(`Error publishing message: ${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: ${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,
+    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();
@@ -240,16 +241,16 @@ const request = async (params, model, requestId, pathway) => {
         const response = await postRequest(params, model, requestId, pathway);
         const { error, data, cached } = response;
         if (cached) {
-            console.info(`<<< [${requestId}] served with cached response.`);
+            logger.info(`<<< [${requestId}] served with cached response.`);
         }
         if (error && error.length > 0) {
             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.1",
   "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/parser.js

@@ -1,3 +1,5 @@
+import logger from '../lib/logger.js';
+
 //simply trim and parse with given regex
 const regexParser = (text, regex) => {
     return text.trim().split(regex).map(s => s.trim()).filter(s => s.length);
@@ -25,7 +27,7 @@ const parseNumberedObjectList = (text, format) => {
             }
             result.push(obj);
         } catch (e) {
-            console.warn(`Failed to parse value in parseNumberedObjectList, value: ${value}, fields: ${fields}`);
+            logger.warn(`Failed to parse value in parseNumberedObjectList, value: ${value}, fields: ${fields}`);
         }
     }