Getting Log working ;)

Author: manifestinteractive

bin/cli.js

@@ -50,6 +50,54 @@ const argv = yargs
       default: false
     }
   })
+  .command('log [client] [instance]', 'Stream log files from an instance', {
+    interval: {
+      describe: 'Polling interval (seconds)',
+      default: 2
+    },
+    lines: {
+      describe: 'Number of lines to display',
+      default: 100
+    },
+    include: {
+      describe: 'Log levels to include',
+      type: 'array',
+      default: []
+    },
+    exclude: {
+      describe: 'Log levels to exclude',
+      type: 'array',
+      default: []
+    },
+    list: {
+      describe: 'Output a list of available log levels',
+      default: false
+    },
+    dates: {
+      describe: 'Output a list of available log dates',
+      default: false
+    },
+    filter: {
+      describe: 'Filter log messages by regexp',
+      default: null
+    },
+    length: {
+      describe: 'Length to truncate a log message',
+      default: null
+    },
+    search: {
+      describe: 'Search all log files',
+      default: false
+    },
+    'no-timestamp': {
+      describe: "Don't convert timestamps to local time",
+      default: false
+    },
+    latest: {
+      describe: 'Show Latest Logs Only',
+      boolean: false
+    }
+  })
   .example('$0 delete my-client sandbox', 'Delete my-client sandbox config')
   .example('$0 watch my-client sandbox', 'Watch for my-client sandbox changes')
   .demand(1)

commands/log.js

@@ -0,0 +1,125 @@
+const argv = require('minimist')(process.argv.slice(2))
+const chalk = require('chalk')
+const forEach = require('lodash/forEach')
+const groupBy = require('lodash/groupBy')
+const keys = require('lodash/keys')
+const pickBy = require('lodash/pickBy')
+const sortBy = require('lodash/sortBy')
+
+const find = require('../lib/find')
+const search = require('../lib/search')
+const tail = require('../lib/tail')
+const config = require('../lib/config')()
+
+module.exports = async options => {
+  let client = argv['_'][1] || null
+  let instance = argv['_'][2] || null
+  let selected = null
+
+  // Get Client & Instance, or check for Default
+  if (client && instance) {
+    selected = config.get(client, instance)
+  } else {
+    const defaultConfig = config.get(client, instance, true)
+
+    if (defaultConfig) {
+      client = defaultConfig.client
+      instance = defaultConfig.instance
+      selected = defaultConfig.config
+    }
+  }
+
+  if (selected) {
+    let files = await find('Logs', {
+      baseURL: `https://${selected.h}/on/demandware.servlet/webdav/Sites/`,
+      auth: {
+        username: selected.u,
+        password: selected.p
+      }
+    })
+
+    files = files.filter(({displayname}) => displayname.includes('.log'))
+
+    // Group Logs
+    let groups = groupBy(files, ({displayname}) => displayname.split('-blade')[0])
+    let dates = groupBy(files, ({creationdate}) => creationdate.split('T')[0])
+
+    // pick out logs we want to include
+    if (options.include.length > 0) {
+      if (options.include.length === 1 && options.include[0].includes(',')) {
+        options.include = options.include[0].split(',')
+      }
+      groups = pickBy(
+        groups,
+        (group, name) =>
+          options.include.filter(level => {
+            return new RegExp(level).test(name)
+          }).length > 0
+      )
+    }
+
+    // pick out logs we want to exclude
+    if (options.exclude.length > 0) {
+      if (options.exclude.length === 1 && options.exclude[0].includes(',')) {
+        options.exclude = options.exclude[0].split(',')
+      }
+      groups = pickBy(
+        groups,
+        (group, name) =>
+          options.exclude.filter(level => {
+            return new RegExp(level).test(name)
+          }).length === 0
+      )
+    }
+
+    // get list of log types
+    if (options.list) {
+      console.log(chalk.green.bold('\nLog Levels:\n'))
+
+      forEach(keys(groups).sort(), group => {
+        console.log('· ' + group)
+      })
+
+      console.log('')
+
+      process.exit()
+    }
+
+    // get lost of log dates
+    if (options.dates) {
+      console.log(chalk.green.bold('\nLog Dates:\n'))
+
+      forEach(
+        keys(dates)
+          .sort()
+          .reverse(),
+        date => {
+          console.log('· ' + date)
+        }
+      )
+
+      console.log('')
+
+      process.exit()
+    }
+
+    // setup logs
+    const logs = []
+    forEach(groups, (files, name) => {
+      logs[name] = []
+    })
+
+    // sort groups by last modified
+    forEach(groups, (files, name) => {
+      var sorted = sortBy(files, file => new Date(file.getlastmodified)).reverse()
+      groups[name] = options.latest ? [sorted[0]] : sorted
+    })
+
+    try {
+      // Start log output
+      options.search ? search(selected, groups, options) : tail(selected, logs, groups, options)
+    } catch (err) {
+      console.log(err)
+    }
+  }
+}

commands/watch.js

@@ -12,26 +12,27 @@ const upload = require('../lib/upload')
 module.exports = options => {
   let client = argv['_'][1] || null
   let instance = argv['_'][2] || null
-  let watching = null
+  let selected = null
   let errorMessage
   let logMessage
 
   const useLog = options.log
   const errorsOnly = options.errorsOnly
 
+  // Get Client & Instance, or check for Default
   if (client && instance) {
-    watching = config.get(client, instance)
+    selected = config.get(client, instance)
   } else {
     const defaultConfig = config.get(client, instance, true)
 
     if (defaultConfig) {
       client = defaultConfig.client
       instance = defaultConfig.instance
-      watching = defaultConfig.config
+      selected = defaultConfig.config
     }
   }
 
-  if (watching) {
+  if (selected) {
     let spinner
     const watcher = chokidar.watch('dir', {
       ignored: [/[/\\]\./, '**/node_modules/**'],
@@ -42,14 +43,14 @@ module.exports = options => {
     })
 
     // Add Instance Directory to Watch List
-    watcher.add(watching.d)
+    watcher.add(selected.d)
 
     // Watch for File Changes
     watcher.on('change', file => {
-      upload({file, spinner, watching, client, instance, options})
+      upload({file, spinner, selected, client, instance, options})
     })
     watcher.on('add', file => {
-      upload({file, spinner, watching, client, instance, options})
+      upload({file, spinner, selected, client, instance, options})
     })
 
     // @TODO: Watch for Removing Files

lib/find.js

@@ -0,0 +1,39 @@
+const axios = require('axios')
+const path = require('path')
+const {parseString} = require('xml2js')
+const get = require('lodash/get')
+const forEach = require('lodash/forEach')
+
+module.exports = async (file, options) => {
+  try {
+    const {data} = await axios(
+      Object.assign({}, options, {
+        headers: {
+          Depth: 1
+        },
+        url: path.isAbsolute(file) ? file : `/${file}`,
+        method: 'PROPFIND'
+      })
+    )
+    return await new Promise((resolve, reject) => {
+      parseString(data, (err, res) => {
+        if (err) {
+          return reject(err)
+        }
+
+        resolve(
+          res.multistatus.response.map(file => {
+            const info = get(file, 'propstat.0.prop.0')
+            forEach(info, (value, name) => {
+              info[name] = get(value, '0')
+            })
+            return info
+          })
+        )
+      })
+    })
+  } catch (err) {
+    console.log(err)
+    return new Error(err)
+  }
+}

lib/read.js

@@ -0,0 +1,13 @@
+const path = require('path')
+const axios = require('axios')
+
+module.exports = async (file, options) => {
+  const {data} = await axios(
+    Object.assign({}, options, {
+      url: path.isAbsolute(file) ? file : `/${file}`,
+      method: 'GET'
+    })
+  )
+
+  return data
+}

lib/search.js

@@ -0,0 +1,82 @@
+const chalk = require('chalk')
+const compact = require('lodash/compact')
+const map = require('lodash/map')
+const ora = require('ora')
+const truncate = require('lodash/truncate')
+
+const read = require('./read')
+
+module.exports = async (selected, groups, options) => {
+  const text = 'Searching'
+
+  const spinner = ora(text)
+  const output = fn => {
+    spinner.stop()
+    fn()
+    spinner.start()
+  }
+
+  const promiseGroups = map(groups, (files, name) => {
+    return map(files, async file => {
+      const displayname = file.displayname
+      try {
+        const response = await read(`Logs/${displayname}`, {
+          baseURL: `https://${selected.h}/on/demandware.servlet/webdav/Sites/`,
+          auth: {
+            username: selected.u,
+            password: selected.p
+          }
+        })
+        return {
+          response,
+          name
+        }
+      } catch (err) {
+        output(() => console.log(err))
+      }
+    })
+  })
+
+  for (const promises of promiseGroups) {
+    const results = await Promise.all(promises)
+
+    for (const {response, name} of compact(results)) {
+      const lines = response.split('\n').slice(-options.lines)
+
+      for (let line of lines) {
+        if (line) {
+          if (!options.noTimestamp) {
+            line = line.replace(/\[(.+)\sGMT\]/g, (exp, match) => {
+              const date = new Date(Date.parse(match + 'Z'))
+              return chalk.magenta(`[${date.toLocaleDateString()} ${date.toLocaleTimeString()}]`)
+            })
+          }
+          // if there's a filter and it doesn't pass .,., the ignore line
+          if (options.filter && !new RegExp(options.filter, 'ig').test(line)) {
+            continue
+          }
+          // highlight the matching parts of the line
+          if (options.filter) {
+            line = line.replace(new RegExp(options.filter, 'ig'), exp => {
+              return chalk.yellow(exp)
+            })
+          }
+
+          if (options.length > 0) {
+            line = truncate(line.trim(), {
+              length: options.length,
+              omission: ''
+            })
+          }
+
+          output(() => console.log(`${chalk.white(name)} ${line}`, 'blue'))
+        }
+      }
+    }
+  }
+
+  // spinner.stop();
+  spinner.text = `Search ` + (options.filter ? `for '${options.filter}' ` : '') + `complete`
+  spinner.succeed()
+  process.exit()
+}