Academic Databases
Explore Our Semantic Databases
STEM & Tech
Math, Physics, CS & Engineering...
Economics
Macro, Micro, Econometrics...
Business
Management, Marketing, Finance...
Health & Life Sciences
Biology, Medicine, Neuroscience...
Humanities & Social Sciences
Psychology, Law, Philosophy, History...
General Studies
General & interdisciplinary studies...
Explore Topics
Features

Building a Non-Blocking Logger in Rust: Channel-Based Logging

Added: 2026-08-07

Deep Dive

Basic Rust programming concepts, specifically ownership, borrowing, lifetimes, and the standard 'Result' type for error handling.

Программирование на Rust 2. Borrow checker. Standard library

Программирование на Rust 2. Borrow checker. Standard library

14.6K

Result<T, E> is an enum that represents either Ok(T) (success with a value) or Err(E) (failure with an error). It is used for error handling in a type-safe way, preventing null pointer errors and providing compile-time guarantees about handling all error cases. The borrow checker ensures that you cannot accidentally ignore error cases. unwrap() extracts the value from Ok(T) and panics if the Result is Err(E). expect() is similar but allows you to provide a custom panic message. These methods are convenient for cases where you're confident the Result will be Ok, but they will panic if the assumption is wrong.

Click to watch →

Rust: An Introduction

Rust: An Introduction

387

Rust is a C-family systems language implementing ownership and borrow checking at compile time to eliminate memory errors. Key concepts include: variables are immutable by default (requiring 'mut'), assignment moves ownership rather than copying, and simple types implement Copy trait for duplication. Functions transfer ownership through returns, and references enable borrowing without moving data. The borrow checker enforces that multiple immutable references are allowed but only one mutable reference exists at any time. Basic types include integers, floats, chars, booleans, arrays, and tuples. Tuples bundle multiple values for returning multiple results. Comparison operators don't require parentheses. The standard library enforces error handling via Result types, catching many bugs at compile time rather than runtime.

Click to watch →

مدیریت ارورها در Rust | راست 15

مدیریت ارورها در Rust | راست 15

390

Rust provides the Result<T, E> enum for handling recoverable errors. This type represents either a successful value (Ok<T>) or an error (Err<E>). The Result type is used throughout the Rust standard library for functions that can fail, allowing callers to handle both success and failure cases. For example, file reading functions return Result<String, Error>, enabling the calling code to handle both successful reads and errors gracefully.

Click to watch →

Rust 101

Rust 101

40.3K

Ownership is Rust's core safety model: every value has exactly one owner at any time. When you create a variable with let, you own that value. You can move ownership to another variable, but the original owner can no longer use it. Mutable variables (let mut) can be changed. Borrowing allows temporary access without transferring ownership: &value (immutable) or &mut value (mutable). You can have one mutable borrow or multiple immutable borrows, but not both simultaneously. Lifetimes determine how long references are valid - no borrow may outlive the thing it was borrowed from. This prevents dangling references and use-after-free errors at compile time. Types and traits work together to enable flexible, type-safe code that can work with many different types while maintaining safety guarantees.

Click to watch →

Python 3.10 — ЛУЧШИЙ релиз после 3.7! Pattern matching, новинки и при чём здесь Rust

Python 3.10 — ЛУЧШИЙ релиз после 3.7! Pattern matching, новинки и при чём здесь Rust

134.3K

Rust uses a 'Result' type that combines a success value (Ok) and an error value (Err). This type forces developers to handle both success and error cases explicitly. When a function returns a Result, the caller must handle both the Ok and Err variants, preventing runtime errors caused by unhandled exceptions.

Click to watch →

Deep Dive

Fundamentals of multithreading in Rust, including spawning threads and understanding the 'Send' and 'Sync' traits.

Multithreading, Message Passing (crossbeam-channel), Arc/Mutex, and Send/Sync - Rust

Multithreading, Message Passing (crossbeam-channel), Arc/Mutex, and Send/Sync - Rust

6.7K

Rust achieves 'Fearless Concurrency' through its type system and ownership model, catching data races and deadlocks at compile time rather than runtime. Concurrency enables running multiple tasks independently, while parallelism executes them simultaneously. Thread spawn creates new threads via closures, while thread sleep yields CPU time enabling interleaving. Thread join waits for spawned threads to complete. Variables must be moved (not borrowed) into threads. Inter-thread communication uses channels: Crossbeam channels support multiple transmitters/receivers with blocking/non-blocking receive. For shared mutable state, Mutex requires locks, while Arc enables shared ownership. Send and Sync traits ensure thread-safe transfer and sharing. These mechanisms enable safe concurrent programming without runtime errors.

Click to watch →

Rust 101 - 25: Threads, Mutexes, channels, Send and Sync

Rust 101 - 25: Threads, Mutexes, channels, Send and Sync

653

Rust provides safe concurrency through threads spawned via `thread::spawn`, with the borrow checker preventing data races by enforcing exclusive access through atomics or mutexes, while Send and Sync traits ensure types can be safely transferred or shared across threads, and channels enable efficient inter-thread communication.

Click to watch →

[SLOWER VERSION] A Firehose of Rust, for busy people who know some C++

[SLOWER VERSION] A Firehose of Rust, for busy people who know some C++

8.7K

Rust supports spawning your own threads (not just the parallel iterators from the standard library). When you spawn threads, you must ensure that the closure passed to the thread doesn't capture references to stack-allocated variables that might be destroyed while the thread is running. Rust's borrow checker prevents this at compile time, ensuring that spawned threads cannot access invalid memory. This is a key safety guarantee that Rust provides for concurrent programming. The borrow checker ensures that spawned threads cannot access invalid memory.

Click to watch →

Programování v Rustu (2024) #7: Parallelism and multi-threading

Programování v Rustu (2024) #7: Parallelism and multi-threading

268

Rust was designed with thread safety as a primary motivation to address C++ problems in Firefox. A data race occurs when multiple threads access the same memory location simultaneously with at least one thread writing, without synchronization. Rust prevents data races at compile time through its ownership and borrowing system, a unique guarantee among mainstream languages. Threads are created using std::spawn with closures. The join handle returned by spawn can wait for threads to complete, blocking until they finish. The join method returns a Result indicating success or panic. Types passed to spawn must either not contain any references or must contain only static references. Data can be moved into threads using the move keyword, transferring ownership. Reference counting (Rc) allows sharing data but is not Send-safe because its clone method is not atomic. The Send trait indicates a type is safe to transfer between threads. Arc<T> (Atomic Reference Counted) is the thread-safe version of Rc, using atomic operations for reference counting. Arc<T> requires T to implement both Send and Sync because when the last reference is dropped, the inner value must be safely transferred to the owning thread.

Click to watch →

Threads - Part 15 of Idiomatic Rust in Simple Steps

Threads - Part 15 of Idiomatic Rust in Simple Steps

1.5K

Threads in Rust are independent execution units within a process that enable concurrent programming, allowing multiple parts of a program to run simultaneously for improved responsiveness and performance. To spawn a thread, use `std::thread::spawn`, which returns a `JoinHandle` that ties the spawned thread to the parent thread; if the handle is dropped, the thread becomes orphaned. Data can be sent between threads using the `Send` trait, which ensures safe transfer between threads. For shared data access across threads, use the `Sync` trait, which allows references to be safely shared. When multiple threads need to access shared data, use a mutex (e.g., `std::sync::Mutex`) to ensure mutual exclusion and prevent race conditions. For shared ownership across threads, use `Arc<T>` (Atomic Reference Count), which provides thread-safe reference counting.

Click to watch →

Deep Dive

Concepts of message-passing concurrency using Rust's standard library channels ('std::sync::mpsc').

Message Passing With Rust MPSC Channels 🦀 Rust Tutorial

Message Passing With Rust MPSC Channels 🦀 Rust Tutorial

10.9K

Rust's message passing channels (implemented in the std::sync::mpsc module) provide a safe mechanism for passing data between threads using a multiple producer single consumer (MPSC) pattern, where multiple senders can push messages into a channel while only one receiver can pull messages out; asynchronous channels have unlimited buffering while synchronous channels require specifying a buffer size, and both types return Result objects for send and receive operations to handle cases where the channel might be closed.

Click to watch →

Введение в язык программирования Rust

Введение в язык программирования Rust

40.8K

Rust provides channels for message-passing concurrency, where data is transferred between threads through channels rather than shared memory. Channels are type-safe and can only transmit specific types. This model prevents data races because each thread has exclusive access to the data it receives. Rust's channels are blocking by default, meaning the sending thread waits until the receiving thread is ready to accept the message. This model is particularly useful for concurrent programming where data integrity is critical.

Click to watch →

Intro to the Rust programming language

Intro to the Rust programming language

177.5K

Rust implements channels for thread communication using two halves (sending and receiving ends), preventing accidental sharing through ownership semantics. Arc (Atomic Reference Counting) enables safe shared-memory concurrency with atomic reference counts. Arc can only provide shared references, ensuring no two threads can mutate the same data simultaneously. Plain data structures like HashMap can be safely shared across threads without internal locking because shared references prevent concurrent mutation.

Click to watch →

MPSC Channel | Rust Language

MPSC Channel | Rust Language

266

MPSC (Multi-Producer Single-Consumer) channels in Rust enable safe, efficient communication between multiple threads by allowing multiple senders to transmit data to a single receiver while preserving message order; the standard sync::mpsc::channel() creates a transmitter-receiver pair where data sent on the sender becomes available on the receiver in the same sequence, and cloning the transmitter allows multiple threads to send data concurrently, with receive_timeout() preventing indefinite blocking by setting a maximum wait time for incoming messages.

Click to watch →

008. Rust — лучше, чем C++ - Степан Кольцов

008. Rust — лучше, чем C++ - Степан Кольцов

32.4K

Rust uses message-passing concurrency through channels for safe multi-threaded communication. Channels allow threads to send and receive data without shared memory, eliminating data races. When data is sent through a channel, ownership is transferred to the receiving thread, preventing concurrent access. Channels can only transfer owned data, not borrowed references, ensuring data remains valid during transfer. This design provides thread-safe concurrent programming without the complexity of shared memory synchronization primitives.

Click to watch →

Deep Dive

Familiarity with the 'log' facade crate in Rust and how a standard synchronous logger typically operates.

Logging with Log | Rust Language

Logging with Log | Rust Language

756

The Log crate in Rust provides a lightweight logging facade that enables developers to implement structured logging with multiple severity levels (Trace, Debug, Info, Warn, Error) through a simple API, requiring a compatible logger implementation like SimpleLogger to produce actual output, and supporting colored output and key-value pairs for enhanced debugging and monitoring capabilities.

Click to watch →

Creating Console/Terminal Apps using Rust Programming + Ratatui - day14

Creating Console/Terminal Apps using Rust Programming + Ratatui - day14

181

Rust logging follows a facade pattern where facade libraries provide unified APIs abstracting over actual logging implementations. The 'log' crate, maintained by the Rust core team, serves as a lightweight facade requiring pairing with a separate logger like 'env_logger' for actual functionality. By default, logging operates at 'error' level, with verbosity controlled through the 'RUST_LOG' environment variable. The 'log' crate provides logging utilities and works with nearly all logger crates. 'env_logger', owned by the Rust CLI working group, offers simple logging for small projects with builder pattern configuration. 'log4rs', developed by Apache, provides advanced features including YAML/programmatic configuration, JSON/pattern encoding, and automatic log rotation through rolling appenders. Each framework serves different needs from quick debugging to production-grade logging.

Click to watch →

Top 10 Rust crates you must know

Top 10 Rust crates you must know

33.7K

The log crate provides a single logging API that abstracts over actual logging implementations. While unlikely to be used directly, it serves as a foundation for other logging crates. Examples include environment_logger (configured via environment variables), pretty_env_logger (provides prettier output), and tracing (bundled with Tokio for structured event-based diagnostic information in async programs).

Click to watch →

Translate Solidity Smart Contracts to Rust - Soroban from Stellar

Translate Solidity Smart Contracts to Rust - Soroban from Stellar

167.3K

In Rust smart contracts, logging is done using 'log!' macro followed by the environment and message arguments. The environment must be passed as the first argument when logging. This is similar to Solidity's console.log but uses the Soroban SDK's log function.

Click to watch →

Rust tracing vs log: Fix Async Logging in 60 Seconds

Rust tracing vs log: Fix Async Logging in 60 Seconds

1.9K

In async Rust, the standard log crate fails when multiple concurrent tasks run because they produce identical log lines with no way to distinguish which request generated which output; tracing solves this by using spans that attach structured fields like request IDs to every event, allowing the subscriber to keep events from different tasks separate even when they interleave on the same thread.

Click to watch →

Logger Refactor

Helper Func

Error Solving

Error Handle

Cleanup

Prop Errors

Channels

Ending

Logger Refactor

2:08

Playing Section

1
Refactoring logger to use channels for non-blocking operations.
2
Aiming to cleanly manage errors and avoid program shutdowns.
3
Discussing a helper function to reduce code duplication.

Deep Dive

Integrating asynchronous runtimes like Tokio to transition from OS-thread-based channels to async-based non-blocking channels.

Rust - Live coding implementation of non-blocking async agents on top of Tokio

Rust - Live coding implementation of non-blocking async agents on top of Tokio

10.1K

Tokio is Rust's async runtime that enables concurrent programming through async functions and channels; it allows multiple async agents to communicate via channels (Sender/Receiver pairs) while running on a single-threaded runtime, enabling efficient non-blocking concurrent execution where agents can send messages, process them, and handle errors through Result types.

Click to watch →

Desktop and editor setup for Rust development

Desktop and editor setup for Rust development

129.8K

Tokio is an asynchronous runtime for Rust that manages concurrent operations efficiently. Key concepts include: (1) Futures represent asynchronous computations that will eventually resolve to values; (2) .then() handles results, while .and_then() chains futures based on successful resolution; (3) The runtime schedules futures on an event loop, enabling non-blocking I/O operations; (4) Async/await syntax simplifies future composition. Understanding combinators like select and join is essential for building complex asynchronous applications. The speaker recommends starting with simpler projects before tackling advanced protocols like Zookeeper integration.

Click to watch →

Ep 1 - Belajar Axum dari 0 - Perkenalan Axum Rust, setup

Ep 1 - Belajar Axum dari 0 - Perkenalan Axum Rust, setup

612

Tokio creates a non-blocking runtime that prevents web applications from becoming unresponsive during I/O operations. When a task encounters blocking time (like database queries), the runtime moves it to another task that can be executed immediately. This is achieved using async functions, which require the 'tokio::main' attribute in the main function. The runtime continues processing other tasks while waiting for blocking operations to complete, similar to a waiter in a restaurant who serves multiple customers without waiting for each order to finish.

Click to watch →

Rinha backend em Rust

Rinha backend em Rust

18.7K

This segment explains Tokio, Rust's asynchronous runtime that enables concurrent execution. The instructor demonstrates how Tokio uses macros like 'tokio::main' to set up an async runtime that executes async functions concurrently without blocking. This is contrasted with synchronous programming where code runs sequentially. The instructor notes that Tokio is the most popular async runtime for Rust web frameworks, similar to how Node.js handles concurrency but with true parallelism.

Click to watch →

Building a simple text editor with iced, a cross-platform GUI library for Rust

Building a simple text editor with iced, a cross-platform GUI library for Rust

83.5K

Loading files synchronously blocks the UI. Upgrade from Sandbox to Application to enable async Rust with Tokio. Application requires implementing Theme, Executor, and Flags associated types. Use Command::perform to execute async futures and convert results to messages. Create a load_file function using Tokio's async file system operations. Return Arc<String> since results may be cloned by the runtime. Use CARGO_MANIFEST_DIR environment variable to construct file paths relative to the project location.

Click to watch →

Deep Dive

Adopting structured logging and diagnostics using the 'tracing' ecosystem for richer application instrumentation.

Creating Console/Terminal Apps using Rust Programming + Ratatui - day14

Creating Console/Terminal Apps using Rust Programming + Ratatui - day14

181

'Tracing' is a structured event-based logging framework maintained by Tokio that records diagnostic information through spans forming tree structures. The 'tracing-subscriber' crate implements the subscriber trait to collect trace events, supporting global installation via 'init()' or staged building for more control. It supports filtering by level and can be layered with multiple subscribers for different contexts. The framework uses events and spans to record execution flow, with parent spans lasting as long as their longest-lived children. Libraries should use tracing traits and macros to collect information for downstream consumers. The 'tracing-appender' crate enables exporting trace data to various destinations.

Click to watch →

RustConf 2019 - Tokio-Trace: Scoped, Structured, Async-Aware Diagnostics by Eliza Weisman

RustConf 2019 - Tokio-Trace: Scoped, Structured, Async-Aware Diagnostics by Eliza Weisman

18.8K

Tracing records structured errors as typed objects (like standard Error type) enabling programmatic interaction - subscribers can downcast, access sources, format with debug/display, and view backtraces. Tracing macros are a superset of log crate macros, making migration straightforward. Adapters record log records as tracing events and vice versa. Performance is optimized: disabled instrumentation costs only one atomic load and branch, filter evaluation is cached, and subscribers only pay for features they need (timestamps, allocations). The ecosystem includes tracing-core, tracing (facade), tracing-format (console logging), tracing-timing (histograms), and other libraries built on the unified instrumentation layer.

Click to watch →

16. API REST con Actix Web | Tokio Tracing | Sesiones prácticas

16. API REST con Actix Web | Tokio Tracing | Sesiones prácticas

634

Tracing is a logging library in the Tokio ecosystem designed for asynchronous environments. It requires 'tracing' and 'tracing-subscriber' dependencies. The library supports library and executable usage patterns, with libraries using tracing without subscribers while executables initialize their own. Tracing provides macros for different log levels and can instrument async functions using attributes. Configuration is done through environment variables like RUST_LOG for log levels and filtering by crate name. Structured logging with key-value fields enables programmatic parsing, with '?' prefix for debug formatting. Multiple output formats are available: default, pretty, and JSON for production. Timestamp formats can be customized to ISO 8601. Conditional compilation allows different formats for debug vs release builds.

Click to watch →

dtrace.conf(24) Eliza Weisman — DTracing Two great tastes…better together

dtrace.conf(24) Eliza Weisman — DTracing Two great tastes…better together

476

Traditional logging fails in async systems because events appear disconnected and out-of-order. At Buoyant, we built contextual logging that attaches client addresses and request paths to events, solving the problem. This evolved into the tracing crate, an application-layer diagnostics library maintained by Tokio. It provides events (single points in time with key-value data) and spans (time periods with RAII-managed entry/exit). The core insight is that async processes behave like distributed systems, requiring similar tracing approaches. The library uses a facade pattern allowing modular subscribers to consume data in different formats, enabling integration into core libraries like Tokio and Hyper.

Click to watch →

De zéro à des milliards de traces, le tracing distribué chez Winamax

De zéro à des milliards de traces, le tracing distribué chez Winamax

196

This section covers adoption strategy and future directions. Successful adoption requires clear documentation, evangelism to team leads, simple integration, and demonstration of value. The biggest barrier is developer resistance - people prefer familiar log-based debugging. Having a champion in each team who advocates for tracing is essential. Future extensions include message brokers (Kafka) to maintain trace links between producers and consumers, and business metrics in spans for faster incident debugging. For non-JavaScript languages (C++, PHP), custom instrumentation libraries are needed since auto-instrumentation is not available.

Click to watch →

Deep Dive

Benchmarking and performance profiling of blocking vs. non-blocking systems using tools like 'Criterion.rs'.

Criterion: A benchmarking tool for Rust

Criterion: A benchmarking tool for Rust

2K

Criterion.rs is a powerful benchmarking crate for Rust that provides statistical analysis, confidence intervals, and visualization capabilities to accurately measure function performance, overcoming the limitations of manual benchmarking which suffers from compiler optimizations, single-input comparisons, and lack of statistical analysis; the crate uses black_box to prevent optimization, supports asynchronous functions via Tokio runtime, and generates detailed HTML reports with charts showing performance across different inputs.

Click to watch →

The One Billion Rows Challenge with criterion and perf

The One Billion Rows Challenge with criterion and perf

6.1K

Criterion is a Rust benchmarking framework providing statistically rigorous performance measurements. It automatically runs benchmarks multiple times, collects timing data, and applies statistical analysis to determine significant differences. The framework handles warmup periods, outlier detection, and confidence interval calculation. Flame graphs visualize call stack distribution of CPU time during program execution, revealing which functions consume the most time and identifying performance bottlenecks. For the weather data challenge, flame graphs showed parsing operations (integer parsing and string searching) dominated execution time. The profiling data guided subsequent optimization decisions, demonstrating the importance of systematic performance engineering.

Click to watch →

Implementing & Benchmarking Stacks & Queues in Rust 🦀! - Rust DSA v2 (part 6)

Implementing & Benchmarking Stacks & Queues in Rust 🦀! - Rust DSA v2 (part 6)

595

Criterion is a Rust benchmarking library for configuring and defining benchmark groups. Setup requires adding it as a dev dependency with html_reports feature. Additional dependencies like newplot are needed for charts. Black_box() creates opaque functions to prevent compiler optimization, ensuring benchmarks measure intended operations. The library provides methods to configure and define groups of benchmarks.

Click to watch →

Making my Voxel Engine faster

Making my Voxel Engine faster

49.2K

Profiling tools like Optic and benchmarking tools like Criterion are essential for measuring code performance. Optic allows developers to collect and analyze timing data for specific functions, while Criterion generates comprehensive benchmark reports with visualizations. The speaker used these tools to identify that their noise library was 10-20 times slower than alternatives, leading to a library switch that significantly improved performance.

Click to watch →

Aulão: Conheça a forma mais moderna de criar serviços web com Spring!

Aulão: Conheça a forma mais moderna de criar serviços web com Spring!

9.7K

This section presents a performance comparison between reactive and blocking APIs. Using a benchmark tool, 1000 concurrent requests were simulated against both implementations. The reactive API achieved approximately 4,600 requests per second compared to 4,118 requests per second for the blocking servlet API. The reactive approach also showed lower median response times due to the absence of blocking waits. This demonstrates that reactive programming can provide significant performance improvements while requiring relatively few code changes to transform a blocking API into a reactive one.

Click to watch →

Deep Dive

Implementing advanced buffering strategies, backpressure handling, and ring buffers (such as the Disruptor pattern) for high-throughput logging.

Episode 201: Martin Thompson on Mechanical Sympathy

Episode 201: Martin Thompson on Mechanical Sympathy

1.3K

The Disruptor pattern addresses high-throughput, low-latency requirements through ring buffer design. Key principles include: (1) Lock-free coordination using ring buffers enables predictable memory access that leverages hardware prefetching, (2) Pre-allocated ring buffers minimize garbage collection pressure and allocation overhead, (3) Design for limited thread-to-core ratios (10 threads on 16 cores performs well, but 100 threads on 16 cores does not). The pattern evolved from practical requirements in financial exchange systems requiring tens to hundreds of thousands of operations per second with minimal jitter. Ring buffers provide sequential memory access that hardware prefetchers can exploit, making them ideal for producer-consumer scenarios.

Click to watch →

Turing's Tarpit Ep06 -- A Game For Hardcore Programmers

Turing's Tarpit Ep06 -- A Game For Hardcore Programmers

517

Ring buffers solve the problem of maintaining a fixed-size collection of recent items by automatically overwriting old entries when new ones exceed capacity. They are ideal for log systems that need to keep only the most recent messages. A ring buffer maintains head and tail pointers, with new items overwriting the oldest entries once capacity is reached. This eliminates the complexity of manual index calculations and bounds checking required when using standard slices. The structure is particularly valuable for crash logging systems where only recent messages are needed for debugging.

Click to watch →

Руслан Черёмин — Disruptor и прочие фокусы

Руслан Черёмин — Disruptor и прочие фокусы

9.5K

Disruptor is a high-performance concurrent ring buffer implementation that achieves approximately 5x higher throughput than standard Java queues by using pre-allocated memory, lock-free operations, and predictable memory access patterns. The key optimizations include: (1) pre-allocating all buffer entries at startup to eliminate garbage collection overhead, (2) using atomic long cursors that are never reset to simplify logic and improve performance, (3) implementing power-of-two buffer sizes with bit masking instead of division for cursor calculations, (4) using padding fields to prevent cache line sharing between concurrent access, and (5) replacing blocking operations with spinning (busy-waiting) for short waits. These techniques enable Disruptor to process millions of transactions per second with minimal latency, making it suitable for high-throughput systems like the London Stock Exchange's trading infrastructure.

Click to watch →

Concurrent Programming with the Disruptor

Concurrent Programming with the Disruptor

3.6K

The Disruptor is a high-performance inter-thread communication pattern designed to solve contention problems in concurrent systems. It uses a ring buffer—a fixed-size array that reuses indices by incrementing from zero—for fast data passing between threads. Sequence barriers enforce happens-before semantics through two protection mechanisms: consumers cannot read until publishers finish writing, and publishers cannot overwrite until consumers process existing entries. Multiple consumer topologies exist: parallel consumers wait on shared barriers for independent processing, diamond-shaped pipelines allow multiple consumers to process the same event simultaneously, worker pools distribute events among threads for variable workloads, and round-robin distribution eliminates contention for evenly distributed workloads by pre-allocating events to specific threads based on sequence numbers.

Click to watch →

Recycle Everything! Techniques for GC and Application Performance - JVM Roundabout - June 2020

Recycle Everything! Techniques for GC and Application Performance - JVM Roundabout - June 2020

156

The Disruptor framework provides high-performance queues for low-latency applications. Replacing standard queues with Disruptor reduces object creation overhead because Disruptor creates new nodes only when objects are returned to the pool. Instead of creating new log event objects for each incoming log, the application borrows events from a pool. This eliminates the overhead of creating new objects for each log entry while maintaining high throughput.

Click to watch →

Logger Refactor

Helper Func

Error Solving

Error Handle

Cleanup

Prop Errors

Channels

Ending

Logger Refactor

2:08

Playing Section

1
Refactoring logger to use channels for non-blocking operations.
2
Aiming to cleanly manage errors and avoid program shutdowns.
3
Discussing a helper function to reduce code duplication.

648 views71:32:03@bit2_CoderOriginal Release: 2026-01-03

This video demonstrates how to create a logger in Rust that handles INFO, DEBUG, WARNING, and ERROR logs, with a focus on making it non-blocking using channels. The instructor shows how to properly handle file operations, manage errors using Result types instead of unwrap(), and implement thread-safe logging using Mutex. The session covers practical aspects of Rust programming including file I/O, error propagation, and concurrent programming patterns, providing beginners with foundational knowledge for building robust logging systems.

[00:00:02]Hey, are we live?

[00:00:08]I think so.

[00:00:12]Uh, let me see.

[00:00:15]Okay, this is good.

[00:00:29]Mhm.

[00:00:32]Uh [snorts] maybe.

[00:00:38]Okay, this is let's do this.

[00:00:47]Okay, we are here.

[00:00:50]And let me see one thing.

[00:00:54]Can I just scroll it over here?

[00:01:12]I think this is good.

[00:01:16]Uh let me just go here.

[00:01:26]Okay, this is on the broader screen.

[00:01:31]This is for the mobile, right?

[00:01:34]Uh this thing.

[00:01:39]Should I? Should I? Should I? Should I?

[00:01:41]Should I or not?

[00:01:44]Maybe I can just shift it over here.

[00:01:53]Let's see how it goes.

[00:01:59][snorts] Sorry.

[00:02:08][snorts] >> [snorts] >> All right. So, hello. Hello. Hello.

[00:02:30]What's up?

[00:02:34]How you doing?

[00:02:42]How you doing?

[00:02:46]Uh, just give me a moment.

[00:02:56]Yep, it just went away.

[00:03:08]Okay. Now, uh let's start. [snorts] So, if you are here, uh you must see the title of part two of whatever we were doing earlier, creating a logger. Uh this time uh what we'll do we'll try to use channel to you know make it non-blocking and we'll try to handle or remove those un like unwraps that we have written to a more something uh more you know clean way [snorts] so that we can handle the errors and we'll generate an error as well for that to see if we are like getting any shutdowns of program or not.

[00:03:59]Okay, [snorts] I hope I am audable.

[00:04:06]Let me start the poll.

[00:04:50]>> [snorts] >> Amazing.

[00:05:15][snorts] So guys, we have a poll running down.

[00:05:25]Make sure you hit that thing.

[00:05:29][snorts] Off for the polls.

[00:05:33]Okay. Uh we'll start now.

[00:05:37][snorts] Uh before that, let me see if everything is going well on the OBS side.

[00:05:48]Okay.

[00:05:55]So last thing that we did was we wrote all these stuff [snorts] and we generated few things so that we can you know see the logs and all.

[00:06:17]Let me just keep an eye on chat as well.

[00:06:24]Okay.

[00:06:26]Uh now [snorts] what we are going to do is uh so here what we did uh we propagated the error up right from here.

[00:06:46]Probably we can do something else.

[00:06:50][snorts] We can create another helper function where uh we can pass in the file name and based on the type we can create this thing info log or something right so this way this would be very clean and but how do I get these things over here.

[00:07:24]Yeah. Uh but that would be I have to do that as well like multiple times.

[00:07:33]Maybe create uh no uh maybe let's start. [snorts] I'm just uh hitting here.

[00:07:58]>> [clears throat] >> So I'll have the the log level as log levels, right? What else do we need? Nothing.

[00:08:20]Yeah, we only need uh love levels. And do we need this?

[00:08:28]Uh here what I'll get? I'll return uh probably I can return mutx uh info file but that info file would be a result of a file.

[00:08:46]Uh can I do something like this?

[00:08:57][snorts] Here I can just say file probably it's not uh it could be an error as well.

[00:09:16]We can and from here maybe based on the log levels we can return this thing.

[00:09:24]What do you think?

[00:09:26][snorts] Yeah, there's pole running down there.

[00:09:31]So, make sure you hit that thing.

[00:09:38][sighs] >> [snorts] [snorts] >> I was just thinking that if I return this thing, you know, so if I return this thing, I can directly say this thing over here.

[00:10:12]So I can, you know, logger info and all.

[00:10:15][snorts] But I need to check uh info file. So if I have open over here returns a result of file and error. So I think yeah so you see the return return type over here of open is result file error and that's what we will return right here.

[00:10:54]So [clears throat] [snorts] if it's uh info, we can uh then open options.

[00:11:26]new, right?

[00:11:34]Read true.

[00:11:42]Uh uh what if I declare something over here and then you know do that? Can I do that?

[00:11:52]Let but I need separate one right if I want to create this Okay.

[00:12:30]I want to create it.

[00:12:33]uh and open I'll do info uh uh this thing I can also you know what does it expect uh string slice right maybe I can just give him a Let's say file birth as string slice I can just say then why I need a log file over here I don't need this right it's a oneliner now so I I think I hope I'm right. Uh I hope so.

[00:13:44]Let's not do this.

[00:13:51]I can simply say file path end.

[00:13:58]Now [snorts] this returns something uh a result right so I can say I can wrap it in mutx here I'll say mutx okay [snorts] now I have some issue here uh Type allocation. I cannot see it on full screen. Uh you know what? Can I do full screen? Uh I think uh going on mobile view is quite you know I cannot see the [snorts] screen much. Uh let me try it with my OBS here. So here is my OBS. You can see probably uh this is what I'm doing right. This is a single uh vertical layout. Maybe I can just switch it to complete desktop layout.

[00:15:00]That be gate.

[00:15:03]Can I do that uh while streaming?

[00:15:06]No sir, I cannot do that.

[00:15:10]Uh let's leave it that way.

[00:15:15][sighs] I'll have to maybe I can just [snorts] open it like full screen.

[00:15:26]Okay. So here I can see the error now.

[00:15:28]As you can see, can you see it now?

[00:15:34]No.

[00:15:36]Let me just stretch it again.

[00:15:40]Yeah. See it says type aliases uh take one generic argument but two are uh were supplied like that.

[00:15:54]So, [snorts] so, so [snorts] if I remove this.

[00:16:16]Okay. Uh, okay. Now, this is done. Uh, get file instance. So instead of now doing this thing open file in all of the cases I can say uh self dot get file instance over here.

[00:16:42]What the heck?

[00:16:45]Get I'm not getting this.

[00:16:59]Okay. Okay. Okay. I think I have to blow here.

[00:17:07]I can What is this?

[00:17:16]self.

[00:17:18]So I have this thing uh get file instance I can do that. So instead of passing this thing I don't need that. I can make it associated.

[00:17:30]So I'll remove this thing.

[00:17:34]Uh I need a file path right? So I'll simply say debug dot log.

[00:17:52]Cool.

[00:17:54]Now [snorts] it says uh yeah now I can simply just shorthand it.

[00:18:02]So let's see.

[00:18:05]Uh it says expectract sync mutx found found uh result. Okay, it needs a file but I found this thing. [snorts] So probably uh I need to have can do something like this.

[00:18:36]uh file.

[00:18:41]I hope you get it.

[00:18:44]A little bit too low to understand what you're saying. Oh, actually I'm talking too slow. Just like uh talking to myself here. Is it okay now?

[00:18:58]Let me check. Hey, hey, hey. Is it okay now?

[00:19:03]The volume I can see is hitting the yellow bar. So I think it is [snorts] pretty audible.

[00:19:16]Yep.

[00:19:17]Thanks for pointing that out.

[00:19:20]Uh error here. So probably we can just uh see error occurred here.

[00:19:43]Uh mismatched type expected this Got that.

[00:19:55]Let me see. Just open it. Found enum. Uh match types expected error.

[00:20:08]Found this.

[00:20:11][snorts] Okay.

[00:20:16][snorts] Uh what is this?

[00:20:27]So it needs this thing right from the struct I declared mutex of file.

[00:20:37]So I'll be getting this thing uh but this is only returning a result of this thing.

[00:20:50]Right.

[00:20:52]So probably maybe maybe maybe this is completely uh maybe we can do something like if I do this uh what is this?

[00:21:16]Okay.

[00:21:21]But maybe we can say okay uh debug file [snorts] equals self uh get file instance and debug file.

[00:21:59][snorts] And then maybe I can just say >> [clears throat] >> cannot find value debug file on the scope.

[00:22:32]What do I use this thing? So let me just [snorts] found enum this uh expected strruct this.

[00:22:45][snorts] How can we uh so it returns uh this thing. I need to have a mutx of file here right. So it returns some mutx file.

[00:23:06]So instead of wrapping it over here, maybe I can just simply do this over here.

[00:23:16]Let's just not do that because and maybe I can then uh it returns result of file and error. Now so I can do it over here.

[00:23:31]So I'll say let tense.

[00:23:51][sighs] I mean, uh, does that make sense?

[00:24:12]Does that make sense?

[00:24:16]Uh, match arms of compatible type expected foil.

[00:24:33]And then here I can uh [snorts] uh this this is found to be of type file. Okay.

[00:24:52]Uh hair.

[00:24:55][snorts] >> [sighs] [snorts] [snorts] [snorts] >> expected file.

[00:25:50]Uh no let's not go here. Uh this has to be handled separately. But over here guys can you uh figure out what is happening here. So match option it will basically it's a result right? Open will return a result of file and an error. So if it's a file I'll return that wrap it in mutx and return from the function. But on the error uh error we have to do something uh [snorts] so maybe maybe let's do this thing.

[00:26:40]Let's open something over here. Uh so I'll say >> [clears throat] [snorts] [snorts] >> So this it returns from the function right? if this thing uh but instead I want to log that error right so we created this thing onto a separate function uh because this open will return a result of this type this you know an error and something so uh yeah this is what it's doing this is what we did right open okay file now we have a file and we did that the exact same thing right where is uh this thing right so [snorts] if we have a file I'll return it and then wrap it in mutx right but in case of error it just using a match statement over here uh if it's not find you could try creating a file here okay but it is expected to return a file [snorts] right uh here is panic for other errors It's a permission denied but but I need to send the file uh right the file file already exists.

[00:28:28][snorts] >> [snorts] >> it is creating a new file and returning it and on the other cases it is just panicking right so maybe we can do that as well if you are handling the thing but this could be an error here the file result is open file handling And again it's using a match here because it's returning a result of file probably.

[00:29:18]Uh maybe we can uh do this thing. Is this on your GitHub? Uh not right now.

[00:29:26]I forgot to push [snorts] Maybe I can Let me just do that.

[00:29:42]Uhoh.

[00:29:51][snorts] Uh, let's not put this thing.

[00:30:23]So, so, so, so this is >> [snorts] >> Yeah, give me a minute. I will just upload it.

[00:30:43][sighs] >> [snorts] [snorts] >> Can you see it now?

[00:31:48][snorts] [snorts] >> [snorts] [snorts] [snorts] [snorts] [snorts] >> It's late here. I'll check tomorrow if you put it up there. Okay. Okay. Sure.

[00:33:45]Sure. Sure. Yep.

[00:33:48][snorts] >> [snorts] [snorts] [snorts] [snorts] [snorts] [snorts] [snorts] >> Anyways, [snorts] [snorts] [snorts] uh [sighs] yeah. [snorts] So maybe we can do this based on the error kind. We can do this or or over here on this thing we can either create a new file because the file could not be there right.

[00:35:28]So maybe we can do that or [snorts] or or we can simply do this. So let me just maybe All right. So scroll it up.

[00:35:49]>> [snorts] >> So [snorts] file name we can Okay. Uh no no file create.

[00:36:42]>> [snorts] >> Maybe we can return open options here again. Then uh we'll be in loop there.

[00:36:54][snorts] It says consider using uh result expect.

[00:37:12][snorts] >> [snorts] [snorts] [snorts] >> So this okay but I think we should handle it that way that we were doing earlier.

[00:38:29]Uh you know using match statement.

[00:38:35]So this is it and here it is I'm getting this thing right.

[00:38:47]It is returning either this and it will return a file. [snorts] So this will probably I don't have to now do this thing because I'll get Cool.

[00:39:25]Now instead of this maybe I can directly do this.

[00:39:41]No, that is it. Now [snorts] let's remove all this thing and use this uh >> [snorts] >> Maybe we can pass it all the file names on the new functions as well. Uh you know what I mean?

[00:40:23]So instead of getting it like manually typing it here we can you know I mean we have to manually type it somewhere but not here on the new when we initiate this thing. Uh self dot so we'll have errors.log log.

[00:40:46]Right. So, it's pretty clean now.

[00:41:02]What is this?

[00:41:04]Info.log.

[00:41:08][snorts] Right now I can simply just do this.

[00:41:24][snorts] So the new is now very concise right instead of all those writing uh we have written it over here based on the file path it will generate this thing correct [snorts] now yeah I was saying that uh you know on the new over here we can get the file name like this [snorts] uh we can get something like info Debug [clears throat] warning.

[00:42:20]Maybe [snorts] I don't know if these are maybe I can get something I can Okay.

[00:42:43]Right. And over here I can just pass in info log error log [snorts] and debug log right uh now that [snorts] it's uh written in new guys only four votes we have till now uh so if you have any questions feel free to come on chat feel free to visit chat Don't take it. Okay. Uh new here. Right.

[00:43:47]So this is good. Now instead of multiple lines over here, we just wrote this uh [snorts] uh format logs is written over here. And this this this this.

[00:44:07]Okay.

[00:44:10]uh unwrap.

[00:44:14][snorts] Maybe instead of doing this we should propagate it on top. We should propagate the error on top and then handle there.

[00:44:22]What do you think? [snorts] Am I right? Am I right?

[00:44:30]Hm.

[00:44:36]Uh, what if I instead of it only used where uh results is used, right? So, but it's not returning anything. So we can return a result from here and then handle those errors on the main function from the main file that we are calling. So this way if we have any error over here the things we are calling from there we can handle the errors over there.

[00:45:15][snorts] Right? Uh so what do we want here? uh we want result uh so I don't need anything if it's uh okay but for error I need uh error which [snorts] okay uh result this from this. Okay, we need to do an okay over here because this unwrap we need to figure out what unwrap returns or what this thing returns, right?

[00:46:16]What it returns is an result of this an error. Error is considered an error if not all bytes returned to the IU errors.

[00:46:23]Okay.

[00:46:26]>> [snorts] >> So this is it result and okay it will return an error. So it's an IO result.

[00:46:39]Okay. And Uh, what's up?

[00:47:15]Hello.

[00:47:17]>> [snorts] >> Hello. Hello.

[00:47:28]What's your name, buddy?

[00:47:32][snorts] >> [snorts] >> Yes, I can see that. That's your handle.

[00:48:00][snorts] [sighs] [clears throat] >> [snorts] [snorts] [snorts] >> phone micro file.

[00:48:44]This is gone, right?

[00:48:47]Uh [snorts] guys, how do we like uh return it?

[00:48:56]Uh no no.

[00:48:59][snorts] Okay.

[00:49:15][snorts] So the thing is if I will return it from here the operation is already done right. So it will like flush and all like this file dot flush.

[00:49:31]So [snorts] can say error in writing all byes to file.

[00:49:53]I can do that.

[00:49:55][snorts] Yeah.

[00:50:00]Uh the same goes for here as well.

[00:50:04]Maybe I can.

[00:50:08][snorts] Yes. Yes. Yes.

[00:50:21][snorts] Mayonnaise.

[00:50:46]again the same message. Let me just copy it.

[00:51:03]video format.

[00:51:11][snorts] Uh next time maybe getting uh so there is a new feature on YouTube studio where uh like I used to do earlier I used to you know For the mobile view, I used to create a vertical layout. That's what I'm doing right now.

[00:51:56]But, uh, YouTube Studio has a new feature feature that allows you to stream on both ways. It's a new feature.

[00:52:08]So, I'll try it on in my next stream. So I'll have to do is I have to stream on the desktop view and it will automatically clip the uh clip uh for vertical layout for me.

[00:52:31][snorts] Let me just show you. So here is my another screen that has this thing over here chat window and all. So if I go over here uh how do I go this maybe I can do this. Yeah you see there is a vertical layout over here as well.

[00:52:51]So this is the new feature.

[00:52:57]Go there. Go there.

[00:53:03]Yeah. [sighs] [snorts] Okay.

[00:53:33]>> [snorts] >> How is the weather? [sighs] It is bad.

[00:53:42]What kind of coding is What kind of coding is this?

[00:53:55][snorts] What kind of coding is this? This is Rust.

[00:54:03]Nothing fancy, just some stupid stuff.

[00:54:07][snorts] >> [sighs] >> Yeah.

[00:54:22]Are you into coding?

[00:54:25]Is it Java, Python, C++? So, yeah, it's Rust.

[00:54:30]Rust.

[00:54:42]>> [snorts] >> Okay. So, I hope this is not an error. Maybe let's remove this thing error kind as well.

[00:54:57]And let's remove this initial layout as well.

[00:55:07]So we are good. We have some issue on main file. Why is that?

[00:55:24]Are you a computer? I am working as a software engineer and I am a bachelor of computer. I did bachelor's in computer science.

[00:55:42]So it takes this thing, right? So I'll have to do this info dot log [sighs] uh debug.log log warning.

[00:56:04][snorts] Cool. Where did you complete your degree?

[00:56:18]I have two degrees basically. So one I have it from uh from college UTU uh it's a university second I have BCA as well it's open.

[00:56:48][snorts] Is there snow falling on your side, bro?

[00:56:53]No.

[00:56:54]Slow snow. Uh [snorts] [snorts] >> [cough] [clears throat] >> through coding.

[00:57:39]>> [sighs] >> I think uh we should always skill up. So I'm [snorts] not sure what's your age but if you are a kid right now or you know learning then it's a very wrong question in this era.

[00:58:00]uh when I was a kid not kid when I just saw first time computer then I thought of hacking something Wi-Fi is a different thing but yes so there are tools that you can use to hack Wi-Fi so if you [snorts] uh go in through Kali Linux there is a dro of this so uh on their website you can see the all the certifications to be an ethical hacker.

[00:58:34]So, they won't just teach you how to hack Wi-Fi or, you know, crack any password. They'll they'll tell you how to do things ethically.

[00:58:45]So, maybe you should give it a try there.

[00:58:55][snorts] >> [snorts] >> Linux can't be fine in Google. What?

[00:59:17][snorts] [sighs] What the hell?

[00:59:27]>> [snorts] [snorts] >> Okay. [snorts] [sighs] So, okay. So, this is the blocking way to do. So how to make it non-blocking is we can use channels over here and uh uh we can use channels over here. For that maybe we can create you know these are the things.

[01:00:18]So for that to show I [snorts] did a tour of bro. Very beautiful place. Merry on your side.

[01:00:27]Yeah. Yes. Nice. Nice. [snorts] I have been to both the places uh like many times.

[01:00:39]Uh so it's beautiful.

[01:00:48]>> [snorts] [snorts] >> So let's create another file over here.

[01:01:08]Uh let's name it uh n blocking ops.

[01:01:19]RS [snorts] is hacking a crime?

[01:01:24]Yes.

[01:01:27]If you do it without consent, it's a crime.

[01:01:36]Uh [sighs] [clears throat] [snorts] but uh you can you know help other people's by doing this crime that is called ethical crime ethical hacking. [snorts] So industries, organizations and other some you know that are uh digitally there online they take help of ethical hackers to make their network or their system secure.

[01:02:14][sighs] What do you think where I am?

[01:02:22]I'm from India.

[01:02:27]>> [snorts] >> foundity ownable and basically Wi-Fi driver. Okay, cool. Now we are talking and what was that? [snorts] >> [snorts] [sighs] >> uh uh yeah.

[01:03:20]So we can have this thing channel uh clone we can thread dotspawn here.

[01:03:27]It's the first thread and from here we can we can do something like this right we'll create a channel this channel will have all these things transmitter and a receiver.

[01:03:46]So as soon as any any error occurs it will send it will you know transmit a log. Just give me a minute.

[01:04:06]Is there God according to you?

[01:04:22]Is there God according to your computer knowledge?

[01:04:28][snorts] I'm not sure.

[01:04:32]What do you think?

[01:04:37][sighs] [clears throat] >> [snorts] [snorts] [sighs] [sighs] [snorts] [snorts] [snorts] [clears throat] [snorts] >> Just give me a minute, guys. I'll be back. [sighs] Repausing my camera. I need to go somewhere. I need to relieve myself.

[01:24:23]I am back.

[01:24:25]Uh, what's that?

[01:24:53]Extreme bit rate is lower.

[01:24:57][sighs] [snorts] What is this? What is this?

[01:25:14]I don't think the bit is lower.

[01:25:28]>> [sighs] [snorts] [sighs] [clears throat] [sighs] >> Uh C++ why I mean uh why you need to which are you a C++ dev.

[01:26:42][snorts] I don't need to switch just for hype.

[01:26:53][clears throat] Oh gosh.

[01:27:14][sighs] Green, green, green, green, green.

[01:27:49]>> [snorts] [snorts] [snorts] >> just curious to learn. I have been hearing a lot about rest lately. So if you are from C or C++ background, it would be fairly easy for you to move along. But if you uh [snorts] >> [snorts] [snorts] [snorts] >> Okay.

[01:30:39]Yeah. So, we have to uh where were we?

[01:30:43]We can use this thing uh channels to make our logger uh nonb blocking. [snorts] So how we are going to do this? Uh we have created a separate file for that right.

[01:30:59]So we have a blocking code on a separate file and a non-blocking code on a separate file. The time is uh should I do this? [snorts] [snorts] I have to eventually leave the stream in half an hour only.

[01:31:27]So I'm not sure should I do this or no?

[01:31:31]Okay. So I think I will close the stream now. [snorts] Uh we can do it next time.

[01:31:37]So I have to go somewhere and I like after half an hour. So thank you very much for coming on the stream and I'll see you next time.

[01:31:56]Bye guys.

Up Next

Understanding the SHA-1 Secure Hashing Algorithm in Cryptography

@Computerphile

1.3M views•2017-04-11

BitTorrent Protocol Explained: Piece Selection & Peer Choking

@StevenGordonAU

481 views•2013-02-22

HTTP Requests Explained: GET, POST, PUT, DELETE

@codecademy

103.1K views•2021-10-07

Enigma Machine Mechanics: WWII Encryption Explained

@JaredOwen

13.2M views•2021-12-11

Related Study Plans & Knowledge Roadmaps

Structured learning paths in Computer Science

View All Computer Science Topics

computer-science

Building BitTorrent: Go, P2P & Concurrency

01Go Fundamentals & Concurrency

02Networking Foundations & P2P Architecture

03Bencode Parsing & Torrent Metadata

+ 3 more learning modules

Explore Roadmap

computer-science

Actor Models (C++ Concurrency & Lock-Free)

01C++ Multi-Threading Foundations

02Thread Pools and Task Scheduling

03Atomics and Lock-Free Queue Design

+ 3 more learning modules

Explore Roadmap

computer-science

Coding HM Type Inference: Algorithm W & OCaml

01Introduction to Functional Programming & OCaml

02Abstract Syntax Trees & Language Interpreters

03Type Systems & Lambda Calculus

+ 2 more learning modules

Explore Roadmap

computer-science

Building OAuth 2.0: Node.js OIDC Server

01Web & Security Foundations

02Authentication vs. Authorization & JWTs

03The OAuth 2.0 Protocol & Grant Types

+ 3 more learning modules

Explore Roadmap