Skip to main content
100%

Python dual-logging setup (console and log file) supporting different log levels and colorized output

✓ Published0🌍 Public
Aalvinthai
Last edited May 15, 2020
Created on Dec 18, 2020

This example demonstrates a dual-logging setup for Python applications, sending console output and file logs to separate destinations with distinct severity levels and formatting. The code defines a `LogFormatter` class that applies ANSI color codes to console messages based on log level, while writing plain, uncolored records to the log file. It uses the standard `logging` module with `StreamHandler` for stdout and `FileHandler` for file output, configuring the root logger to handle debug through critical messages. A template controls the output format, including timestamps, thread names, and log levels.

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
55% match
Loading thumbnail…

Gist 08eab60dbb32cefc4b2769ddf53fa43e

This example demonstrates a Python helper function for logging during pandas DataFrame method chaining. The code defines `csnap`, which accepts a DataFrame, an optional function (defaulting to `lambda x: x.shape`), and an optional message, then prints the message and logs the function’s result via the `logging` module. It writes debug output to `mylog.log` using a `FileHandler` with a timestamped formatter, and returns the original DataFrame unchanged to preserve chaining. The snippet shows a debugging utility rather than a visual plot, relying on Python’s standard `logging` API.

Aadiamaan92
51% match
Loading thumbnail…

Gist 25342708e9edeb5099b496447772d743

The visualization shows a technique for analyzing log files by measuring time gaps between consecutive timestamped entries. It uses Python’s `datetime.strptime` to parse timestamps from `"YYYY-MM-DD HH:MM:SS.mmm"` formats and calculates differences in milliseconds, flagging intervals exceeding 10 ms. The code filters log lines by keyword using standard file I/O operations and prints matching entries, or reads all lines from a file to identify timing anomalies. This example demonstrates text-based log inspection rather than graphical rendering, relying on Python console output for insights.

JJastor11
50% match
Loading thumbnail…

Python debugging an exception

This example shows a minimal Python script that demonstrates how to catch and format an exception. It deliberately triggers an exception by assigning `1` to `temp` after initially setting it to `None`, then uses `sys.exc_info()` to retrieve the exception type, value, and traceback. The code prints both the string and representation of the exception, and finally formats the full traceback with `traceback.format_exception()`. The output displays the error message and stack trace in the console, illustrating the standard workflow for handling and reporting exceptions in Python.

WWilliamQLiu
50% match
Loading thumbnail…

Created on Cognitive Class Labs

This example demonstrates basic Python programming concepts taught in a Cognitive Class Labs notebook, including printing output, writing comments, and introducing data types like integers and floats. The notebook uses markdown cells for instructional text and code cells that execute `print()` statements to display results, such as "Hello, Python!". The material is sourced from a gist and covers foundational syntax, expressions, and variables, with exercises for learners. No data-visualization libraries are used; the focus is on interactive coding practice within the Jupyter notebook environment.

DDAVINDER
46% match
Loading thumbnail…

Gist e3f5949ff1f99ab4126a

This notebook demonstrates Python string formatting through a series of interactive code cells. It shows how variables like `animal`, `verb`, and `noun` are assigned values and then inserted into template sentences using the `.format()` method from the Python standard library. The examples progress from simple variable printing with `print` statements to building sentences with placeholders like `{noun}` and `{verb}`, which are replaced with actual values, including numbers, demonstrating flexible substitution. The notebook uses standard Python 3 syntax and pandas for data handling, with matplotlib inline plotting enabled for visualization context.

Aakeshavan
46% match
Loading thumbnail…

monitor threads in python

This example monitors the runtime behavior of threads in a Python application. It periodically displays the number of active threads, along with each thread's name, ID, and current call stack. The visualization uses the `sys._current_frames()` API to capture stack frames and `traceback.extract_stack()` to format them for logging. A daemon thread controls the monitoring loop, printing updates every five seconds using Python's `logging` module.

JJastor11
46% match
Loading thumbnail…

Gist 3942570

This visualization renders a real-time terminal log of a Bundler dependency installation. The code captures the text output from `bundle` and displays it as a scrolling monospace feed, using the Canvas API’s `fillText` and `getImageData` to sample pixel colors for a subtle background gradient. It animates each line’s appearance with a d3 transition, fading new entries in while shifting older lines upward, and highlights the final success message in green. The data source is the raw gist text file, parsed line-by-line to drive the display.

Aallyraza
46% match