configurable-logger-example.js

100%

configurable-logger-example.js

✓ Published0🌍 Public

Last edited Nov 22, 2014

Created on Nov 22, 2014

This example demonstrates a configurable logger that prefixes messages with a custom string. The code defines a `createLogger` function that takes a prefix and returns a new logging function, which prepends that prefix to all subsequent arguments before delegating to the original `log` function. The `log` function itself uses `Array.prototype.slice.call` to handle variable arguments and joins them with spaces for console output via `console.log`. The example shows a logger created with the prefix `'MyApp ::'`, then invoked with multiple arguments to produce a prefixed message.

AI-generated description

Similar vizzes

Loading thumbnail…

Logger

This logger module provides color-coded, type-prefixed console output for Node.js applications. It shows how different log levels (error, info, success, debug, etc.) are mapped to distinct chalk colors and console methods, with optional global and module-specific prefixes. The code uses `chalk` for styling, `ramda` for argument processing, and `jsondiffpatch` to display object differences. In non-production environments it enables colored output and uses `util.inspect` for pretty-printed JSON, while production mode uses plain JSON serialization via `toJson`.

RRestuta

60% match

Loading thumbnail…

JS Bin

This example demonstrates a JavaScript function-wrapping utility that intercepts and modifies the behavior of existing functions. The code defines a `wrapper` function, which takes a context object, a function name, and an optional modifier function, then replaces the original function with a proxy that logs arguments or applies custom modifications. Two concrete use cases are shown: wrapping the native `JSON.parse` method to display its arguments in the console, and wrapping a custom `logMsg` function to prepend a prefix to its message. The example uses plain JavaScript (ES5) and relies on the browser console for output.

Aalessioalex

59% match

Loading thumbnail…

A simple logging hook for React

This example shows a React logging hook that provides memoized console methods for component-level debugging. It exposes `useLogger`, `useDebugger`, and `useError` hooks, each returning a bound console function with a prefix. The code uses `useMemo` to cache the logger instances, and stores references to `console.log`, `console.error`, and `console.debug` to avoid React.DOM overriding them. The `logger` function returns a bound function via `Function.prototype.bind`, allowing services like Redux/Thunk to use the same logging utility. No data source or rendering is involved.

Aabonello

57% match

Loading thumbnail…

Gist 56b9c00fb86d733bf6f97d3a27ecb5fd

This example shows a Redux middleware-style logger that visualizes state changes in a React or Redux application. The code exports a `logger` function that wraps a reducer and, for each dispatched action, logs a collapsible group with the action type, the previous state, the action object, and the next state, using `console.group`, `console.log`, and styled `%c` format specifiers with color codes for readability. It relies on the Redux reducer pattern, where `currentState` is implicitly captured, and returns the next state unchanged after logging. No external visualization library is used; the rendering approach is plain browser console output.

Aackuser

56% match

Loading thumbnail…

Gist d4a6d55663d524237c14

This example demonstrates a JavaScript module that automatically instruments an object’s methods to log their arguments and return values to the browser console. It uses the `underscore` library to chain through the object’s functions, wrapping each method with `console.group` and `console.log` calls. The wrapper takes a module and an identifier, replacing each original method with a logging version that preserves the original behavior. The code shows the pattern for debugging or tracing method calls in a modular JavaScript application.

TThomasG77

55% match

Loading thumbnail…

Gist 7ce9df53ac9ec00419634ca3f9e3f772

This example demonstrates a minimal JavaScript module that exports both a default function and a named export. The default function logs and returns a greeting string, while the named export `doStuff` logs a message when invoked. The code uses standard ES module syntax with `export default` and `export const`, and relies on the console API for output. It shows the basic structure of a reusable module, highlighting how default and named exports are defined and accessed. No external libraries or rendering are involved.

Aabernier

54% match

Loading thumbnail…

Winston..

The example demonstrates a Node.js server setup that uses Winston for logging operations. It initializes a Winston logger with both console and file transports, writing log entries to `log/server.log` while also capturing exceptions to a separate file. The code shows how to create a logger instance via `winston.Logger`, configure transports like `winston.transports.Console` and `winston.transports.File`, and record messages using `logger.log('info', ...)` and `logger.info(...)`. The visible data source is the hardcoded log strings, with the rendering approach being text output to console and file.

Aalessioalex

54% match

Loading thumbnail…

JS Bin

This example demonstrates how to intercept and log method calls on a JavaScript object without altering the original function's behavior. It shows a `User` class with a `trackAction` method, which is replaced with a wrapper that logs the arguments to the console while still invoking the original method using `apply` to preserve context. The code relies on ES6 classes, arrow functions, and `Array.prototype.slice` to handle arguments, with output visible in the browser console.

Aalessioalex

54% match