@blackglory/logger-js

npm install --save @blackglory/logger-js

Usage no npm install needed!

<script type="module">
  import blackgloryLoggerJs from 'https://cdn.skypack.dev/@blackglory/logger-js';
</script>

README

logger-js

Install

npm install --save @blackglory/logger-js
# or
yarn add @blackglory/logger-js

API

interface ILog {
  id: string
  payload: string
}

interface IJsonLog {
  id: string
  payload: Json
}

LoggerClient

new LoggerClient({
  server: string
, token?: string
, basicAuth?: {
    username: string
  , password: string
  }
, keepalive?: boolean
, timeout?: number
, heartbeat?: IHeartbeatOptions
})

interface ILoggerClientRequestOptions {
  signal?: AbortSignal
  token?: string
  keepalive?: boolean
  timeout?: number | false
}

interface ILoggerClientRequestOptionsWithoutToken {
  signal?: AbortSignal
  keepalive?: booolean
  timeout?: number | false
}

interface ILoggerClientObserveOptions {
  token?: string
  heartbeat?: IHeartbeatOptions
}

interface IHeartbeatOptions {
  timeout: number
}

write

LoggerClient#write(
  namespace: string
, val: string
, options?: ILoggerClientRequestOptions
): Promise<void>

writeJSON

LoggerClient#writeJSON(
  namespace: string
, val: Json
, options?: ILoggerClientRequestOptions
): Promise<void>

follow

LoggerClient#follow(
  namespace: string
, options?: ILoggerClientObserveOptions
): Observable<ILog>

followJSON

LoggerClient#followJSON(
  namespace: string
, options?: ILoggerClientObserveOptions
): Observable<IJsonLog>

query

LoggerClient#query(
  namespace: string
, query: {
    from?: string
    to?: string
    head?: number
    tail?: number
  }
, options?: ILoggerClientRequestOptions
): Promise<ILog[]>

queryJSON

LoggerClient#queryJSON(
  namespace: string
, query: {
    from?: string
    to?: string
    head?: number
    tail?: number
  }
, options?: ILoggerClientRequestOptions
): Promise<Array<IJsonLog>>

del

LoggerClient#del(
  namespace: string
, query: {
    from?: string
    to?: string
    head?: number
    tail?: number
  }
, options?: ILoggerClientRequestOptions
): Promise<void>

getAllNamespaces

LoggerClient#getAllNamespaces(options?: ILoggerClientRequestOptionsWithoutToken): Promise<string[]>

LoggerManager

new LoggerManager({
  server: string
, adminPassword: string
, keepalive?: boolean
, timeout?: number
})

interface ILoggerManagerRequestOptions {
  signal?: AbortSignal
  keepalive?: boolean
  timeout?: number | false
}

JsonSchema

getNamespaces
LoggerManager#JsonSchema.getNamespaces(
  options?: ILoggerManagerRequestOptions
): Promise<string[]>
get
LoggerManager#JsonSchema.get(
  namespace: string
, options?: ILoggerManagerRequestOptions
): Promise<Json>
set
LoggerManager#JsonSchema.set(
  namespace: string
, schema: Json
, options?: ILoggerManagerRequestOptions
): Promise<void>
remove
LoggerManager#JsonSchema.remove(
  namespace: string
, options?: ILoggerManagerRequestOptions
): Promise<void>

PurgePolicy

getNamespaces
LoggerManager#PurgePolicy.getNamespaces(
  options?: ILoggerManagerRequestOptions
): Promise<string[]>
get
LoggerManager#PurgePolicy.get(
  namespace: string
, options?: ILoggerManagerRequestOptions
): Promise<{
  timeToLive: number | null
  limit: number | null
}>
setTimeToLive
LoggerManager#PurgePolicy.setTimeToLive(
  namespace: string
, val: number
, options?: ILoggerManagerRequestOptions
): Promise<void>
removeTimeToLive
LoggerManager#PurgePolicy.removeTimeToLive(
  namespace: string
, options?: ILoggerManagerRequestOptions
): Promise<void>
setLimit
LoggerManager#PurgePolicy.setLimit(
  namespace: string
, val: boolean
, options?: ILoggerManagerRequestOptions
): Promise<void>
removeLimit
LoggerManager#PurgePolicy.removeLimit(
  namespace: string
, options?: ILoggerManagerRequestOptions
): Promise<void>
purge
LoggerManager#PurgePolicy.purge(
  namespace: string
, options?: ILoggerManagerRequestOptions
): Promise<void>

Blacklist

getNamespaces
LoggerManager#Blacklist.getNamespaces(
  options?: ILoggerManagerRequestOptions
): Promise<string[]>
add
LoggerManager#Blacklist.add(
  namespace: string
, options?: ILoggerManagerRequestOptions
): Promise<void>
remove
LoggerManager#Blacklist.remove(
  namespace: string
, options?: ILoggerManagerRequestOptions
): Promise<void>

Whitelist

getNamespaces
LoggerManager#Whitelist.getNamespaces(
  options?: ILoggerManagerRequestOptions
): Promise<string[]>
add
LoggerManager#Whitelist.add(
  namespace: string
, options?: ILoggerManagerRequestOptions
): Promise<void>
remove
LoggerManager#Whitelist.remove(
  namespace: string
, options?: ILoggerManagerRequestOptions
): Promise<void>

TokenPolicy

getNamespaces
LoggerManager#TokenPolicy.getNamespaces(
  options?: ILoggerManagerRequestOptions
): Promise<string[]>
get
LoggerManager#TokenPolicy.get(
  namespace: string
, options?: ILoggerManagerRequestOptions
): Promise<{
  writeTokenRequired: boolean | null
  readTokenRequired: boolean | null
  deleteTokenRequired: boolean | null
}>
setWriteTokenRequired
LoggerManager#TokenPolicy.setWriteTokenRequired(
  namespace: string
, val: boolean
, options?: ILoggerManagerRequestOptions
): Promise<void>
removeWriteTokenRequired
LoggerManager#TokenPolicy.removeWriteTokenRequired(
  namespace: string
, options?: ILoggerManagerRequestOptions
): Promise<void>
setReadTokenRequired
LoggerManager#TokenPolicy.setReadTokenRequired(
  namespace: string
, val: boolean
, options?: ILoggerManagerRequestOptions
): Promise<void>
removeReadTokenRequired
LoggerManager#TokenPolicy.removeReadTokenRequired(
  namespace: string
, options?: ILoggerManagerRequestOptions
): Promise<void>
setDeleteTokenRequired
LoggerManager#TokenPolicy.setDeleteTokenRequired(
  namespace: string
, val: boolean
, options?: ILoggerManagerRequestOptions
): Promise<void>
removeDeleteTokenRequired
LoggerManager#TokenPolicy.removeDeleteTokenRequired(
  namespace: string
, options?: ILoggerManagerRequestOptions
): Promise<void>

Token

getNamespaces
LoggerManager#Token.getNamespaces(options?: ILoggerManagerRequestOptions): Promise<string[]>
getTokens
LoggerManager#Token.getTokens(
  namespace: string
, options?: ILoggerManagerRequestOptions
): Promise<Array<{
  token: string
  write: boolean
  read: boolean
  delete: boolean
}>>
addWriteToken
LoggerManager#Token.addWriteToken(
  namespace: string
, token: string
, options?: ILoggerManagerRequestOptions
): Promise<void>
removeWriteToken
LoggerManager#Token.removeWriteToken(
  namespace: string
, token: string
, options?: ILoggerManagerRequestOptions
): Promise<void>
addReadToken
LoggerManager#Token.addReadToken(
  namespace: string
, token: string
, options?: ILoggerManagerRequestOptions
): Promise<void>
removeReadToken
LoggerManager#Token.removeReadToken(
  namespace: string
, token: string
, options?: ILoggerManagerRequestOptions
): Promise<void>
addDeleteToken
LoggerManager#Token.addDeleteToken(
  namespace: string
, token: string
, options?: ILoggerManagerRequestOptions
): Promise<void>
removeDeleteToken
LoggerManager#Token.removeDeleteToken(
  namespace: string
, token: string
, options?: ILoggerManagerRequestOptions
): Promise<void>