PINO JSON logging

packages/api/src/controllers/archive.js

@@ -6,6 +6,9 @@ const socket = require('../utility/socket');
 const { saveFreeTableData } = require('../utility/freeTableStorage');
 const loadFilesRecursive = require('../utility/loadFilesRecursive');
 const getJslFileName = require('../utility/getJslFileName');
+const { getLogger } = require('dbgate-tools');
+
+const logger = getLogger();
 
 module.exports = {
   folders_meta: true,
@@ -68,7 +71,7 @@ module.exports = {
         ...fileType('.matview.sql', 'matview.sql'),
       ];
     } catch (err) {
-      console.log('Error reading archive files', err.message);
+      logger.error('Error reading archive files', err.message);
       return [];
     }
   },

packages/api/src/controllers/auth.js

@@ -3,8 +3,11 @@ const jwt = require('jsonwebtoken');
 const getExpressPath = require('../utility/getExpressPath');
 const uuidv1 = require('uuid/v1');
 const { getLogins } = require('../utility/hasPermission');
+const { getLogger } = require('dbgate-tools');
 const AD = require('activedirectory2').promiseWrapper;
 
+const logger = getLogger();
+
 const tokenSecret = uuidv1();
 
 function shouldAuthorizeApi() {
@@ -51,7 +54,7 @@ function authMiddleware(req, res, next) {
       return next();
     }
 
-    console.log('Sending invalid token error', err.message);
+    logger.error('Sending invalid token error', err.message);
 
     return unauthorizedResponse(req, res, 'invalid token');
   }
@@ -74,7 +77,7 @@ module.exports = {
 
     const payload = jwt.decode(access_token);
 
-    console.log('User payload returned from OAUTH:', payload);
+    logger.info({ payload }, 'User payload returned from OAUTH');
 
     const login =
       process.env.OAUTH_LOGIN_FIELD && payload && payload[process.env.OAUTH_LOGIN_FIELD]
@@ -122,7 +125,7 @@ module.exports = {
           accessToken: jwt.sign({ login }, tokenSecret, { expiresIn: getTokenLifetime() }),
         };
       } catch (err) {
-        console.log('Failed active directory authentization', err.message);
+        logger.error('Failed active directory authentization', err);
         return {
           error: err.message,
         };

packages/api/src/controllers/connections.js

@@ -12,10 +12,12 @@ const { pickSafeConnectionInfo } = require('../utility/crypting');
 const JsonLinesDatabase = require('../utility/JsonLinesDatabase');
 
 const processArgs = require('../utility/processArgs');
-const { safeJsonParse } = require('dbgate-tools');
+const { safeJsonParse, getLogger } = require('dbgate-tools');
 const platformInfo = require('../utility/platformInfo');
 const { connectionHasPermission, testConnectionPermission } = require('../utility/hasPermission');
 
+const logger = getLogger();
+
 let volatileConnections = {};
 
 function getNamedArgs() {
@@ -86,13 +88,13 @@ function getPortalCollections() {
       sslKeyFile: process.env[`SSL_KEY_FILE_${id}`],
       sslRejectUnauthorized: process.env[`SSL_REJECT_UNAUTHORIZED_${id}`],
     }));
-    console.log('Using connections from ENV variables:');
-    console.log(JSON.stringify(connections.map(pickSafeConnectionInfo), undefined, 2));
+
+    logger.info({ connections: connections.map(pickSafeConnectionInfo) }, 'Using connections from ENV variables');
     const noengine = connections.filter(x => !x.engine);
     if (noengine.length > 0) {
-      console.log(
-        'Warning: Invalid CONNECTIONS configutation, missing ENGINE for connection ID:',
-        noengine.map(x => x._id)
+      logger.warn(
+        { connections: noengine.map(x => x._id) },
+        'Invalid CONNECTIONS configutation, missing ENGINE for connection ID'
       );
     }
     return connections;

packages/api/src/controllers/databaseConnections.js

@@ -12,6 +12,7 @@ const {
   matchPairedObjects,
   extendDatabaseInfo,
   modelCompareDbDiffOptions,
+  getLogger,
 } = require('dbgate-tools');
 const { html, parse } = require('diff2html');
 const { handleProcessCommunication } = require('../utility/processComm');
@@ -29,6 +30,8 @@ const processArgs = require('../utility/processArgs');
 const { testConnectionPermission } = require('../utility/hasPermission');
 const { MissingCredentialsError } = require('../utility/exceptions');
 
+const logger = getLogger();
+
 module.exports = {
   /** @type {import('dbgate-types').OpenedDatabaseConnection[]} */
   opened: [],
@@ -60,7 +63,7 @@ module.exports = {
 
   handle_error(conid, database, props) {
     const { error } = props;
-    console.log(`Error in database connection ${conid}, database ${database}: ${error}`);
+    logger.error(`Error in database connection ${conid}, database ${database}: ${error}`);
   },
   handle_response(conid, database, { msgid, ...response }) {
     const [resolve, reject] = this.requests[msgid];
@@ -137,7 +140,7 @@ module.exports = {
   queryData_meta: true,
   async queryData({ conid, database, sql }, req) {
     testConnectionPermission(conid, req);
-    console.log(`Processing query, conid=${conid}, database=${database}, sql=${sql}`);
+    logger.info({ conid, database, sql }, 'Processing query');
     const opened = await this.ensureOpened(conid, database);
     // if (opened && opened.status && opened.status.name == 'error') {
     //   return opened.status;
@@ -157,7 +160,7 @@ module.exports = {
   runScript_meta: true,
   async runScript({ conid, database, sql }, req) {
     testConnectionPermission(conid, req);
-    console.log(`Processing script, conid=${conid}, database=${database}, sql=${sql}`);
+    logger.info({ conid, database, sql }, 'Processing script');
     const opened = await this.ensureOpened(conid, database);
     const res = await this.sendRequest(opened, { msgtype: 'runScript', sql });
     return res;

packages/api/src/controllers/runners.js

@@ -6,10 +6,17 @@ const byline = require('byline');
 const socket = require('../utility/socket');
 const { fork } = require('child_process');
 const { rundir, uploadsdir, pluginsdir, getPluginBackendPath, packagedPluginList } = require('../utility/directories');
-const { extractShellApiPlugins, extractShellApiFunctionName, jsonScriptToJavascript } = require('dbgate-tools');
+const {
+  extractShellApiPlugins,
+  extractShellApiFunctionName,
+  jsonScriptToJavascript,
+  getLogger,
+  safeJsonParse,
+} = require('dbgate-tools');
 const { handleProcessCommunication } = require('../utility/processComm');
 const processArgs = require('../utility/processArgs');
 const platformInfo = require('../utility/platformInfo');
+const logger = getLogger();
 
 function extractPlugins(script) {
   const requireRegex = /\s*\/\/\s*@require\s+([^\s]+)\s*\n/g;
@@ -29,13 +36,14 @@ const requirePluginsTemplate = (plugins, isExport) =>
 
 const scriptTemplate = (script, isExport) => `
 const dbgateApi = require(${isExport ? `'dbgate-api'` : 'process.env.DBGATE_API'});
+const logger = dbgateApi.getLogger();
 dbgateApi.initializeApiEnvironment();
 ${requirePluginsTemplate(extractPlugins(script), isExport)}
 require=null;
 async function run() {
 ${script}
 await dbgateApi.finalizer.run();
-console.log('Finished job script');
+logger.info('Finished job script');
 }
 dbgateApi.runScript(run);
 `;
@@ -59,19 +67,17 @@ module.exports = {
   requests: {},
 
   dispatchMessage(runid, message) {
-    if (message) console.log('...', message.message);
-    if (_.isString(message)) {
-      socket.emit(`runner-info-${runid}`, {
-        message,
-        time: new Date(),
-        severity: 'info',
-      });
-    }
-    if (_.isPlainObject(message)) {
+    if (message) {
+      const json = safeJsonParse(message.message);
+
+      if (json) logger.info(json);
+      else logger.info(message.message);
+
       socket.emit(`runner-info-${runid}`, {
         time: new Date(),
         severity: 'info',
         ...message,
+        message: json ? json.msg : message.message,
       });
     }
   },
@@ -98,7 +104,7 @@ module.exports = {
     fs.writeFileSync(`${scriptFile}`, scriptText);
     fs.mkdirSync(directory);
     const pluginNames = _.union(fs.readdirSync(pluginsdir()), packagedPluginList);
-    console.log(`RUNNING SCRIPT ${scriptFile}`);
+    logger.info({ scriptFile }, 'Running script');
     // const subprocess = fork(scriptFile, ['--checkParent', '--max-old-space-size=8192'], {
     const subprocess = fork(
       scriptFile,
@@ -124,7 +130,7 @@ module.exports = {
     byline(subprocess.stderr).on('data', pipeDispatcher('error'));
     subprocess.on('exit', code => {
       this.rejectRequest(runid, { message: 'No data retured, maybe input data source is too big' });
-      console.log('... EXIT process', code);
+      logger.info({ code, pid: subprocess.pid }, 'Exited process');
       socket.emit(`runner-done-${runid}`, code);
     });
     subprocess.on('error', error => {

packages/api/src/controllers/scheduler.js

@@ -4,6 +4,9 @@ const path = require('path');
 const cron = require('node-cron');
 const runners = require('./runners');
 const { hasPermission } = require('../utility/hasPermission');
+const { getLogger } = require('dbgate-tools');
+
+const logger = getLogger();
 
 const scheduleRegex = /\s*\/\/\s*@schedule\s+([^\n]+)\n/;
 
@@ -21,7 +24,7 @@ module.exports = {
     if (!match) return;
     const pattern = match[1];
     if (!cron.validate(pattern)) return;
-    console.log(`Schedule script ${file} with pattern ${pattern}`);
+    logger.info(`Schedule script ${file} with pattern ${pattern}`);
     const task = cron.schedule(pattern, () => runners.start({ script: text }));
     this.tasks.push(task);
   },

packages/api/src/controllers/sessions.js

@@ -8,6 +8,9 @@ const path = require('path');
 const { handleProcessCommunication } = require('../utility/processComm');
 const processArgs = require('../utility/processArgs');
 const { appdir } = require('../utility/directories');
+const { getLogger } = require('dbgate-tools');
+
+const logger = getLogger();
 
 module.exports = {
   /** @type {import('dbgate-types').OpenedSession[]} */
@@ -120,7 +123,7 @@ module.exports = {
       throw new Error('Invalid session');
     }
 
-    console.log(`Processing query, sesid=${sesid}, sql=${sql}`);
+    logger.info({ sesid, sql }, 'Processing query');
     this.dispatchMessage(sesid, 'Query execution started');
     session.subprocess.send({ msgtype: 'executeQuery', sql });
 
@@ -158,7 +161,7 @@ module.exports = {
       throw new Error('Invalid session');
     }
 
-    console.log(`Starting profiler, sesid=${sesid}`);
+    logger.info({ sesid }, 'Starting profiler');
     session.loadingReader_jslid = jslid;
     session.subprocess.send({ msgtype: 'startProfiler', jslid });
 

packages/api/src/controllers/uploads.js

@@ -1,6 +1,8 @@
 const path = require('path');
 const { uploadsdir } = require('../utility/directories');
 const uuidv1 = require('uuid/v1');
+const { getLogger } = require('dbgate-tools');
+const logger = getLogger();
 
 module.exports = {
   upload_meta: {
@@ -15,7 +17,7 @@ module.exports = {
     }
     const uploadName = uuidv1();
     const filePath = path.join(uploadsdir(), uploadName);
-    console.log(`Uploading file ${data.name}, size=${data.size}`);
+    logger.info(`Uploading file ${data.name}, size=${data.size}`);
 
     data.mv(filePath, () => {
       res.json({

packages/api/src/index.js

@@ -1,5 +1,12 @@
-const shell = require('./shell');
+const { setLogger, getLogger } = require('dbgate-tools');
 const processArgs = require('./utility/processArgs');
+const pino = require('pino');
+
+if (processArgs.listenApi) {
+  // configure logger
+}
+
+const shell = require('./shell');
 const dbgateTools = require('dbgate-tools');
 
 global['DBGATE_TOOLS'] = dbgateTools;
@@ -8,7 +15,7 @@ if (processArgs.startProcess) {
   const proc = require('./proc');
   const module = proc[processArgs.startProcess];
   module.start();
-} 
+}
 
 if (processArgs.listenApi) {
   const main = require('./main');
@@ -17,5 +24,6 @@ if (processArgs.listenApi) {
 
 module.exports = {
   ...shell,
+  getLogger,
   getMainModule: () => require('./main'),
 };

packages/api/src/main.js

@@ -33,6 +33,9 @@ const platformInfo = require('./utility/platformInfo');
 const getExpressPath = require('./utility/getExpressPath');
 const { getLogins } = require('./utility/hasPermission');
 const _ = require('lodash');
+const { getLogger } = require('dbgate-tools');
+
+const logger = getLogger();
 
 function start() {
   // console.log('process.argv', process.argv);
@@ -60,8 +63,8 @@ function start() {
   } else if (platformInfo.isNpmDist) {
     app.use(getExpressPath('/'), express.static(path.join(__dirname, '../../dbgate-web/public')));
   } else if (process.env.DEVWEB) {
-    console.log('__dirname', __dirname);
-    console.log(path.join(__dirname, '../../web/public/build'));
+    // console.log('__dirname', __dirname);
+    // console.log(path.join(__dirname, '../../web/public/build'));
     app.use(getExpressPath('/'), express.static(path.join(__dirname, '../../web/public')));
   } else {
     app.get(getExpressPath('/'), (req, res) => {
@@ -109,7 +112,7 @@ function start() {
 
   if (platformInfo.isDocker) {
     const port = process.env.PORT || 3000;
-    console.log('DbGate API listening on port (docker build)', port);
+    logger.info(`DbGate API listening on port ${port} (docker build)`);
     server.listen(port);
   } else if (platformInfo.isNpmDist) {
     getPort({
@@ -119,27 +122,27 @@ function start() {
       ),
     }).then(port => {
       server.listen(port, () => {
-        console.log(`DbGate API listening on port ${port} (NPM build)`);
+        logger.info(`DbGate API listening on port ${port} (NPM build)`);
       });
     });
   } else if (process.env.DEVWEB) {
     const port = process.env.PORT || 3000;
-    console.log('DbGate API & web listening on port (dev web build)', port);
+    logger.info(`DbGate API & web listening on port ${port} (dev web build)`);
     server.listen(port);
   } else {
     const port = process.env.PORT || 3000;
-    console.log('DbGate API listening on port (dev API build)', port);
+    logger.info(`DbGate API listening on port ${port} (dev API build)`);
     server.listen(port);
   }
 
   function shutdown() {
-    console.log('\nShutting down DbGate API server');
+    logger.info('\nShutting down DbGate API server');
     server.close(() => {
-      console.log('Server shut down, terminating');
+      logger.info('Server shut down, terminating');
       process.exit(0);
     });
     setTimeout(() => {
-      console.log('Server close timeout, terminating');
+      logger.info('Server close timeout, terminating');
       process.exit(0);
     }, 1000);
   }

packages/api/src/proc/databaseConnectionProcess.js

@@ -1,7 +1,7 @@
 const stableStringify = require('json-stable-stringify');
 const { splitQuery } = require('dbgate-query-splitter');
 const childProcessChecker = require('../utility/childProcessChecker');
-const { extractBoolSettingsValue, extractIntSettingsValue } = require('dbgate-tools');
+const { extractBoolSettingsValue, extractIntSettingsValue, getLogger } = require('dbgate-tools');
 const requireEngineDriver = require('../utility/requireEngineDriver');
 const connectUtility = require('../utility/connectUtility');
 const { handleProcessCommunication } = require('../utility/processComm');
@@ -9,6 +9,8 @@ const { SqlGenerator } = require('dbgate-tools');
 const generateDeploySql = require('../shell/generateDeploySql');
 const { dumpSqlSelect } = require('dbgate-sqltree');
 
+const logger = getLogger();
+
 let systemConnection;
 let storedConnection;
 let afterConnectCallbacks = [];
@@ -269,7 +271,7 @@ async function handleSqlPreview({ msgid, objects, options }) {
     process.send({ msgtype: 'response', msgid, sql: dmp.s, isTruncated: generator.isTruncated });
     if (generator.isUnhandledException) {
       setTimeout(() => {
-        console.log('Exiting because of unhandled exception');
+        getLogger.info('Exiting because of unhandled exception');
         process.exit(0);
       }, 500);
     }
@@ -336,7 +338,7 @@ function start() {
   setInterval(() => {
     const time = new Date().getTime();
     if (time - lastPing > 40 * 1000) {
-      console.log('Database connection not alive, exiting');
+      logger.info('Database connection not alive, exiting');
       process.exit(0);
     }
   }, 10 * 1000);
@@ -346,7 +348,7 @@ function start() {
     try {
       await handleMessage(message);
     } catch (e) {
-      console.error('Error in DB connection', e);
+      logger.error('Error in DB connection', e);
       process.send({ msgtype: 'error', error: e.message });
     }
   });

packages/api/src/proc/serverConnectionProcess.js

@@ -1,9 +1,10 @@
 const stableStringify = require('json-stable-stringify');
-const { extractBoolSettingsValue, extractIntSettingsValue } = require('dbgate-tools');
+const { extractBoolSettingsValue, extractIntSettingsValue, getLogger } = require('dbgate-tools');
 const childProcessChecker = require('../utility/childProcessChecker');
 const requireEngineDriver = require('../utility/requireEngineDriver');
 const connectUtility = require('../utility/connectUtility');
 const { handleProcessCommunication } = require('../utility/processComm');
+const logger = getLogger();
 
 let systemConnection;
 let storedConnection;
@@ -101,7 +102,7 @@ async function handleDatabaseOp(op, { name }) {
   } else {
     const dmp = driver.createDumper();
     dmp[op](name);
-    console.log(`RUNNING SCRIPT: ${dmp.s}`);
+    logger.info({ sql: dmp.s }, 'Running script');
     await driver.query(systemConnection, dmp.s);
   }
   await handleRefresh();
@@ -146,7 +147,7 @@ function start() {
   setInterval(() => {
     const time = new Date().getTime();
     if (time - lastPing > 40 * 1000) {
-      console.log('Server connection not alive, exiting');
+      logger.info('Server connection not alive, exiting');
       process.exit(0);
     }
   }, 10 * 1000);

packages/api/src/proc/sessionProcess.js

@@ -10,6 +10,9 @@ const requireEngineDriver = require('../utility/requireEngineDriver');
 const { decryptConnection } = require('../utility/crypting');
 const connectUtility = require('../utility/connectUtility');
 const { handleProcessCommunication } = require('../utility/processComm');
+const { getLogger } = require('dbgate-tools');
+
+const logger = getLogger();
 
 let systemConnection;
 let storedConnection;
@@ -325,7 +328,7 @@ function start() {
   setInterval(() => {
     const time = new Date().getTime();
     if (time - lastPing > 25 * 1000) {
-      console.log('Session not alive, exiting');
+      logger.info('Session not alive, exiting');
       process.exit(0);
     }
   }, 10 * 1000);

packages/api/src/proc/sshForwardProcess.js

@@ -3,6 +3,9 @@ const platformInfo = require('../utility/platformInfo');
 const childProcessChecker = require('../utility/childProcessChecker');
 const { handleProcessCommunication } = require('../utility/processComm');
 const { SSHConnection } = require('../utility/SSHConnection');
+const { getLogger } = require('dbgate-tools');
+
+const logger = getLogger();
 
 async function getSshConnection(connection) {
   const sshConfig = {
@@ -35,8 +38,8 @@ async function handleStart({ connection, tunnelConfig }) {
       tunnelConfig,
     });
   } catch (err) {
-    console.log('Error creating SSH tunnel connection:', err.message);
-    
+    logger.error('Error creating SSH tunnel connection:', err);
+
     process.send({
       msgtype: 'error',
       connection,

packages/api/src/shell/archiveWriter.js

@@ -3,11 +3,14 @@ const fs = require('fs');
 const { archivedir, resolveArchiveFolder } = require('../utility/directories');
 // const socket = require('../utility/socket');
 const jsonLinesWriter = require('./jsonLinesWriter');
+const { getLogger } = require('dbgate-tools');
+
+const logger = getLogger();
 
 function archiveWriter({ folderName, fileName }) {
   const dir = resolveArchiveFolder(folderName);
   if (!fs.existsSync(dir)) {
-    console.log(`Creating directory ${dir}`);
+    logger.info(`Creating directory ${dir}`);
     fs.mkdirSync(dir);
   }
   const jsonlFile = path.join(dir, `${fileName}.jsonl`);

packages/api/src/shell/dumpDatabase.js

@@ -1,5 +1,8 @@
 const requireEngineDriver = require('../utility/requireEngineDriver');
 const connectUtility = require('../utility/connectUtility');
+const { getLogger } = require('dbgate-tools');
+
+const logger = getLogger();
 
 function doDump(dumper) {
   return new Promise((resolve, reject) => {
@@ -21,11 +24,11 @@ async function dumpDatabase({
   databaseName,
   schemaName,
 }) {
-  console.log(`Dumping database`);
+  logger.info(`Dumping database`);
 
   if (!driver) driver = requireEngineDriver(connection);
   const pool = systemConnection || (await connectUtility(driver, connection, 'read', { forceRowsAsObjects: true }));
-  console.log(`Connected.`);
+  logger.info(`Connected.`);
 
   const dumper = await driver.createBackupDumper(pool, {
     outputFile,

packages/api/src/shell/executeQuery.js

@@ -1,12 +1,15 @@
 const requireEngineDriver = require('../utility/requireEngineDriver');
 const connectUtility = require('../utility/connectUtility');
+const { getLogger } = require('dbgate-tools');
+
+const logger = getLogger();
 
 async function executeQuery({ connection = undefined, systemConnection = undefined, driver = undefined, sql }) {
-  console.log(`Execute query ${sql}`);
+  logger.info({ sql }, `Execute query`);
 
   if (!driver) driver = requireEngineDriver(connection);
   const pool = systemConnection || (await connectUtility(driver, connection, 'script'));
-  console.log(`Connected.`);
+  logger.info(`Connected.`);
 
   await driver.script(pool, sql);
 }

packages/api/src/shell/importDatabase.js

@@ -4,6 +4,9 @@ const connectUtility = require('../utility/connectUtility');
 const { splitQueryStream } = require('dbgate-query-splitter/lib/splitQueryStream');
 const download = require('./download');
 const stream = require('stream');
+const { getLogger } = require('dbgate-tools');
+
+const logger = getLogger();
 
 class ImportStream extends stream.Transform {
   constructor(pool, driver) {
@@ -38,11 +41,11 @@ function awaitStreamEnd(stream) {
 }
 
 async function importDatabase({ connection = undefined, systemConnection = undefined, driver = undefined, inputFile }) {
-  console.log(`Importing database`);
+  logger.info(`Importing database`);
 
   if (!driver) driver = requireEngineDriver(connection);
   const pool = systemConnection || (await connectUtility(driver, connection, 'write'));
-  console.log(`Connected.`);
+  logger.info(`Connected.`);
 
   const downloadedFile = await download(inputFile);
 

packages/api/src/shell/jsonArrayWriter.js

@@ -1,6 +1,9 @@
+const { getLogger } = require('dbgate-tools');
 const fs = require('fs');
 const stream = require('stream');
 
+const logger = getLogger();
+
 class StringifyStream extends stream.Transform {
   constructor() {
     super({ objectMode: true });
@@ -38,7 +41,7 @@ class StringifyStream extends stream.Transform {
 }
 
 async function jsonArrayWriter({ fileName, encoding = 'utf-8' }) {
-  console.log(`Writing file ${fileName}`);
+  logger.info(`Writing file ${fileName}`);
   const stringify = new StringifyStream();
   const fileStream = fs.createWriteStream(fileName, encoding);
   stringify.pipe(fileStream);

packages/api/src/shell/jsonLinesReader.js

@@ -1,6 +1,8 @@
 const fs = require('fs');
 const stream = require('stream');
 const byline = require('byline');
+const { getLogger } = require('dbgate-tools');
+const logger = getLogger();
 
 class ParseStream extends stream.Transform {
   constructor({ limitRows }) {
@@ -31,7 +33,7 @@ class ParseStream extends stream.Transform {
 }
 
 async function jsonLinesReader({ fileName, encoding = 'utf-8', limitRows = undefined }) {
-  console.log(`Reading file ${fileName}`);
+  logger.info(`Reading file ${fileName}`);
 
   const fileStream = fs.createReadStream(fileName, encoding);
   const liner = byline(fileStream);

packages/api/src/shell/jsonLinesWriter.js

@@ -1,5 +1,7 @@
+const { getLogger } = require('dbgate-tools');
 const fs = require('fs');
 const stream = require('stream');
+const logger = getLogger();
 
 class StringifyStream extends stream.Transform {
   constructor({ header }) {
@@ -21,7 +23,7 @@ class StringifyStream extends stream.Transform {
 }
 
 async function jsonLinesWriter({ fileName, encoding = 'utf-8', header = true }) {
-  console.log(`Writing file ${fileName}`);
+  logger.info(`Writing file ${fileName}`);
   const stringify = new StringifyStream({ header });
   const fileStream = fs.createWriteStream(fileName, encoding);
   stringify.pipe(fileStream);

packages/api/src/shell/queryReader.js

@@ -1,5 +1,7 @@
 const requireEngineDriver = require('../utility/requireEngineDriver');
 const connectUtility = require('../utility/connectUtility');
+const { getLogger } = require('dbgate-tools');
+const logger = getLogger();
 
 async function queryReader({
   connection,
@@ -14,12 +16,12 @@ async function queryReader({
   // if (!sql && !json) {
   //   throw new Error('One of sql or json must be set');
   // }
-  console.log(`Reading query ${query || sql}`);
+  logger.info({ sql: query || sql }, `Reading query`);
   // else console.log(`Reading query ${JSON.stringify(json)}`);
 
   const driver = requireEngineDriver(connection);
   const pool = await connectUtility(driver, connection, queryType == 'json' ? 'read' : 'script');
-  console.log(`Connected.`);
+  logger.info(`Connected.`);
   const reader =
     queryType == 'json' ? await driver.readJsonQuery(pool, query) : await driver.readQuery(pool, query || sql);
   return reader;

packages/api/src/shell/requirePlugin.js

@@ -3,6 +3,8 @@ const fs = require('fs');
 const { pluginsdir, packagedPluginsDir, getPluginBackendPath } = require('../utility/directories');
 const nativeModules = require('../nativeModules');
 const platformInfo = require('../utility/platformInfo');
+const { getLogger } = require('dbgate-tools');
+const logger = getLogger();
 
 const loadedPlugins = {};
 
@@ -17,7 +19,7 @@ function requirePlugin(packageName, requiredPlugin = null) {
   if (requiredPlugin == null) {
     let module;
     const modulePath = getPluginBackendPath(packageName);
-    console.log(`Loading module ${packageName} from ${modulePath}`);
+    logger.info(`Loading module ${packageName} from ${modulePath}`);
     try {
       // @ts-ignore
       module = __non_webpack_require__(modulePath);

packages/api/src/shell/runScript.js

@@ -1,5 +1,7 @@
+const { getLogger } = require('dbgate-tools');
 const childProcessChecker = require('../utility/childProcessChecker');
 const processArgs = require('../utility/processArgs');
+const logger = getLogger();
 
 async function runScript(func) {
   if (processArgs.checkParent) {
@@ -9,7 +11,7 @@ async function runScript(func) {
     await func();
     process.exit(0);
   } catch (err) {
-    console.log(err);
+    logger.error('Error running script', err);
     process.exit(1);
   }
 }

packages/api/src/shell/sqlDataWriter.js

@@ -1,8 +1,9 @@
 const fs = require('fs');
 const stream = require('stream');
 const path = require('path');
-const { driverBase } = require('dbgate-tools');
+const { driverBase, getLogger } = require('dbgate-tools');
 const requireEngineDriver = require('../utility/requireEngineDriver');
+const logger = getLogger();
 
 class SqlizeStream extends stream.Transform {
   constructor({ fileName, dataName }) {
@@ -40,7 +41,7 @@ class SqlizeStream extends stream.Transform {
 }
 
 async function sqlDataWriter({ fileName, dataName, driver, encoding = 'utf-8' }) {
-  console.log(`Writing file ${fileName}`);
+  logger.info(`Writing file ${fileName}`);
   const stringify = new SqlizeStream({ fileName, dataName });
   const fileStream = fs.createWriteStream(fileName, encoding);
   stringify.pipe(fileStream);

packages/api/src/shell/tableReader.js

@@ -1,17 +1,18 @@
-const { quoteFullName, fullNameToString } = require('dbgate-tools');
+const { quoteFullName, fullNameToString, getLogger } = require('dbgate-tools');
 const requireEngineDriver = require('../utility/requireEngineDriver');
 const connectUtility = require('../utility/connectUtility');
+const logger = getLogger();
 
 async function tableReader({ connection, pureName, schemaName }) {
   const driver = requireEngineDriver(connection);
   const pool = await connectUtility(driver, connection, 'read');
-  console.log(`Connected.`);
+  logger.info(`Connected.`);
 
   const fullName = { pureName, schemaName };
 
   if (driver.databaseEngineTypes.includes('document')) {
     // @ts-ignore
-    console.log(`Reading collection ${fullNameToString(fullName)}`);
+    logger.info(`Reading collection ${fullNameToString(fullName)}`);
     // @ts-ignore
     return await driver.readQuery(pool, JSON.stringify(fullName));
   }
@@ -20,14 +21,14 @@ async function tableReader({ connection, pureName, schemaName }) {
   const query = `select * from ${quoteFullName(driver.dialect, fullName)}`;
   if (table) {
     // @ts-ignore
-    console.log(`Reading table ${fullNameToString(table)}`);
+    logger.info(`Reading table ${fullNameToString(table)}`);
     // @ts-ignore
     return await driver.readQuery(pool, query, table);
   }
   const view = await driver.analyseSingleObject(pool, fullName, 'views');
   if (view) {
     // @ts-ignore
-    console.log(`Reading view ${fullNameToString(view)}`);
+    logger.info(`Reading view ${fullNameToString(view)}`);
     // @ts-ignore
     return await driver.readQuery(pool, query, view);
   }

packages/api/src/shell/tableWriter.js

@@ -1,16 +1,17 @@
-const { fullNameToString } = require('dbgate-tools');
+const { fullNameToString, getLogger } = require('dbgate-tools');
 const requireEngineDriver = require('../utility/requireEngineDriver');
 const connectUtility = require('../utility/connectUtility');
+const logger = getLogger();
 
 async function tableWriter({ connection, schemaName, pureName, driver, systemConnection, ...options }) {
-  console.log(`Writing table ${fullNameToString({ schemaName, pureName })}`);
+  logger.info(`Writing table ${fullNameToString({ schemaName, pureName })}`);
 
   if (!driver) {
     driver = requireEngineDriver(connection);
   }
   const pool = systemConnection || (await connectUtility(driver, connection, 'write'));
 
-  console.log(`Connected.`);
+  logger.info(`Connected.`);
   return await driver.writeTable(pool, { schemaName, pureName }, options);
 }
 

packages/api/src/utility/childProcessChecker.js

@@ -1,3 +1,7 @@
+const { getLogger } = require('dbgate-tools');
+
+const logger = getLogger();
+
 let counter = 0;
 
 function childProcessChecker() {
@@ -8,7 +12,7 @@ function childProcessChecker() {
       // This will come once parent dies.
       // One way can be to check for error code ERR_IPC_CHANNEL_CLOSED
       //     and call process.exit()
-      console.log('parent died', ex.toString());
+      logger.error('parent died', ex);
       process.exit(1);
     }
   }, 1000);

packages/api/src/utility/directories.js

@@ -5,16 +5,18 @@ const cleanDirectory = require('./cleanDirectory');
 const platformInfo = require('./platformInfo');
 const processArgs = require('./processArgs');
 const consoleObjectWriter = require('../shell/consoleObjectWriter');
+const { getLogger } = require('dbgate-tools');
+const logger = getLogger();
 
 const createDirectories = {};
 const ensureDirectory = (dir, clean) => {
   if (!createDirectories[dir]) {
     if (clean && fs.existsSync(dir) && !platformInfo.isForkedApi) {
-      console.log(`Cleaning directory ${dir}`);
+      logger.info(`Cleaning directory ${dir}`);
       cleanDirectory(dir);
     }
     if (!fs.existsSync(dir)) {
-      console.log(`Creating directory ${dir}`);
+      logger.info(`Creating directory ${dir}`);
       fs.mkdirSync(dir);
     }
     createDirectories[dir] = true;
@@ -38,12 +40,14 @@ function datadir() {
   return dir;
 }
 
-const dirFunc = (dirname, clean = false) => () => {
-  const dir = path.join(datadir(), dirname);
-  ensureDirectory(dir, clean);
+const dirFunc =
+  (dirname, clean = false) =>
+  () => {
+    const dir = path.join(datadir(), dirname);
+    ensureDirectory(dir, clean);
 
-  return dir;
-};
+    return dir;
+  };
 
 const jsldir = dirFunc('jsl', true);
 const rundir = dirFunc('run', true);
@@ -128,7 +132,7 @@ function migrateDataDir() {
       fs.renameSync(oldDir, newDir);
     }
   } catch (e) {
-    console.log('Error migrating data dir:', e.message);
+    logger.error('Error migrating data dir:', e.message);
   }
 }
 

packages/api/src/utility/sshTunnel.js

@@ -5,6 +5,8 @@ const AsyncLock = require('async-lock');
 const lock = new AsyncLock();
 const { fork } = require('child_process');
 const processArgs = require('../utility/processArgs');
+const { getLogger } = require('dbgate-tools');
+const logger = getLogger();
 
 const sshTunnelCache = {};
 
@@ -45,7 +47,7 @@ function callForwardProcess(connection, tunnelConfig, tunnelCacheKey) {
       }
     });
     subprocess.on('exit', code => {
-      console.log('SSH forward process exited');
+      logger.info('SSH forward process exited');
       delete sshTunnelCache[tunnelCacheKey];
     });
   });
@@ -65,13 +67,13 @@ async function getSshTunnel(connection) {
       toHost: connection.server,
     };
     try {
-      console.log(
+      logger.info(
         `Creating SSH tunnel to ${connection.sshHost}-${connection.server}:${connection.port}, using local port ${localPort}`
       );
 
       const subprocess = await callForwardProcess(connection, tunnelConfig, tunnelCacheKey);
 
-      console.log(
+      logger.info(
         `Created SSH tunnel to ${connection.sshHost}-${connection.server}:${connection.port}, using local port ${localPort}`
       );
 

packages/api/src/utility/useController.js

@@ -2,7 +2,9 @@ const _ = require('lodash');
 const express = require('express');
 const getExpressPath = require('./getExpressPath');
 const { MissingCredentialsError } = require('./exceptions');
+const { getLogger } = require('dbgate-tools');
 
+const logger = getLogger();
 /**
  * @param {string} route
  */
@@ -10,11 +12,11 @@ module.exports = function useController(app, electron, route, controller) {
   const router = express.Router();
 
   if (controller._init) {
-    console.log(`Calling init controller for controller ${route}`);
+    logger.info(`Calling init controller for controller ${route}`);
     try {
       controller._init();
     } catch (err) {
-      console.log(`Error initializing controller, exiting application`, err);
+      logger.error(`Error initializing controller, exiting application`, err);
       process.exit(1);
     }
   }
@@ -76,7 +78,7 @@ module.exports = function useController(app, electron, route, controller) {
           const data = await controller[key]({ ...req.body, ...req.query }, req);
           res.json(data);
         } catch (e) {
-          console.log(e);
+          logger.error(`Error when processing route ${route}/${key}`, e);
           if (e instanceof MissingCredentialsError) {
             res.json({
               missingCredentials: true,