web-log-viewer 0.0.3 → 0.1.0

package/produce-log.sh

@@ -1,3 +0,0 @@
-#!/bin/fish
-
-echo "{ timestamp: '"(date -Ins)"',  level: 'INFO',  message: 'Finished job execution5'}"

package/src/config.ts

@@ -1,28 +0,0 @@
-import { Command } from 'commander'
-import { extractIndexTokens as extractIndexTokensFn } from './log-index'
-
-const program = new Command('web-log-viewer')
-program.version('0.0.1')
-program.option('--port <port>', 'specify the port where the server will run', '8000')
-program.option(
-  '-p, --parser <filename>',
-  'specify the script used for parsing lines of text from stdin and converting them to JSON. Defaults to parse using `json5` (https://www.npmjs.com/package/json5)',
-)
-program.option(
-  '-k, --index-keys',
-  'allow searching by the log object keys, instead of just its values',
-  false,
-)
-program.option('-s, --stdout', 'log every message coming in to stdout', false)
-
-program.parse(process.argv)
-const options = program.opts()
-
-const config = {
-  port: options.port || 8000,
-  stdout: options.stdout || false,
-  parseRawMessage: options.parser ? require(options.parser) : require('./defaultMessageParser'),
-  extractIndexTokens: extractIndexTokensFn({ includeObjectKeys: options.indexKeys }),
-}
-
-export { config }

package/src/defaultMessageParser.ts

@@ -1,16 +0,0 @@
-import json5 from 'json5'
-
-/**
- * Default parser implementation, that transforms a string (usually a single
- * line of text coming in from **stdin**) into a JSON object containing the data
- * present in a log message
- */
-
-module.exports = (rawMessage: string) => {
-  try {
-    return json5.parse(rawMessage)
-  } catch (err) {
-    const msg = { message: rawMessage }
-    return msg
-  }
-}

package/src/log-index.ts

@@ -1,44 +0,0 @@
-type Tokens = string[]
-
-interface Config {
-  includeObjectKeys: boolean
-}
-
-const extractIndexTokens = (cfg: Config) => (obj: Object, tokens: Tokens = []): Tokens => {
-  let newTokens = [...tokens]
-  if (cfg.includeObjectKeys) {
-    newTokens = [...newTokens, ...Object.keys(obj)]
-  }
-  return Object.values(obj).reduce((acc, val) => {
-    if (!val) {
-      return acc
-    } else if (typeof val !== 'object') {
-      return [...acc, removeDiacritics(val.toString())]
-    } else {
-      return extractIndexTokens(cfg)(val, acc)
-    }
-  }, newTokens)
-}
-
-// see: https://github.com/esamattis/underscore.string
-const removeDiacritics = (str: string) => {
-  const accents = 'ąàáäâãåæăćčĉęèéëêĝĥìíïîĵłľńňòóöőôõðøśșşšŝťțţŭùúüűûñÿýçżźž'
-  const result = 'aaaaaaaaaccceeeeeghiiiijllnnoooooooossssstttuuuuuunyyczzz'
-
-  return str.toLowerCase().replace(/.{1}/g, function (c: string) {
-    var index = accents.indexOf(c)
-    return index === -1 ? c : result[index]
-  })
-}
-
-const isIndexMatch = (filter: string) => {
-  if (!filter) {
-    return () => true
-  }
-  const tokens = removeDiacritics(filter).split(/\s+/)
-  return (index: Tokens) => tokens.every(token => index.find(isSingleMatch(token)))
-}
-
-const isSingleMatch = (tokenToSearch: string) => (data: string) => data.indexOf(tokenToSearch) != -1
-
-export { extractIndexTokens, isIndexMatch }

package/src/server.ts

@@ -1,135 +0,0 @@
-import { map, runEffects, tap } from '@most/core'
-import { newDefaultScheduler } from '@most/scheduler'
-import express from 'express'
-import http from 'http'
-import { pipe } from 'ramda'
-import WebSocket from 'ws'
-import { createReadlineStream } from './stream-utils'
-import { ClientMessage, LogMessage, ServerMessage } from './types'
-import { config } from './config'
-import { isIndexMatch } from './log-index'
-import path from 'path'
-
-const LOG_WINDOW_SIZE = 100
-
-type ClientStatus =
-  | { mode: 'tail' }
-  | {
-      mode: 'static'
-      // the `seq` of the first message the client is locked on
-      start: number
-    }
-const clients: ClientStatus[] = []
-
-/**Contains all the logs that came into the server up until now */
-const logs: LogMessage[] = []
-
-// setup the server
-const app = express()
-app.use(express.static(path.join(__dirname, 'public')))
-const server = http.createServer(app)
-const wss = new WebSocket.Server({ server })
-
-//start our server
-server.listen(config.port, () => {
-  const address = server.address()
-  if (address) {
-    console.log(
-      `Started on ${
-        typeof address == 'string' ? address : `${address.port}`
-      }. Waiting for log messages on stdin...`,
-    )
-
-    // setup the log stream from stdin to clients
-    const logStream = setupLogStream()()
-    runEffects(logStream, newDefaultScheduler())
-
-    // waits for WS clients to connect
-    wss.on('connection', setupNewClient)
-  }
-})
-
-/**
- * Sets up the stream that receives messages from **stdin** and
- * pipes them to all registered clients using websockets.
- */
-const setupLogStream = () =>
-  pipe(
-    () => createReadlineStream(),
-    tap(rawMessage => {
-      if (config.stdout) {
-        console.log(rawMessage)
-      }
-    }),
-    map(rawMessage => {
-      const data = config.parseRawMessage(rawMessage)
-      const msg: LogMessage = {
-        seq: logs.length + 1,
-        data,
-        index: config.extractIndexTokens(data),
-      }
-      logs.push(msg)
-      return msg
-    }),
-    tap((rawLog: LogMessage) => {
-      const updateMsg: ServerMessage = {
-        type: 'update',
-        size: logs.length,
-        message: rawLog,
-      }
-      wss.clients.forEach(ws => {
-        ws.send(encode(updateMsg))
-      })
-    }),
-  )
-
-/**
- * Function executed every time a new WS client connects to the server.
- * This will send a `InitMessage` to that client, so it can immediately start showing to the user.
- */
-function setupNewClient(ws: WebSocket) {
-  const clientId = clients.length
-  clients.push({ mode: 'tail' })
-
-  // send a window with the last logs to newly registered clients
-  ws.send(encode(buildTailMessage('')))
-
-  ws.on('message', encodedMsg => {
-    const msg = decode(encodedMsg) as ClientMessage
-    if (msg.mode == 'tail') {
-      ws.send(encode(buildTailMessage(msg.filter)))
-    } else if (msg.mode == 'static') {
-      ws.send(encode(buildStaticMessage(msg.filter, msg.offsetSeq)))
-    }
-  })
-
-  function buildTailMessage(filter: string): ServerMessage {
-    const matcher = isIndexMatch(filter)
-    const filteredLogs = logs.filter(l => matcher(l.index)).map((l, i) => ({ ...l, seq: i + 1 }))
-    return {
-      type: 'init',
-      mode: 'tail',
-      size: filteredLogs.length,
-      offsetSeq: -1,
-      window: filteredLogs.slice(-LOG_WINDOW_SIZE),
-    }
-  }
-
-  function buildStaticMessage(filter: string, offsetSeq: number): ServerMessage {
-    const matcher = isIndexMatch(filter)
-    const filteredLogs = logs.filter(l => matcher(l.index)).map((l, i) => ({ ...l, seq: i + 1 }))
-    return {
-      type: 'init',
-      mode: 'static',
-      size: filteredLogs.length,
-      offsetSeq,
-      window: filteredLogs.slice(
-        Math.max(offsetSeq - LOG_WINDOW_SIZE / 2, 0),
-        offsetSeq + LOG_WINDOW_SIZE / 2,
-      ),
-    }
-  }
-}
-
-const encode = (data: ServerMessage) => JSON.stringify(data)
-const decode = (data: WebSocket.Data): ClientMessage => JSON.parse(data.toString('utf-8'))

package/src/stream-utils.ts

@@ -1,28 +0,0 @@
-import { createAdapter } from "@most/adapter";
-import * as readline from "readline";
-import json5 from "json5";
-
-const memoizedFromJson = (s: string) => {
-  try {
-    return json5.parse(s);
-  } catch (err) {
-    return {};
-  }
-};
-
-const createReadlineStream = () => {
-  const [induce, readlineStream] = createAdapter<string>();
-
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    terminal: false,
-  });
-  rl.on("line", (line) => {
-    induce(line);
-  });
-
-  return readlineStream;
-};
-
-export { memoizedFromJson, createReadlineStream };

package/src/types.ts

@@ -1,51 +0,0 @@
-type OperationMode = 'static' | 'tail'
-
-/**A log message has sent by the server to the clients */
-type LogMessage = {
-  seq: number
-  data: Record<string, any>
-  index: string[]
-}
-
-/**A log message that's already been formatted and ready to be displayed */
-type FormattedMessage = {
-  seq: number
-  rawMessage: Record<string, any>
-  formattedMessage: Record<string, any>
-}
-
-/**A function that formats a log message */
-type LogFormatter = Record<string, LogColumnFormatter>
-type LogColumnFormatter = (message: LogMessage['data'], seq: number) => any
-
-// ***
-// SERVER MESSAGES
-// ***
-
-// the message sent to clients that either just connected or changed operation model (tail <-> static)
-type InitMessage = {
-  type: 'init'
-  mode: OperationMode
-  size: number
-  offsetSeq: number
-  window: LogMessage[]
-}
-// the message sent to all clients once a new message comes in from stdin
-type UpdateMessage = { type: 'update'; size: number; message: LogMessage }
-// all messages in the direction Server -> Client
-type ServerMessage = InitMessage | UpdateMessage
-
-// CLIENT MESSAGES
-type StaticClientMessage = { mode: 'static'; filter: string; offsetSeq: number }
-type TailClientMessage = { mode: 'tail'; filter: string }
-/**Messages sent from the client to the server, basically to signal it want to swith operation mode */
-type ClientMessage = StaticClientMessage | TailClientMessage
-
-export type {
-  LogMessage,
-  FormattedMessage,
-  LogFormatter,
-  LogColumnFormatter,
-  ServerMessage,
-  ClientMessage,
-}

package/svelte/.vscode/extensions.json

@@ -1,3 +0,0 @@
-{
-  "recommendations": ["svelte.svelte-vscode"]
-}