@codeleap/logger 4.3.0

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@codeleap/logger",
+  "version": "4.3.0",
+  "main": "src/index.ts",
+  "license": "UNLICENSED",
+  "repository": {
+    "url": "https://github.com/codeleap-uk/internal-libs-monorepo.git",
+    "type": "git",
+    "directory": "packages/logger"
+  },
+  "devDependencies": {
+    "@codeleap/types": "4.3.0",
+    "@codeleap/utils": "4.3.0",
+    "@codeleap/config": "4.3.0",
+    "ts-node-dev": "1.1.8",
+    "@sentry/types": "8.40.0"
+  },
+  "scripts": {
+    "build": "echo 'No build needed'"
+  },
+  "peerDependencies": {
+    "@codeleap/types": "4.3.0",
+    "@codeleap/utils": "4.3.0",
+    "typescript": "5.0.4",
+    "react": "18.1.0"
+  },
+  "dependencies": {
+    "util": "0.12.5",
+    "url-parse": "^1.5.10"
+  }
+}

package/package.json.bak

@@ -0,0 +1,31 @@
+{
+  "name": "@codeleap/logger",
+  "version": "4.3.0",
+  "main": "src/index.ts",
+  "license": "UNLICENSED",
+  "repository": {
+    "url": "https://github.com/codeleap-uk/internal-libs-monorepo.git",
+    "type": "git",
+    "directory": "packages/logger"
+  },
+  "devDependencies": {
+    "@codeleap/types": "workspace:*",
+    "@codeleap/utils": "workspace:*",
+    "@codeleap/config": "workspace:*",
+    "ts-node-dev": "1.1.8",
+    "@sentry/types": "8.40.0"
+  },
+  "scripts": {
+    "build": "echo 'No build needed'"
+  },
+  "peerDependencies": {
+    "@codeleap/types": "workspace:*",
+    "@codeleap/utils": "workspace:*",
+    "typescript": "5.0.4",
+    "react": "18.1.0"
+  },
+  "dependencies": {
+    "util": "0.12.5",
+    "url-parse": "^1.5.10"
+  }
+}

package/src/Analytics.ts

@@ -0,0 +1,67 @@
+import { obfuscate } from './obfuscate'
+import { FunctionType, AnyFunction, AppSettings } from '@codeleap/types'
+
+export type AnalyticsObject = {
+  name: string
+  type: 'interaction' | 'event'
+  data: any
+}
+
+type IAnalyticsArgs = {
+  init(): any
+  prepareData: () => any
+  error?: (err: any) => any
+} & Record<`on${Capitalize<AnalyticsObject['type']>}`, FunctionType<[AnalyticsObject], void>>
+
+export class Analytics {
+
+  constructor(private callers: IAnalyticsArgs, private settings: AppSettings) {
+    this.callers.init()
+
+  }
+
+  private prepare() {
+    const data = this.callers.prepareData()
+
+    return data
+  }
+
+  obfuscate(data) {
+    return obfuscate({
+      object: data,
+      keys: this?.settings?.Logger?.Obfuscate?.keys || [],
+      values: this?.settings?.Logger?.Obfuscate?.values || [],
+    })
+  }
+
+  event(name: string, data = {}) {
+    this.handle(name, data, 'event', this.callers.onEvent)
+  }
+
+  interaction(name: string, data = {}) {
+    this.handle(name, data, 'interaction', this.callers.onInteraction)
+
+  }
+
+  onError(cb) {
+    this.callers.error = cb
+  }
+
+  private handle(name: string, data: any, type: AnalyticsObject['type'], fn: AnyFunction) {
+    try {
+
+      const obfuscated = this.obfuscate({
+        ...data,
+        ...this.prepare(),
+      })
+
+      fn({
+        name,
+        type,
+        data: obfuscated,
+      })
+    } catch (e) {
+      this.callers.error(e)
+    }
+  }
+}

package/src/Logger.ts

@@ -0,0 +1,223 @@
+import { inspect } from 'util'
+import { TypeGuards, LogType, AppSettings } from '@codeleap/types'
+import { Analytics } from './Analytics'
+import { SentryService } from './Sentry'
+import { SlackService } from './Slack'
+import { LogToTerminal, LogFunctionArgs, LogToTerminalArgs, LoggerMiddleware } from './types'
+
+const logLevels: LogType[] = ['debug', 'info', 'log', 'warn', 'error']
+
+const emptyFunction = () => { }
+
+const hollowAnalytics = new Analytics({
+  init: emptyFunction,
+  onEvent: emptyFunction,
+  onInteraction: emptyFunction,
+  prepareData: () => ({}),
+}, {})
+
+export class Logger {
+  static settings: AppSettings
+
+  settings: AppSettings
+
+  sentry: SentryService
+
+  slack: SlackService
+
+  middleware: LoggerMiddleware[] = []
+
+  constructor(settings: AppSettings, middleware?: LoggerMiddleware[], public analytics?: Analytics) {
+    this.settings = settings
+    this.middleware = middleware || []
+    if (settings.Logger.isMain) {
+      Logger.settings = settings
+    }
+
+    if (settings?.Logger?.IgnoreWarnings?.length) {
+      const newConsole = (args, oldConsole) => {
+        const shouldIgnore = typeof args[0] === 'string' &&
+          settings.Logger.IgnoreWarnings.some(ignoredWarning => args.join(' ').includes(ignoredWarning))
+        if (shouldIgnore) return
+        else return oldConsole.apply(console, args)
+      }
+      const consoles = ['log', 'warn', 'error']
+
+      consoles.forEach(t => {
+        const tmp = console[t]
+        console[t] = (...args) => newConsole(args, tmp)
+      })
+    }
+
+    this.sentry = new SentryService(settings)
+
+    this.slack = new SlackService(settings)
+
+    if (!analytics) {
+      this.analytics = hollowAnalytics
+    }
+
+    this.analytics.onError((err) => {
+      this.logToTerminal({
+        logType: 'error',
+        args: ['Error on analytics event', err, 'Internal'],
+      })
+    })
+
+  }
+
+  static formatContent(logArgs: LogToTerminalArgs) {
+    const { logType, args: content, deviceIdentifier: deviceId, stringify, logKeys = true } = logArgs
+
+    const [descriptionOrValue, value, category] = content
+
+    const nArgs = content.length
+    let logContent = content
+
+    const logValue = nArgs === 1 ? descriptionOrValue : value
+
+    const shouldStringify = stringify && !!logValue && TypeGuards.isObject(logValue) && !(logValue instanceof Error)
+    const inspectOptions = Logger?.settings?.Logger?.inspect || {}
+
+    const displayValue = shouldStringify ? inspect(logValue, {
+      depth: 5,
+      showHidden: true,
+      ...inspectOptions,
+    }) : logValue
+
+    if (nArgs === 3) {
+      logContent = [
+        `(${category}) ${descriptionOrValue}${displayValue ? ' ->' : ''}`,
+        displayValue,
+      ]
+    }
+
+    if (nArgs === 2) {
+      logContent = [
+        `${descriptionOrValue}${displayValue ? ' ->' : ''}`,
+        displayValue,
+      ]
+    }
+
+    if (nArgs === 1) {
+      const isObj = typeof descriptionOrValue === 'object' && !(descriptionOrValue instanceof Error)
+      const keys = isObj ? Object.keys(descriptionOrValue) : null
+      const title = isObj && keys.length && logKeys ?
+        `${keys.filter(i => !!i).slice(0, 3).join(', ')}${keys.length > 3 ? '...' : ''} ->`
+        : null
+
+      if (title) {
+        logContent = [
+          title,
+          displayValue,
+        ]
+      } else {
+        logContent = [
+          displayValue,
+        ]
+      }
+    }
+
+    return logContent
+  }
+
+  static coloredLog: LogToTerminal = (logArgs) => {
+    const { logType, args: content, deviceIdentifier: deviceId, stringify } = logArgs
+
+    const logContent = Logger.formatContent(logArgs)
+
+    const displayLog = logType === 'error' ? 'warn' : logType
+
+    console[displayLog](deviceId, ...logContent)
+
+    return logContent
+  }
+
+  private logToTerminal: LogToTerminal = (logArgs) => {
+    const { logType, args, color } = logArgs
+
+    if (this.settings.Logger.Level === 'silent') return
+
+    const shouldLog = TypeGuards.isString(this.settings.Logger.Level) ?
+      logLevels.indexOf(logType) >=
+      logLevels.indexOf(this.settings.Logger.Level) : this.settings.Logger.Level.includes(logType)
+    if (!shouldLog) return
+
+    const content = Logger.formatContent(logArgs)
+
+    if (this.settings.Environment.IsDev) {
+
+      const deviceId = this.settings.Logger?.DeviceIdentifier ?
+        `[${this.settings.Logger.DeviceIdentifier}]` : ''
+
+      const stringify = this.settings.Logger?.StringifyObjects
+
+      this.middleware.forEach(m => m(logArgs, content))
+
+      Logger.coloredLog(
+        {
+          logType: logType as LogType,
+          args,
+          color,
+          deviceIdentifier: deviceId,
+          stringify,
+        },
+      )
+
+    }
+
+    if (!this.settings.Environment.IsDev || this.settings.Logger.alwaysSendToSentry) {
+      try {
+
+        this.middleware.forEach(m => m(logArgs, content))
+        if (['info', 'log'].includes(logType)) {
+
+          this.sentry.captureBreadcrumb(
+            logType,
+            content,
+          )
+        }
+        if (['error'].includes(logType)) {
+          this.sentry.sendLog(args?.[1] || args?.[0])
+        }
+      } catch (e) {
+        // Nothing
+      }
+    }
+  }
+
+  info(...args: LogFunctionArgs) {
+    this.logToTerminal({
+      args,
+      logType: 'info',
+    })
+  }
+
+  error(...args: LogFunctionArgs) {
+    this.logToTerminal({
+      args,
+      logType: 'error',
+    })
+  }
+
+  warn(...args: LogFunctionArgs) {
+    this.logToTerminal({
+      args,
+      logType: 'warn',
+    })
+  }
+
+  log(...args: LogFunctionArgs) {
+    this.logToTerminal({
+      args,
+      logType: 'log',
+    })
+  }
+
+  debug(...args: LogFunctionArgs) {
+    this.logToTerminal({
+      args,
+      logType: 'debug',
+    })
+  }
+}

package/src/Sentry.ts

@@ -0,0 +1,54 @@
+import type { Breadcrumb, ClientOptions } from '@sentry/types'
+import { AppSettings } from '@codeleap/types'
+import {
+  LogFunctionArgs,
+  LogType,
+  SentrySeverityMap,
+  SentryProvider,
+} from './types'
+
+export class SentryService {
+  private sentry: SentryProvider
+
+  private use: boolean
+
+  constructor(settings: AppSettings) {
+    this.use = settings?.Sentry?.enable
+    this.sentry = settings?.Sentry?.provider as SentryProvider
+    if (this.use) {
+      const isDebug = settings?.Sentry?.debug || false
+      if (isDebug) console.log('> > > Initializing Sentry', settings.Sentry)
+      const initObj:ClientOptions = {
+        dsn: settings.Sentry.dsn,
+        debug: isDebug,
+        integrations: [],
+        ...settings?.Sentry?.initArgs,
+      }
+      if (settings?.Sentry?.beforeBreadcrumb) {
+        initObj.beforeBreadcrumb = settings?.Sentry?.beforeBreadcrumb
+      }
+      this.sentry?.init?.(initObj)
+    }
+  }
+
+  captureBreadcrumb(type: LogType, content: LogFunctionArgs) {
+    if (!this.use) return
+
+    const [message, data, category] = content
+
+    const sentryArgs: Breadcrumb = {
+      message,
+      data,
+      category,
+      level: SentrySeverityMap[type],
+      type: '',
+    }
+
+    this.sentry.addBreadcrumb(sentryArgs)
+  }
+
+  sendLog(err?: any) {
+    if (!this.use) return
+    this.sentry.captureException(err)
+  }
+}

package/src/Slack.ts

@@ -0,0 +1,138 @@
+import { inspect } from 'util'
+import { TypeGuards, AppSettings } from '@codeleap/types'
+
+type EchoSlackConfig = AppSettings['Slack']['echo']
+
+type EchoSlack = {
+  label: string
+  data: object
+  options?: EchoSlackOptions
+  module?: string
+}
+
+type OptionInclude = 'version'
+
+type SendIn = 'debug' | 'release'
+
+type EchoSlackOptions = {
+  sendIn?: SendIn[]
+  include?: OptionInclude[]
+}
+
+const DEFAULT_CHANNEL = '#_dev_logs'
+const DEFAULT_BASE_URL = 'https://slack.com/api/chat.postMessage'
+
+export class SlackService {
+  private echoConfig: EchoSlackConfig
+
+  private isDev: boolean
+
+  private appName: string
+
+  public api
+
+  constructor(settings: AppSettings) {
+    this.echoConfig = settings?.Slack?.echo as EchoSlackConfig
+    this.isDev = settings?.Environment?.IsDev
+    this.appName = settings?.AppName
+  }
+
+  async echo(
+    label: EchoSlack['label'],
+    slackData: EchoSlack['data'],
+    moduleName: EchoSlack['module'] = null,
+    messageOptions: EchoSlack['options'] = {}
+  ) {
+    const options = this.parseOptions(messageOptions)
+    const slack = this.parseData(label, slackData, options.info, moduleName)
+
+    const enabled = TypeGuards.isBoolean(this.echoConfig.enabled) ? this.echoConfig.enabled : true
+  
+    if (!options.send || !this.api || !this.echoConfig || !enabled) return
+
+    const settingsData = this?.echoConfig?.options ?? {}
+  
+    try {
+      const data = {
+        'channel': this?.echoConfig?.channel ?? DEFAULT_CHANNEL,
+        text: slack,
+        'username': `${this.appName} Log`,
+        'icon_url': this?.echoConfig?.icon,
+        ...settingsData,
+      }
+  
+      await this.api.post('', data, {
+        baseURL: this?.echoConfig?.baseURL ?? DEFAULT_BASE_URL,
+        headers: {
+          Authorization: `Bearer ${this?.echoConfig?.token}`,
+        },
+      })
+    } catch (err) {
+      console.error('Failed to echo', err, 'logger echoSlack')
+    }
+  }
+
+  private serializers: Record<OptionInclude, (IsDev: boolean) => string> = {
+    version: (IsDev: boolean) => {
+      return IsDev ? 'debug' : 'release'
+    },
+  }
+
+  private parseOptions(options: EchoSlackOptions) {
+    const {
+      sendIn = [],
+      include = [],
+    } = options
+  
+    const hasSendIn = sendIn.length >= 1
+    const isDebug = hasSendIn ? sendIn.includes('debug') : true
+    const isRelease = hasSendIn ? sendIn.includes('release') : true
+  
+    if (!isDebug && this.isDev || !isRelease && !this.isDev) {
+      return {
+        info: '',
+        send: false,
+      }
+    }
+  
+    let str = ''
+    const separator = ' - '
+  
+    include.forEach(k => {
+      const data = this.serializers[k]?.(this.isDev)
+      str = `${str}${str.length > 0 ? separator : ''}[${data}]`
+    })
+  
+    return {
+      info: str,
+      send: true,
+    }
+  }
+  
+  private parseData(label: string, data: object, info: string, module?: string) {
+    const obj = !info ? data : {
+      ...data,
+      info,
+    }
+  
+    const args = [`${!module ? '' : `(${module}) `}${label}: `, obj]
+  
+    const slack = args.map(i => {
+      if (typeof i === 'object') {
+        try {
+          return inspect(i, {
+            depth: 5,
+            compact: false,
+            showHidden: true,
+          })
+        } catch (e) {
+          return `${i} (Unserializable value)`
+        }
+      }
+  
+      return String(i)
+    }).join(' ')
+  
+    return slack
+  }
+}

package/src/constants.ts

@@ -0,0 +1,37 @@
+import { ConsoleColor } from './types'
+import { LogType } from '@codeleap/types'
+
+export const foregroundColors = {
+  Black: '\x1b[30m',
+  Red: '\x1b[31m',
+  Green: '\x1b[32m',
+  Yellow: '\x1b[33m',
+  Blue: '\x1b[34m',
+  Magenta: '\x1b[35m',
+  Cyan: '\x1b[36m',
+  White: '\x1b[37m',
+} as const
+
+export const formatColors = {
+  Reset: '\x1b[0m',
+  Bright: '\x1b[1m',
+  Dim: '\x1b[2m',
+  Underscore: '\x1b[4m',
+  Blink: '\x1b[5m',
+  Reverse: '\x1b[7m',
+  Hidden: '\x1b[8m',
+} as const
+
+export const colors = {
+  ...foregroundColors,
+  ...formatColors,
+}
+
+export const logColors: Record<LogType, ConsoleColor> = {
+  error: 'Red',
+  info: 'White',
+  warn: 'Yellow',
+  debug: 'Magenta',
+  log: 'White',
+  silent: 'Green',
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * as LoggerTypes from './types'
+export * as LoggerAnalytics from './Analytics'
+export * from './Logger'
+export * from './silentLogger'
+export * from './performance'

package/src/obfuscate.ts

@@ -0,0 +1,76 @@
+import { cloneDeep } from '@codeleap/utils'
+import { Matcher } from '@codeleap/types'
+import { inspect } from 'util'
+import parse from 'url-parse'
+
+type ObfuscateArgs = {
+  object: any
+  keys: (Matcher<'key'>)[]
+  values: (Matcher<'value'>)[]
+}
+
+function removeKey(obj, key) {
+  if (obj?.hasOwnProperty(key)) {
+    obj[key] = '[secret]'
+  }
+  for (const subObj in obj) {
+    if (typeof obj[subObj] == 'object') {
+      removeKey(obj[subObj], key)
+    }
+  }
+}
+
+function removeValue(obj, value) {
+  for (const subObj in obj) {
+    const isString = typeof obj[subObj] == 'string'
+    if (isString) {
+      const isRegex = value instanceof RegExp
+      const match = isRegex ? value.test(obj[subObj]) : obj[subObj].includes(value)
+      if (match) {
+        if (obj[subObj].startsWith('http')) {
+          const url = parse(obj[subObj])
+          obj[subObj] = `${url.origin}${url.pathname}/[secret]`
+        } else {
+          obj[subObj] = '[secret]'
+        }
+      }
+    }
+    if (typeof obj[subObj] == 'object') {
+      removeValue(obj[subObj], value)
+    }
+  }
+}
+
+export function obfuscate(args: ObfuscateArgs) {
+  const { object, keys, values } = args
+
+  let isCircular = false
+  try {
+    JSON.stringify(args)
+  } catch (e) {
+    isCircular = true
+  }
+
+  if (typeof object === 'object' && !isCircular) {
+    let cleanData = {}
+    try {
+      cleanData = cloneDeep(object)
+      keys.forEach(fieldName => removeKey(cleanData, fieldName))
+      values.forEach(fieldName => removeValue(cleanData, fieldName))
+    } catch (err1) {
+      try {
+        cleanData = inspect(object, { depth: 1 })
+      } catch (err2) {
+        cleanData = { value: `Couldn't process data` }
+      }
+    }
+    const result = cleanData
+    return result
+  } else {
+    if (isCircular) {
+      return { ...args.object, WARNING: 'Circular reference detected' }
+    } else {
+      return args.object
+    }
+  }
+}

package/src/performance/errors.ts

@@ -0,0 +1,26 @@
+import { InspectRenderOptions } from '.'
+
+type ErrorArgs = InspectRenderOptions & {
+  name: string
+  maxRenders: number
+}
+
+type ErrorNames = 'maxRenders'
+
+const defineError = (errorName: ErrorNames, args: Partial<ErrorArgs>) => {
+  switch (errorName) {
+    case 'maxRenders':
+      return `${args.name} is rendering more than ${args.maxRenders}time per ${
+        args.throttleInterval / 1000
+      }second!
+      If you aware of this, you can disable it in the Settings.ts > Performancer.
+      `
+  }
+}
+
+export class PerformanceError extends Error {
+  constructor(errorName: ErrorNames, args: Partial<ErrorArgs>) {
+    super(defineError(errorName, args))
+    this.name = 'Codeleap:Perf'
+  }
+}

package/src/performance/index.ts

@@ -0,0 +1,86 @@
+import { throttle } from '@codeleap/utils'
+import { useEffect } from 'react'
+import { AppSettings } from '@codeleap/types'
+import { PerformanceError } from './errors'
+
+export type InspectRenderOptions = {
+  noHooks?: boolean
+  logMode?: 'raw' | 'summarized'
+  throttleInterval?: number
+  maxRenders?: number
+}
+
+export type PerformanceInspector = {
+  inspectRender: (name: string, options?: InspectRenderOptions) => void
+}
+
+const renderCounter: Record<string, number> = {}
+
+export function makePerformanceInspector(settings: AppSettings) {
+  /**
+   * inspectRender monitors how much time a component render per second.
+   * Use perf.inspectRender('ComponentName') inside a component to monitor it.
+   * @param {string} name - Component name
+   * @param {PerformanceInspector} options - Some options for the inspector
+   * @returns
+   */
+  const inspectRender = (
+    name: string,
+    options: InspectRenderOptions = {
+      noHooks: false,
+      logMode: 'summarized',
+      throttleInterval: 1000,
+      maxRenders: settings?.PerformanceInspector.maxRenders,
+    },
+  ) => {
+    const blacklist = settings?.PerformanceInspector.blacklist || []
+    if (blacklist.some((item) => name.startsWith(item))) return
+
+    const { noHooks, logMode, throttleInterval, maxRenders } = options
+
+    if (
+      !settings?.PerformanceInspector.enable ||
+      !settings?.Environment.IsDev
+    ) {
+      return
+    }
+
+    if (!noHooks) {
+      useEffect(() => {
+        console.log(`[PerformanceInspector] Mounted -> ${name}`)
+
+        return () => {
+          console.log(`[PerformanceInspector] Unmounted -> ${name}`)
+        }
+      })
+    }
+
+    renderCounter[name] = renderCounter[name] ? renderCounter[name] + 1 : 1
+    const renders = renderCounter[name]
+
+    if (renders > maxRenders) {
+      renderCounter[name] = 0
+      throw new PerformanceError('maxRenders', {
+        name,
+        throttleInterval,
+        maxRenders,
+      })
+    }
+
+    if (logMode === 'raw') {
+      console.log(`[PerformanceInspector] Rendered -> ${name}: ${renders}`)
+      return
+    }
+
+    function logSummary() {
+      if (renders <= 0) return
+
+      console.log(`[PerformanceInspector] Render summary -> ${name}: ${renders}`)
+      renderCounter[name] = 0
+    }
+
+    throttle(logSummary, name, throttleInterval)
+  }
+
+  return { inspectRender }
+}

package/src/silentLogger.ts

@@ -0,0 +1,11 @@
+import { Logger } from './Logger'
+
+export const silentLogger = new Logger({
+  Logger: {
+    Level: 'silent',
+    IgnoreWarnings: [
+      `Require cycle:`,
+      `Require cycles are allowed`,
+    ],
+  },
+})

package/src/types.ts

@@ -0,0 +1,45 @@
+import { FunctionType } from '@codeleap/types'
+import { colors, foregroundColors } from './constants'
+
+import type { SeverityLevel, Client, ClientOptions, Breadcrumb } from '@sentry/types'
+
+export type LogType = 'info' | 'debug' | 'warn' | 'error' | 'log' | 'silent'
+
+export type LogFunctionArgs = [
+    description?: any,
+    value?:any,
+    category?:string
+]
+export type ConsoleColor = keyof typeof colors
+export type DebugColors = {
+  [Property in keyof typeof foregroundColors as `${Lowercase<
+    string & Property
+  >}`]: (...args: LogFunctionArgs) => void;
+}
+export type DebugColor = keyof DebugColors
+export type LogToTerminalArgs = {
+  logType: LogType
+  args: LogFunctionArgs
+  color?: keyof DebugColors
+  deviceIdentifier?: string
+  stringify?: boolean
+  logKeys?: boolean
+}
+export type LogToTerminal = FunctionType<[LogToTerminalArgs], void>
+
+export const SentrySeverityMap: Record<LogType, SeverityLevel> = {
+  debug: 'debug',
+  error: 'error',
+  info: 'info',
+  log: 'log',
+  warn: 'warning',
+  silent: 'log',
+}
+
+export type SentryProvider = {
+  addBreadcrumb: FunctionType<[Breadcrumb], void>
+  init(options: ClientOptions): Client
+  captureException(err: any): void
+}
+
+export type LoggerMiddleware = FunctionType<[arguments: LogToTerminalArgs, formattedContent: string[]], any>