diff --git a/README.md b/README.md
index 7fb39f4..9c8e344 100644
--- a/README.md
+++ b/README.md
@@ -5,24 +5,25 @@
 [![](https://img.shields.io/badge/docs.rs-spdlog--rs-ff69b4?style=flat-square&logo=rust)](https://docs.rs/spdlog-rs)
 [![](https://img.shields.io/github/actions/workflow/status/SpriteOvO/spdlog-rs/ci.yml?branch=main&style=flat-square&logo=githubactions&logoColor=white)](https://github.com/SpriteOvO/spdlog-rs/actions/workflows/ci.yml)
  
-A fast and combinable Rust logging crate, inspired by the C++ logging library [spdlog].
+Fast, highly configurable Rust logging crate, inspired by the C++ logging library [spdlog].
 
 ## Features
 
  - Very fast (see [Benchmarks]).
- - Various log targets:
-    - Standard streams with optional colors.
-    - Files.
-    - Rotating log files by file size.
-    - Rotating log files hourly.
-    - Rotating log files daily.
-    - ... (more targets are implementing, PRs are welcome)
-    - Extendable with custom log targets.
- - Compatible with [log crate] (optional).
  - Asynchronous support.
- - Configured via environment variable.
- - Custom formatting.
- - Log filtering - log levels can be modified in runtime as well as in compile time.
+ - Compatible with `log` crate.
+ - Custom log formats:
+   - compile-time zero-cost pattern or runtime pattern;
+   - manually implementing for more flexibility.
+ - Various combinable sinks:
+    - standard streams with optional color support;
+    - files (single file, rotating hourly, daily or by file size);
+    - platform-specific (e.g. `journald` for Linux and `OutputDebugStringW` for Windows);
+    - ... and able to implement one yourself.
+ - Configuring via environment variables or TOML[^1].
+ - More readable level filters.
+
+[^1]: TOML deserialization support is working in progress, tracking issue [#25]
 
 ## Getting started
 
@@ -32,11 +33,11 @@ Add this to `Cargo.toml`:
 spdlog-rs = "0.3"
 ```
 
-The documentation of this crate is hosted on [docs.rs], and you can find examples under [./examples] directory.
+The documentation of this crate is hosted on [docs.rs], and you can learn examples under [./examples] directory along with it.
 
-If you have any questions or need help while using this crate, feel free to [open a discussion]. For feature requests or bug reports, please [open an issue].
+If you have any trouble while using this crate, please don't hesitate to [open a discussion] for help. For feature requests or bug reports, please [open an issue].
 
-## Supported Rust Versions
+## Supported Rust versions
 
 <!--
 When updating this, also update:
@@ -55,22 +56,18 @@ The current minimum supported Rust version is 1.56.
 
 Licensed under either of
 
- * Apache License, Version 2.0
-   ([LICENSE-APACHE](/LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license
-   ([LICENSE-MIT](/LICENSE-MIT) or http://opensource.org/licenses/MIT)
+ * Apache License, Version 2.0 ([LICENSE-APACHE](/LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license ([LICENSE-MIT](/LICENSE-MIT) or http://opensource.org/licenses/MIT)
 
 at your option.
 
 ## Contribution
 
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
-dual licensed as above, without any additional terms or conditions.
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
 
 [spdlog]: https://github.com/gabime/spdlog
 [Benchmarks]: https://github.com/SpriteOvO/spdlog-rs/blob/main/spdlog/benches/README.md
-[log crate]: https://crates.io/crates/log
+[#25]: https://github.com/SpriteOvO/spdlog-rs/issues/25
 [./examples]: https://github.com/SpriteOvO/spdlog-rs/tree/main/spdlog/examples
 [docs.rs]: https://docs.rs/spdlog-rs/
 [open a discussion]: https://github.com/SpriteOvO/spdlog-rs/discussions/new
diff --git a/spdlog/Cargo.toml b/spdlog/Cargo.toml
index edcbf7e..4b0f831 100644
--- a/spdlog/Cargo.toml
+++ b/spdlog/Cargo.toml
@@ -147,8 +147,8 @@ name = "ftlog_3_level_off"
 path = "benches/ftlog/3_level_off.rs"
 
 [[example]]
-name = "06_compatible_with_log_crate"
+name = "06_log_crate"
 required-features = ["log"]
 [[example]]
-name = "07_async_pool_sink"
+name = "07_async"
 required-features = ["multi-thread"]
diff --git a/spdlog/examples/01_default_logger.rs b/spdlog/examples/01_default_logger.rs
deleted file mode 100644
index 8560cf6..0000000
--- a/spdlog/examples/01_default_logger.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-use std::{
-    sync::Arc,
-    time::{SystemTime, UNIX_EPOCH},
-};
-
-// All log macros and common types are already under `spdlog::prelude` module.
-use spdlog::prelude::*;
-
-fn main() {
-    info!("program started");
-
-    // Loggers only log 'info' level and more severe records by default,
-    // you can modify the level filter of the default logger to enable all levels.
-    let default_logger: Arc<Logger> = spdlog::default_logger();
-    default_logger.set_level_filter(LevelFilter::All);
-
-    trace!(
-        "current unix timestamp: {:?}",
-        SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap()
-            .as_secs()
-    );
-
-    // Replacing the default logger.
-    //
-    // Suppose `new_logger` is the new default logger you want, we'll explain how to
-    // build loggers in later examples.
-    let new_logger: Arc<Logger> = spdlog::default_logger();
-    let old_logger: Arc<Logger> = spdlog::swap_default_logger(new_logger);
-
-    debug!(
-        "the name of the old default logger: {:?}",
-        old_logger.name()
-    );
-
-    info!("program exit");
-}
diff --git a/spdlog/examples/01_macro.rs b/spdlog/examples/01_macro.rs
new file mode 100644
index 0000000..5fedf92
--- /dev/null
+++ b/spdlog/examples/01_macro.rs
@@ -0,0 +1,20 @@
+// All log macros and common types are under `spdlog::prelude` module.
+use spdlog::prelude::*;
+
+fn main() {
+    // Writes a log at "info" level with the info level, and this log will be
+    // processed by the global default logger - It will be output to `stdout`.
+    info!("program started");
+
+    let file = "config.json";
+
+    // They will be output to `stderr`.
+    error!("failed to open file: {}", file);
+    warn!("undetermined locale, defaults to `en_US.UTF-8`");
+
+    // Level "trace" and "debug" will be ignored by default, you can modify the
+    // level filter of the global default logger to enable all levels.
+    spdlog::default_logger().set_level_filter(LevelFilter::All);
+
+    trace!("position x: {}, y: {}", 11.4, -5.14);
+}
diff --git a/spdlog/examples/02_building_logger.rs b/spdlog/examples/02_building_logger.rs
deleted file mode 100644
index 6128fa2..0000000
--- a/spdlog/examples/02_building_logger.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-use std::sync::Arc;
-
-use spdlog::{prelude::*, sink::Sink};
-
-fn main() -> Result<(), spdlog::Error> {
-    // Building loggers
-    //
-    // A logger can combine multiple sinks, we'll explain how to build sinks in
-    // later examples. Here we clone sinks of the default logger so that we can see
-    // the output in our terminal.
-
-    let sinks: Vec<Arc<dyn Sink>> = spdlog::default_logger().sinks().to_owned();
-    let mut builder: LoggerBuilder = Logger::builder();
-    let builder: &mut LoggerBuilder = builder.sinks(sinks).level_filter(LevelFilter::All);
-
-    let gui: Logger = builder.name("gui").build()?;
-    let network: Logger = builder.name("network").build()?;
-    let settings: Logger = builder.name("settings").build()?;
-
-    // Logging with our loggers instead of the default logger.
-
-    info!(logger: gui, "user clicked 'check for updates'");
-
-    info!(logger: network, "connect to the update server");
-    warn!(logger: network, "failed to connect: {}. retry 1", "timeout");
-    warn!(logger: network, "failed to connect: {}. retry 2", "timeout");
-    info!(logger: network, "connection established");
-    info!(logger: network, "fetched the latest version: {}", "v1.2.3");
-    trace!(logger: network, "disconnect by client");
-
-    info!(logger: gui, "ask user for the update");
-    info!(logger: gui, "user clicked 'update now'");
-
-    info!(logger: network, "connect to the download server");
-    info!(logger: network, "connection established");
-    info!(logger: network, "file size: {} bytes", 123456);
-    info!(logger: network, "downloading...");
-    trace!(logger: network, "downloading... {} %", 0);
-    trace!(logger: network, "downloading... {} %", 25);
-    trace!(logger: network, "downloading... {} %", 50);
-    trace!(logger: network, "downloading... {} %", 75);
-    trace!(logger: network, "downloading... {} %", 100);
-    info!(logger: network, "download completed");
-    trace!(logger: network, "disconnect by client");
-
-    info!(
-        logger: gui,
-        "user selected 'check for updates' as '{}'", "daily"
-    );
-
-    info!(
-        logger: settings,
-        "change `updates_check_period` to {}s",
-        24 * 60 * 60
-    );
-    info!(logger: settings, "settings saved");
-
-    Ok(())
-}
diff --git a/spdlog/examples/02_file.rs b/spdlog/examples/02_file.rs
new file mode 100644
index 0000000..519498c
--- /dev/null
+++ b/spdlog/examples/02_file.rs
@@ -0,0 +1,42 @@
+use std::{env, sync::Arc};
+
+use spdlog::{
+    prelude::*,
+    sink::{FileSink, RotatingFileSink, RotationPolicy},
+};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    configure_file_logger()?;
+    configure_rotating_file_logger()?;
+
+    Ok(())
+}
+
+fn configure_file_logger() -> Result<(), Box<dyn std::error::Error>> {
+    let path = env::current_exe()?.with_file_name("file.log");
+
+    let file_sink = Arc::new(FileSink::builder().path(path).build()?);
+    let new_logger = Arc::new(Logger::builder().sink(file_sink).build()?);
+    spdlog::set_default_logger(new_logger);
+
+    info!("this log will be written to the file `all.log`");
+
+    Ok(())
+}
+
+fn configure_rotating_file_logger() -> Result<(), Box<dyn std::error::Error>> {
+    let path = env::current_exe()?.with_file_name("rotating.log");
+
+    let file_sink = Arc::new(
+        RotatingFileSink::builder()
+            .base_path(path)
+            .rotation_policy(RotationPolicy::Daily { hour: 0, minute: 0 })
+            .build()?,
+    );
+    let new_logger = Arc::new(Logger::builder().sink(file_sink).build()?);
+    spdlog::set_default_logger(new_logger);
+
+    info!("this log will be written to the file `rotating.log`, and the file will be rotated daily at 00:00");
+
+    Ok(())
+}
diff --git a/spdlog/examples/03_file_sink.rs b/spdlog/examples/03_file_sink.rs
deleted file mode 100644
index 3f3ac7d..0000000
--- a/spdlog/examples/03_file_sink.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-use std::{env, fs, path::PathBuf, sync::Arc, time::Duration};
-
-use spdlog::{prelude::*, sink::FileSink};
-
-fn main() -> Result<(), spdlog::Error> {
-    const LOG_FILE: &str = "logs/file_sink.log";
-
-    let path: PathBuf = env::current_exe().unwrap().parent().unwrap().join(LOG_FILE);
-
-    let file_sink: Arc<FileSink> =
-        Arc::new(FileSink::builder().path(&path).truncate(true).build()?);
-
-    // Building a logger uses the `file_sink`.
-    // All logs to this logger will be written to file "example_logs/file_sink.log".
-    let logger: Arc<Logger> = Arc::new(Logger::builder().sink(file_sink).build()?);
-
-    // Usually, if flush is relatively expensive for sinks, they do not
-    // automatically flush on verbose levels by default, or even never,
-    // depending on the sink implementation. However, they always do a final flush
-    // when they are dropped.
-    //
-    // There are two automatic flush policies, and they can work together:
-    //  - `Logger::set_flush_level_filter`
-    //  - `Logger::set_flush_period`
-    // For their description, see the documentation.
-
-    // Flush when log "warn" and more severe logs.
-    logger.set_flush_level_filter(LevelFilter::MoreSevereEqual(Level::Warn));
-
-    // Flush every 10 seconds.
-    logger.set_flush_period(Some(Duration::from_secs(10)));
-
-    info!(logger: logger, "hello");
-    warn!(logger: logger, "world");
-
-    drop(logger);
-
-    println!(
-        "contents of file '{}':\n{}",
-        LOG_FILE,
-        fs::read_to_string(path).unwrap()
-    );
-
-    Ok(())
-}
diff --git a/spdlog/examples/03_logger.rs b/spdlog/examples/03_logger.rs
new file mode 100644
index 0000000..2abbbba
--- /dev/null
+++ b/spdlog/examples/03_logger.rs
@@ -0,0 +1,60 @@
+use std::{env, sync::Arc, time::Duration};
+
+use spdlog::{
+    prelude::*,
+    sink::{FileSink, Sink},
+};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // `spdlog-rs` has a global default logger and logs will be processed by it
+    // by default, You can configure it.
+    let default_logger = spdlog::default_logger();
+    default_logger.set_level_filter(LevelFilter::All);
+
+    // Or completely replace it with a new one.
+    let path = env::current_exe()?.with_file_name("all.log");
+    let file_sink = Arc::new(FileSink::builder().path(path).build()?);
+
+    let new_logger = Arc::new(
+        Logger::builder()
+            .level_filter(LevelFilter::All)
+            .flush_level_filter(LevelFilter::MoreSevereEqual(Level::Warn))
+            .sink(file_sink.clone())
+            .build()?,
+    );
+    new_logger.set_flush_period(Some(Duration::from_secs(3)));
+    spdlog::set_default_logger(new_logger);
+
+    info!("this log will be written to the file `all.log`");
+
+    // In addition to having the global default logger, more loggers are allowed to
+    // be configured, stored and used independently.
+    let db = AppDatabase::new(file_sink)?;
+    db.write_i32(114514);
+
+    Ok(())
+}
+
+struct AppDatabase {
+    logger: Logger,
+}
+
+impl AppDatabase {
+    fn new(all_log_sink: Arc<dyn Sink>) -> Result<Self, Box<dyn std::error::Error>> {
+        let path = env::current_exe()?.with_file_name("db.log");
+        let db_file_sink = Arc::new(FileSink::builder().path(path).build()?);
+
+        let logger = Logger::builder()
+            .name("database")
+            .level_filter(LevelFilter::All)
+            .flush_level_filter(LevelFilter::MoreSevereEqual(Level::Warn))
+            .sinks([all_log_sink, db_file_sink])
+            .build()?;
+        Ok(Self { logger })
+    }
+
+    fn write_i32(&self, value: i32) {
+        // This log will be written to both files `all.log` and `db.log`.
+        trace!(logger: self.logger, "writing value {} to the database", value);
+    }
+}
diff --git a/spdlog/examples/05_custom_formatter.rs b/spdlog/examples/04_format.rs
similarity index 82%
rename from spdlog/examples/05_custom_formatter.rs
rename to spdlog/examples/04_format.rs
index 8f58ef1..625a26c 100644
--- a/spdlog/examples/05_custom_formatter.rs
+++ b/spdlog/examples/04_format.rs
@@ -1,5 +1,5 @@
 fn main() {
-    spdlog::info!("default format by `FullFormatter`");
+    spdlog::info!("the default formatter for most sinks is `FullFormatter`");
 
     // There are two ways to set up custom formats
 
@@ -17,10 +17,8 @@ fn use_pattern_formatter() {
     };
 
     // Building a pattern formatter with a pattern.
-    //
     // The `pattern!` macro will parse the template string at compile-time.
-    // See the documentation of `pattern!` macro for more usage.
-    let new_formatter: Box<PatternFormatter<_>> = Box::new(PatternFormatter::new(pattern!(
+    let new_formatter = Box::new(PatternFormatter::new(pattern!(
         "{datetime} - {^{level}} - {payload}{eol}"
     )));
 
@@ -46,12 +44,12 @@ fn impl_manually() {
 
     impl Formatter for MyFormatter {
         fn format(&self, record: &Record, dest: &mut StringBuf) -> spdlog::Result<FmtExtraInfo> {
-            let style_range_begin: usize = dest.len();
+            let style_range_begin = dest.len();
 
             dest.write_str(&record.level().as_str().to_ascii_uppercase())
                 .map_err(spdlog::Error::FormatRecord)?;
 
-            let style_range_end: usize = dest.len();
+            let style_range_end = dest.len();
 
             writeln!(dest, " {}", record.payload()).map_err(spdlog::Error::FormatRecord)?;
 
@@ -66,7 +64,7 @@ fn impl_manually() {
     }
 
     // Building a custom formatter.
-    let new_formatter: Box<MyFormatter> = Box::default();
+    let new_formatter = Box::new(MyFormatter);
 
     // Setting the new formatter for each sink of the default logger.
     for sink in spdlog::default_logger().sinks() {
diff --git a/spdlog/examples/04_rotating_file_sink.rs b/spdlog/examples/04_rotating_file_sink.rs
deleted file mode 100644
index 6a348aa..0000000
--- a/spdlog/examples/04_rotating_file_sink.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-use std::{
-    env,
-    ffi::OsString,
-    fs::{self, DirEntry},
-    io,
-    path::PathBuf,
-    sync::Arc,
-};
-
-use spdlog::{
-    prelude::*,
-    sink::{RotatingFileSink, RotationPolicy},
-};
-
-fn main() -> Result<(), spdlog::Error> {
-    let logs_path: PathBuf = env::current_exe()
-        .unwrap()
-        .parent()
-        .unwrap()
-        .join("logs/rotating_file_sink");
-
-    let path_by_size: PathBuf = logs_path.join("by_size.log");
-    let path_hourly: PathBuf = logs_path.join("hourly.log");
-    let path_daily: PathBuf = logs_path.join("daily.log");
-
-    // See the documentation for descriptions.
-
-    let by_size: Arc<RotatingFileSink> = Arc::new(
-        RotatingFileSink::builder()
-            .base_path(path_by_size)
-            .rotation_policy(RotationPolicy::FileSize(1024 * 10))
-            .rotate_on_open(true)
-            .build()?,
-    );
-
-    let hourly: Arc<RotatingFileSink> = Arc::new(
-        RotatingFileSink::builder()
-            .base_path(path_hourly)
-            .rotation_policy(RotationPolicy::Hourly)
-            .rotate_on_open(true)
-            .build()?,
-    );
-
-    let daily: Arc<RotatingFileSink> = Arc::new(
-        RotatingFileSink::builder()
-            .base_path(path_daily)
-            .rotation_policy(RotationPolicy::Daily { hour: 0, minute: 0 })
-            .rotate_on_open(true)
-            .build()?,
-    );
-
-    let by_size: Logger = Logger::builder().sink(by_size).build()?;
-    let hourly: Logger = Logger::builder().sink(hourly).build()?;
-    let daily: Logger = Logger::builder().sink(daily).build()?;
-
-    info!(logger: by_size, "hello, world");
-    info!(logger: hourly, "hello, world");
-    info!(logger: daily, "hello, world");
-
-    info!(
-        "log files: {:?}",
-        fs::read_dir(logs_path)
-            .unwrap()
-            .collect::<Vec<io::Result<DirEntry>>>()
-            .into_iter()
-            .map(|p| p.unwrap().file_name())
-            .collect::<Vec<OsString>>()
-    );
-
-    Ok(())
-}
diff --git a/spdlog/examples/05_sink.rs b/spdlog/examples/05_sink.rs
new file mode 100644
index 0000000..1078cc4
--- /dev/null
+++ b/spdlog/examples/05_sink.rs
@@ -0,0 +1,78 @@
+use std::sync::Arc;
+
+use atomic::{Atomic, Ordering};
+use spdlog::{
+    formatter::{Formatter, FullFormatter},
+    prelude::*,
+    sink::Sink,
+    ErrorHandler, Record, StringBuf,
+};
+use spin::{Mutex, RwLock};
+
+struct CollectVecSink {
+    level_filter: Atomic<LevelFilter>,
+    formatter: RwLock<Box<dyn Formatter>>,
+    error_handler: Atomic<Option<ErrorHandler>>,
+    collected: Mutex<Vec<String>>,
+}
+
+impl CollectVecSink {
+    fn new() -> Self {
+        Self {
+            level_filter: Atomic::new(LevelFilter::All),
+            formatter: RwLock::new(Box::new(FullFormatter::new())),
+            error_handler: Atomic::new(None),
+            collected: Mutex::new(Vec::new()),
+        }
+    }
+
+    fn collected(&self) -> Vec<String> {
+        self.collected.lock().clone()
+    }
+}
+
+impl Sink for CollectVecSink {
+    fn log(&self, record: &Record) -> spdlog::Result<()> {
+        let mut string_buf = StringBuf::new();
+        self.formatter.read().format(record, &mut string_buf)?;
+        self.collected.lock().push(string_buf.to_string());
+        Ok(())
+    }
+
+    fn flush(&self) -> spdlog::Result<()> {
+        Ok(())
+    }
+
+    fn level_filter(&self) -> LevelFilter {
+        self.level_filter.load(Ordering::Relaxed)
+    }
+
+    fn set_level_filter(&self, level_filter: LevelFilter) {
+        self.level_filter.store(level_filter, Ordering::Relaxed);
+    }
+
+    fn set_formatter(&self, formatter: Box<dyn Formatter>) {
+        *self.formatter.write() = formatter;
+    }
+
+    fn set_error_handler(&self, handler: Option<ErrorHandler>) {
+        self.error_handler.store(handler, Ordering::Relaxed);
+    }
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let my_sink = Arc::new(CollectVecSink::new());
+    let example = Logger::builder().sink(my_sink.clone()).build()?;
+
+    info!(logger: example, "Hello, world!");
+    warn!(logger: example, "Meow~");
+
+    let collected = my_sink.collected();
+    println!("collected:\n{collected:#?}");
+
+    assert_eq!(collected.len(), 2);
+    assert!(collected[0].ends_with(" [info] Hello, world!\n"));
+    assert!(collected[1].ends_with(" [warn] Meow~\n"));
+
+    Ok(())
+}
diff --git a/spdlog/examples/06_compatible_with_log_crate.rs b/spdlog/examples/06_compatible_with_log_crate.rs
deleted file mode 100644
index 965a2a0..0000000
--- a/spdlog/examples/06_compatible_with_log_crate.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-use std::sync::Arc;
-
-use spdlog::prelude::*;
-
-// Assuming that this function comes from an upstream dependency, it internally
-// uses log crate to output logs.
-fn fn_from_other_crate() {
-    log::set_max_level(log::LevelFilter::Trace);
-    log::info!("this is a log from other crate");
-}
-
-fn main() {
-    // Call this function early. Logs from log crate will not be handled before
-    // calling it.
-    spdlog::init_log_crate_proxy()
-        .expect("users should only call `init_log_crate_proxy` function once");
-
-    // Logs will be output to `spdlog::default_logger()`.
-    fn_from_other_crate();
-
-    // Assuming this is a custom logger, it might be a combination of
-    // `StdStreamSink` and `FileSink` or whatever.
-    let custom_logger: Arc<Logger> = spdlog::default_logger();
-
-    // Logs will be output to `custom_logger`.
-    let proxy: &'static spdlog::LogCrateProxy = spdlog::log_crate_proxy();
-    proxy.set_logger(Some(custom_logger));
-    fn_from_other_crate();
-
-    // Logs will be output to `spdlog::default_logger()`.
-    proxy.set_logger(None);
-    fn_from_other_crate();
-}
diff --git a/spdlog/examples/06_log_crate.rs b/spdlog/examples/06_log_crate.rs
new file mode 100644
index 0000000..265b932
--- /dev/null
+++ b/spdlog/examples/06_log_crate.rs
@@ -0,0 +1,16 @@
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    spdlog::init_log_crate_proxy()
+        .expect("users should only call `init_log_crate_proxy` function once");
+
+    log::set_max_level(log::LevelFilter::Trace);
+    log::trace!("this log will be processed by the global default logger in spdlog-rs");
+
+    let custom_logger = spdlog::default_logger().fork_with_name(Some("another_logger"))?;
+    spdlog::log_crate_proxy().set_logger(Some(custom_logger));
+    log::info!("this log will be processed by custom_logger in spdlog-rs");
+
+    spdlog::log_crate_proxy().set_logger(None);
+    log::trace!("this log will be processed by the global default logger in spdlog-rs");
+
+    Ok(())
+}
diff --git a/spdlog/examples/07_async.rs b/spdlog/examples/07_async.rs
new file mode 100644
index 0000000..ee9b64c
--- /dev/null
+++ b/spdlog/examples/07_async.rs
@@ -0,0 +1,25 @@
+use std::{env, sync::Arc};
+
+use spdlog::{
+    prelude::*,
+    sink::{AsyncPoolSink, FileSink},
+};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let path = env::current_exe()?.with_file_name("async.log");
+    let file_sink = Arc::new(FileSink::builder().path(path).build()?);
+
+    // AsyncPoolSink is a combined sink which wraps other sinks
+    let async_pool_sink = Arc::new(AsyncPoolSink::builder().sink(file_sink).build()?);
+
+    let async_logger = Arc::new(
+        Logger::builder()
+            .sink(async_pool_sink)
+            .flush_level_filter(LevelFilter::All)
+            .build()?,
+    );
+
+    info!(logger: async_logger, "Hello, async!");
+
+    Ok(())
+}
diff --git a/spdlog/examples/07_async_pool_sink.rs b/spdlog/examples/07_async_pool_sink.rs
deleted file mode 100644
index f7ed92d..0000000
--- a/spdlog/examples/07_async_pool_sink.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use std::{env, path::PathBuf, sync::Arc};
-
-use spdlog::{
-    prelude::*,
-    sink::{AsyncPoolSink, FileSink},
-};
-
-fn main() -> Result<(), spdlog::Error> {
-    const LOG_FILE: &str = "logs/async_file_sink.log";
-
-    let path: PathBuf = env::current_exe().unwrap().parent().unwrap().join(LOG_FILE);
-    let file_sink: Arc<FileSink> = Arc::new(FileSink::builder().path(path).truncate(true).build()?);
-
-    // Building a `AsyncPoolSink`.
-    // Log and flush operations with this sink will be processed asynchronously.
-    let async_pool_sink: Arc<AsyncPoolSink> =
-        Arc::new(AsyncPoolSink::builder().sink(file_sink).build().unwrap());
-
-    let logger: Arc<Logger> = Arc::new(Logger::builder().sink(async_pool_sink).build()?);
-
-    info!(logger: logger, "hello async_pool_sink");
-
-    Ok(())
-}
diff --git a/spdlog/src/error.rs b/spdlog/src/error.rs
index c52390d..d0ef27f 100644
--- a/spdlog/src/error.rs
+++ b/spdlog/src/error.rs
@@ -1,4 +1,9 @@
 //! Provides error types.
+//!
+//! # Default error handler
+//!
+//! If a logger or sink does not have an error handler set up, a default error
+//! handler will be used, which will print the error to `stderr`.
 
 use std::{
     fmt::{self, Display},
@@ -13,94 +18,87 @@ use crate::utils::const_assert;
 #[cfg(feature = "multi-thread")]
 use crate::{sink::Task, RecordOwned};
 
-/// The error type of this crate.
+/// Contains most errors of this crate.
 #[derive(Error, Debug)]
 #[non_exhaustive]
 pub enum Error {
-    /// The variant returned by [`Formatter`]s when an error occurs in
-    /// formatting a record.
+    /// Returned by [`Formatter`]s when an error occurs in formatting a record.
     ///
     /// [`Formatter`]: crate::formatter::Formatter
     #[error("format record error: {0}")]
     FormatRecord(fmt::Error),
 
-    /// The variant returned by [`Sink`]s when an error occurs in writing a
-    /// record to the target.
+    /// Returned by [`Sink`]s when an error occurs in writing a record to the
+    /// target.
     ///
     /// [`Sink`]: crate::sink::Sink
     #[error("write record error: {0}")]
     WriteRecord(io::Error),
 
-    /// The variant returned by [`Sink`]s when an error occurs in flushing the
-    /// buffer.
+    /// Returned by [`Sink`]s when an error occurs in flushing the buffer.
     ///
     /// [`Sink`]: crate::sink::Sink
     #[error("flush buffer error: {0}")]
     FlushBuffer(io::Error),
 
-    /// The variant returned by [`Sink`]s when an error occurs in creating a
-    /// directory.
+    /// Returned by [`Sink`]s when an error occurs in creating a directory.
     ///
     /// [`Sink`]: crate::sink::Sink
     #[error("create directory error: {0}")]
     CreateDirectory(io::Error),
 
-    /// The variant returned by [`Sink`]s when an error occurs in opening a
-    /// file.
+    /// Returned by [`Sink`]s when an error occurs in opening a file.
     ///
     /// [`Sink`]: crate::sink::Sink
     #[error("open file error: {0}")]
     OpenFile(io::Error),
 
-    /// The variant returned by [`Sink`]s when an error occurs in querying the
-    /// metadata of a file.
+    /// Returned by [`Sink`]s when an error occurs in querying the metadata of a
+    /// file.
     ///
     /// [`Sink`]: crate::sink::Sink
     #[error("query file metadata error: {0}")]
     QueryFileMetadata(io::Error),
 
-    /// The variant returned by [`Sink`]s when an error occurs in renaming a
-    /// file.
+    /// Returned by [`Sink`]s when an error occurs in renaming a file.
     ///
     /// [`Sink`]: crate::sink::Sink
     #[error("rename file error: {0}")]
     RenameFile(io::Error),
 
-    /// The variant returned by [`Sink`]s when an error occurs in removing a
-    /// file.
+    /// Returned by [`Sink`]s when an error occurs in removing a file.
     ///
     /// [`Sink`]: crate::sink::Sink
     #[error("remove file error: {0}")]
     RemoveFile(io::Error),
 
-    /// The variant returned by [`from_str`] when the string doesn't match any
-    /// of the log levels.
+    /// Returned by [`from_str`] when the string doesn't match any of the log
+    /// levels.
     ///
     /// [`from_str`]: std::str::FromStr::from_str
     #[error("attempted to convert a string that doesn't match an existing log level: {0}")]
     ParseLevel(String),
 
-    /// The variant returned if an invalid argument was passed in.
+    /// Returned if an invalid argument was passed in.
     #[error("invalid argument {0}")]
     InvalidArgument(#[from] InvalidArgumentError),
 
-    /// The variant returned by [`Sink`]s when an error occurs in sending to the
-    /// channel.
+    /// Returned by [`Sink`]s when an error occurs in sending to the channel.
     ///
     /// [`Sink`]: crate::sink::Sink
     #[cfg(feature = "multi-thread")]
     #[error("failed to send message to channel: {0}")]
     SendToChannel(SendToChannelError, SendToChannelErrorDropped),
 
-    /// The variant returned by [`runtime_pattern!`] when the
-    /// pattern is failed to be built at runtime.
+    /// Returned by [`runtime_pattern!`] when the pattern is failed to be built
+    /// at runtime.
     ///
     /// [`runtime_pattern!`]: crate::formatter::runtime_pattern
     #[cfg(feature = "runtime-pattern")]
     #[error("failed to build pattern at runtime: {0}")]
     BuildPattern(BuildPatternError),
 
-    /// This variant returned when multiple errors occurred.
+    /// Returned when multiple errors occurred.
     #[error("{0:?}")]
     Multiple(Vec<Error>),
 
@@ -109,7 +107,7 @@ pub enum Error {
     __ForInternalTestsUseOnly(i32),
 }
 
-/// This error type contains a variety of possible invalid arguments.
+/// Indicates that an invalid parameter was specified.
 #[derive(Error, Debug)]
 #[non_exhaustive]
 pub enum InvalidArgumentError {
@@ -135,7 +133,7 @@ pub enum InvalidArgumentError {
     ThreadPoolCapacity(String),
 }
 
-/// This error indicates that an invalid logger name was set.
+/// Indicates that an invalid logger name was set.
 ///
 /// See the documentation of [`LoggerBuilder::name`] for the name requirements.
 ///
@@ -164,7 +162,7 @@ impl Display for SetLoggerNameError {
     }
 }
 
-/// The more detailed error type of sending to channel.
+/// Indicates that an error occurred while sending to channel.
 #[cfg(feature = "multi-thread")]
 #[derive(Error, Debug)]
 #[non_exhaustive]
@@ -249,8 +247,7 @@ impl SendToChannelErrorDropped {
     }
 }
 
-/// This error indicates that an error occurred while building a pattern at
-/// compile-time.
+/// Indicates that an error occurred while building a pattern at compile-time.
 #[cfg(feature = "runtime-pattern")]
 #[derive(Error, Debug)]
 #[error("{0}")]
diff --git a/spdlog/src/formatter/full_formatter.rs b/spdlog/src/formatter/full_formatter.rs
index b919408..8f0808e 100644
--- a/spdlog/src/formatter/full_formatter.rs
+++ b/spdlog/src/formatter/full_formatter.rs
@@ -10,28 +10,28 @@ use crate::{
 };
 
 #[rustfmt::skip]
-/// A full info log records formatter.
+/// Full information logs formatter.
 ///
-/// It is the default formatter for sinks.
+/// It is the default formatter for most sinks.
 ///
 /// Log messages formatted by it look like:
 ///
 ///  - Default:
 ///
 ///    <pre>
-///    [2022-11-02 09:23:12.263] [<font color="#11D116">info</font>] hello, world!
+///    [2022-11-02 09:23:12.263] [<font color="#0DBC79">info</font>] hello, world!
 ///    </pre>
 ///
 ///  - If the logger has a name:
 ///
 ///    <pre>
-///    [2022-11-02 09:23:12.263] [logger-name] [<font color="#11D116">info</font>] hello, world!
+///    [2022-11-02 09:23:12.263] [logger-name] [<font color="#0DBC79">info</font>] hello, world!
 ///    </pre>
 /// 
 ///  - If crate feature `source-location` is enabled:
 ///
 ///    <pre>
-///    [2022-11-02 09:23:12.263] [<font color="#11D116">info</font>] [mod::path, src/main.rs:4] hello, world!
+///    [2022-11-02 09:23:12.263] [logger-name] [<font color="#0DBC79">info</font>] [mod::path, src/main.rs:4] hello, world!
 ///    </pre>
 #[derive(Clone)]
 pub struct FullFormatter {
diff --git a/spdlog/src/formatter/mod.rs b/spdlog/src/formatter/mod.rs
index 878812d..05675da 100644
--- a/spdlog/src/formatter/mod.rs
+++ b/spdlog/src/formatter/mod.rs
@@ -1,8 +1,52 @@
 //! Provides formatters for sink formatting log records.
 //!
-//! Usually use [`Sink::set_formatter`] to set the formatter of a sink.
+//! # Formatter
+//!
+//! Each normal *Sink* owns a *Formatter*, which is used to format each log.
+//!
+//! The default formatter for most sinks is [`FullFormatter`], you can call
+//! [`Sink::set_formatter`] to replace it with another formatter.
+//!
+//! The easiest way to make a custom formatter is to build a pattern, see
+//! [Compile-time and runtime pattern
+//! formatter](#compile-time-and-runtime-pattern-formatter) below. If pattern
+//! isn't flexible enough for you, you need to implement [`Formatter`] trait for
+//! your own formatter struct. See the implementation of [`FullFormatter`] and
+//! [./examples] directory for examples.
+//!
+//! # Compile-time and runtime pattern formatter
+//!
+//! *spdlog-rs* supports formatting your log records according to a pattern
+//! string. There are 2 ways to construct a pattern:
+//!
+//! - Macro [`pattern!`]: Builds a pattern at compile-time.
+//! - Macro [`runtime_pattern!`]: Builds a pattern at runtime.
+//!
+//! ```
+//! use spdlog::formatter::{pattern, PatternFormatter};
+//! # use spdlog::sink::{Sink, WriteSink};
+//!
+//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
+//! // This pattern is built at compile-time, the template accepts only a literal string.
+//! let pattern = pattern!("[{date} {time}.{millisecond}] [{level}] {payload}{eol}");
+//!
+//! #[cfg(feature = "runtime-pattern")]
+//! {
+//!     use spdlog::formatter::runtime_pattern;
+//!
+//!     // This pattern is built at runtime, the template accepts a runtime string.
+//!     let input = "[{date} {time}.{millisecond}] [{level}] {payload}{eol}";
+//!     let pattern = runtime_pattern!(input)?;
+//! }
+//!
+//! // Use the compile-time or runtime pattern.
+//! # let your_sink = WriteSink::builder().target(vec![]).build()?;
+//! your_sink.set_formatter(Box::new(PatternFormatter::new(pattern)));
+//! # Ok(()) }
+//! ```
 //!
 //! [`Sink::set_formatter`]: crate::sink::Sink::set_formatter
+//! [./examples]: https://github.com/SpriteOvO/spdlog-rs/tree/main/spdlog/examples
 
 mod full_formatter;
 #[cfg(any(
@@ -26,7 +70,7 @@ pub use pattern_formatter::*;
 
 use crate::{Record, Result, StringBuf};
 
-/// A trait for log records formatters.
+/// Represents a formatter that can be used for formatting logs.
 ///
 /// # Examples
 ///
@@ -55,7 +99,7 @@ impl FmtExtraInfo {
         FmtExtraInfo::default()
     }
 
-    /// Constructs a [`FmtExtraInfoBuilder`].
+    /// Gets a [`FmtExtraInfoBuilder`].
     #[must_use]
     pub fn builder() -> FmtExtraInfoBuilder {
         FmtExtraInfoBuilder::new()
@@ -75,13 +119,7 @@ impl FmtExtraInfo {
     }
 }
 
-/// The builder of [`FmtExtraInfo`].
-///
-/// # Examples
-///
-/// See the implementation of [`FullFormatter`] and [./examples] directory.
-///
-/// [./examples]: https://github.com/SpriteOvO/spdlog-rs/tree/main/spdlog/examples
+#[allow(missing_docs)]
 #[derive(Clone, Eq, PartialEq, Hash, Debug, Default)]
 pub struct FmtExtraInfoBuilder {
     info: FmtExtraInfo,
diff --git a/spdlog/src/formatter/pattern_formatter/mod.rs b/spdlog/src/formatter/pattern_formatter/mod.rs
index 922b8a9..513f2b0 100644
--- a/spdlog/src/formatter/pattern_formatter/mod.rs
+++ b/spdlog/src/formatter/pattern_formatter/mod.rs
@@ -1,15 +1,3 @@
-//! This module provides a pattern-string based formatter.
-//!
-//! The [`PatternFormatter`] struct defines a formatter that formats log
-//! messages against a specific text pattern.
-//!
-//! Patterns are represented by the [`Pattern`] trait. You can create your own
-//! pattern by implementing the [`Pattern`] trait.
-//!
-//! You can also build a pattern with the [`pattern`][pattern-macro] macro.
-//!
-//! [pattern-macro]: crate::formatter::pattern
-
 #[doc(hidden)]
 #[path = "pattern/mod.rs"]
 pub mod __pattern;
@@ -29,7 +17,7 @@ use crate::{
 };
 
 #[rustfmt::skip] // rustfmt currently breaks some empty lines if `#[doc = include_str!("xxx")]` exists
-/// Build a pattern from a template literal string at compile-time.
+/// Builds a pattern from a template literal string at compile-time.
 ///
 /// It accepts inputs in the form:
 ///
@@ -304,7 +292,7 @@ use crate::{
 /// );
 /// ```
 ///
-/// # Appendix: A Full List of Built-in Patterns
+/// # Appendix: Full List of Built-in Patterns
 ///
 /// | Placeholders          | Description                  | Example                                      |
 /// | --------------------- | ---------------------------- | -------------------------------------------- |
@@ -354,7 +342,7 @@ use crate::{
 /// [`FullFormatter`]: crate::formatter::FullFormatter
 pub use ::spdlog_macros::pattern;
 
-/// A formatter that formats log records according to a specified pattern.
+/// Formats logs according to a specified pattern.
 #[derive(Clone)]
 pub struct PatternFormatter<P> {
     pattern: P,
@@ -392,20 +380,22 @@ where
     }
 }
 
-/// Provide context for patterns.
+/// Provides context for patterns.
+///
+/// There is nothing to set up here at the moment, reserved for future use.
 #[derive(Clone, Debug)]
 pub struct PatternContext {
     fmt_info_builder: FmtExtraInfoBuilder,
 }
 
 impl PatternContext {
-    /// Create a new `PatternContext` object.
+    /// Creates a new `PatternContext` object.
     #[must_use]
     fn new(fmt_info_builder: FmtExtraInfoBuilder) -> Self {
         Self { fmt_info_builder }
     }
 
-    /// Set the style range of the log message written by the patterns.
+    /// Sets the style range of the log message written by the patterns.
     ///
     /// This function is reserved for use by the style range pattern. Other
     /// built-in patterns should not use this function. User-defined
@@ -416,26 +406,24 @@ impl PatternContext {
     }
 }
 
-/// A pattern.
+/// Represents a pattern for replacing a placeholder in templates.
 ///
-/// A pattern is like a formatter, except that multiple patterns can be combined
-/// in various ways to create a new pattern. The [`PatternFormatter`] struct
-/// provides a [`Formatter`] that formats log records according to a given
-/// pattern.
+/// A pattern will be used to replace placeholders that appear in a template
+/// string. Multiple patterns can form a new pattern. The [`PatternFormatter`]
+/// formats logs according to a given pattern.
 ///
 /// # Built-in Patterns
 ///
-/// `spdlog` provides a rich set of built-in patterns. See the [`pattern`]
+/// `spdlog-rs` provides a rich set of built-in patterns. See the [`pattern`]
 /// macro.
 ///
 /// # Custom Patterns
 ///
 /// There are 3 approaches to create your own pattern:
-/// - Define a new type and implements this trait;
-/// - Use the [`pattern`] macro to create a pattern from a literal template
+/// - Define a new type and implement this trait;
+/// - Use [`pattern`] macro to create a pattern from a literal template string.
+/// - Use [`runtime_pattern`] macro to create a pattern from a runtime template
 ///   string.
-/// - Use the [`runtime_pattern`] macro to create a pattern from a runtime
-///   template string.
 pub trait Pattern: Send + Sync + DynClone {
     /// Format this pattern against the given log record and write the formatted
     /// message into the output buffer.
diff --git a/spdlog/src/formatter/pattern_formatter/runtime.rs b/spdlog/src/formatter/pattern_formatter/runtime.rs
index ef768e7..8d643a2 100644
--- a/spdlog/src/formatter/pattern_formatter/runtime.rs
+++ b/spdlog/src/formatter/pattern_formatter/runtime.rs
@@ -17,7 +17,7 @@ type PatternCreator = Box<dyn Fn() -> Box<dyn Pattern>>;
 type PatternRegistry = GenericPatternRegistry<PatternCreator>;
 type PatternKind = GenericPatternKind<PatternCreator>;
 
-/// Build a pattern from a template string at runtime.
+/// Builds a pattern from a template string at runtime.
 ///
 /// It accepts inputs in the form:
 ///
@@ -58,7 +58,7 @@ type PatternKind = GenericPatternKind<PatternCreator>;
 pub use spdlog_macros::runtime_pattern;
 
 #[rustfmt::skip] // rustfmt currently breaks some empty lines if `#[doc = include_str!("xxx")]` exists
-/// A runtime pattern built via [`runtime_pattern!`] macro.
+/// Runtime pattern built via [`runtime_pattern!`] macro.
 ///
 /// ## Basic Usage
 /// 
diff --git a/spdlog/src/include/doc/log-macro-nameed-opt-params.md b/spdlog/src/include/doc/log-macro-nameed-opt-params.md
new file mode 100644
index 0000000..d004654
--- /dev/null
+++ b/spdlog/src/include/doc/log-macro-nameed-opt-params.md
@@ -0,0 +1,5 @@
+# Named optional parameters
+
+| Name   | Type                      | Description                                                                       |
+|--------|---------------------------|-----------------------------------------------------------------------------------|
+| logger | `Arc<Logger>` or `Logger` | If specified, the given logger will be used instead of the global default logger. |
diff --git a/spdlog/src/level.rs b/spdlog/src/level.rs
index 7b2aa8b..26df4dd 100644
--- a/spdlog/src/level.rs
+++ b/spdlog/src/level.rs
@@ -1,5 +1,3 @@
-//! Provides stuff related to log levels
-
 use std::{fmt, str::FromStr};
 
 use cfg_if::cfg_if;
@@ -11,24 +9,24 @@ pub(crate) const LOG_LEVEL_NAMES: [&str; Level::count()] =
 
 const LOG_LEVEL_SHORT_NAMES: [&str; Level::count()] = ["C", "E", "W", "I", "D", "T"];
 
-/// An enum representing log levels.
+/// Represents log levels.
 ///
-/// Typical usage includes: specifying the `Level` of [`log!`], and comparing a
-/// `Level` to a [`LevelFilter`] through [`LevelFilter::test`].
+/// Typical usage:
+/// - specifying the `level` parameter of macro [`log!`];
+/// - comparing a `Level` to a [`LevelFilter`] through [`LevelFilter::test`].
 ///
 /// # Note
 ///
-/// Users should never convert variants of this enum to integers for persistent
+/// Users should never cast variants of this enum to integers for persistent
 /// storage (e.g., configuration files), using [`Level::as_str`] instead,
 /// because integers corresponding to variants may change in the future.
 ///
 /// Do **not** do this:
 /// ```
 /// # use spdlog::prelude::*;
-/// # fn save_to_config_file(_: usize) {}
-/// let level: Level = /* ... */
-/// # Level::Info;
-/// let value: usize = level as usize;
+/// # fn save_to_config_file(_: u32) {}
+/// # let level: Level = Level::Info;
+/// let value = level as u32; // Never do numeric casting!
 ///
 /// save_to_config_file(value);
 /// ```
@@ -37,9 +35,8 @@ const LOG_LEVEL_SHORT_NAMES: [&str; Level::count()] = ["C", "E", "W", "I", "D",
 /// ```
 /// # use spdlog::prelude::*;
 /// # fn save_to_config_file(_: &str) {}
-/// let level: Level = /* ... */
-/// # Level::Info;
-/// let value: &'static str = level.as_str();
+/// # let level: Level = Level::Info;
+/// let value = level.as_str();
 ///
 /// save_to_config_file(value);
 /// ```
@@ -117,7 +114,7 @@ impl Level {
         Level::Trace
     }
 
-    /// Returns the string representation of the `Level`.
+    /// Returns the string representation.
     ///
     /// This returns the same string as the `fmt::Display` implementation.
     #[must_use]
@@ -130,7 +127,7 @@ impl Level {
         LOG_LEVEL_SHORT_NAMES[*self as usize]
     }
 
-    /// Iterate through all supported logging levels.
+    /// Iterates through all logging levels.
     ///
     /// The order of iteration is from more severe to more verbose.
     ///
@@ -182,23 +179,10 @@ impl FromStr for Level {
     }
 }
 
-/// An enum representing log level logical filter conditions.
-///
-/// A `LevelFilter` may be compared to a [`Level`] through
-/// [`LevelFilter::test`].
-///
-/// # Examples
-///
-/// ```
-/// use spdlog::prelude::*;
-///
-/// let level_filter: LevelFilter = LevelFilter::MoreSevere(Level::Info);
+/// Represents log level logical filter conditions.
 ///
-/// assert_eq!(level_filter.test(Level::Trace), false);
-/// assert_eq!(level_filter.test(Level::Info), false);
-/// assert_eq!(level_filter.test(Level::Warn), true);
-/// assert_eq!(level_filter.test(Level::Error), true);
-/// ```
+/// Use [`LevelFilter::test`] method to check if a [`Level`] satisfies the
+/// filter condition.
 #[repr(align(4))]
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 pub enum LevelFilter {
@@ -234,11 +218,7 @@ cfg_if! {
 }
 
 impl LevelFilter {
-    /// Compares the given level with the logical filter condition
-    ///
-    /// # Examples
-    ///
-    /// See the documentation of [`LevelFilter`].
+    /// Checks the given level if satisfies the filter condition.
     #[deprecated(
         since = "0.4.0",
         note = "it may be removed in the future, use method `test()` instead"
@@ -248,11 +228,20 @@ impl LevelFilter {
         self.__test_const(level)
     }
 
-    /// Tests the given level with the logical filter condition
+    /// Checks the given level if satisfies the filter condition.
     ///
     /// # Examples
     ///
-    /// See the documentation of [`LevelFilter`].
+    /// ```
+    /// use spdlog::prelude::*;
+    ///
+    /// let level_filter = LevelFilter::MoreSevere(Level::Info);
+    ///
+    /// assert_eq!(level_filter.test(Level::Trace), false);
+    /// assert_eq!(level_filter.test(Level::Info), false);
+    /// assert_eq!(level_filter.test(Level::Warn), true);
+    /// assert_eq!(level_filter.test(Level::Error), true);
+    /// ```
     #[must_use]
     pub fn test(&self, level: Level) -> bool {
         self.__test_const(level)
diff --git a/spdlog/src/lib.rs b/spdlog/src/lib.rs
index 858dacf..d5afcc7 100644
--- a/spdlog/src/lib.rs
+++ b/spdlog/src/lib.rs
@@ -1,9 +1,25 @@
-//! A fast and combinable Rust logging crate.
+//! Fast, highly configurable Rust logging crate.
 //!
-//! It is inspired by the C++ logging library [spdlog], so if you are familiar
-//! with C++ `spdlog`, you should be able to get started with this crate quite
-//! easily. Of course, there are some differences, you can see [Significant
-//! differences from C++ spdlog](#significant-differences-from-c-spdlog) below.
+//! It is inspired by the C++ logging library [spdlog], and we share most of the
+//! same concepts. So if you are already familiar with C++ `spdlog`, you should
+//! be able to get started with this crate quite easily. Of course, there are
+//! some differences, you can see [Significant differences from C++
+//! spdlog](#significant-differences-from-c-spdlog) below.
+//!
+//! # Table of contents
+//!
+//! - [Getting started](#getting-started)
+//! - [Compile-time filters](#compile-time-filters)
+//! - [Crate feature flags](#crate-feature-flags)
+//! - [Supported Rust versions](#supported-rust-versions)
+//! - Overview of features
+//!   - [Configured via environment variable](init_env_level)
+//!   - [Compile-time and runtime pattern formatter]
+//!   - [Asynchronous support]
+//!   - [Compatible with log crate](LogCrateProxy)
+//!
+//! [Compile-time and runtime pattern formatter]: formatter/index.html#compile-time-and-runtime-pattern-formatter
+//! [Asynchronous support]: crate::sink::AsyncPoolSink
 //!
 //! # Getting started
 //!
@@ -13,118 +29,127 @@
 //! spdlog-rs = "0.3"
 //! ```
 //!
-//! `spdlog-rs` is out-of-the-box, it has a default logger, so users can output
-//! logs to terminal by default without any configuration. For more details
-//! about the default logger, please read the documentation of
-//! [`default_logger`].
-//!
-//! The basic use of this crate is through these logging macros: [`trace!`],
-//! [`debug!`], [`info!`], [`warn!`], [`error!`], [`critical!`] and [`log!`],
-//! where [`critical!`] represents the most severe log messages and [`trace!`]
-//! the most verbose. Each of these macros accept format strings similarly to
-//! [`println!`]. All log macros and common types are already under [`prelude`]
-//! module.
-//!
-//! [`Logger`] and [`sink`] are the most important components of `spdlog-rs`.
-//! Make sure to read their documentation. In short, a logger contains a
-//! combination of sinks, and sinks implement writing log messages to actual
-//! targets.
-//!
-//! ## Examples
+//! `spdlog-rs` is highly configurable, and also works out-of-the-box for
+//! lightweight projects. By default, logs will be output to `stdout` and
+//! `stderr`.
 //!
 //! ```
 //! use spdlog::prelude::*;
 //!
-//! info!("hello world!");
-//! warn!("3 + 2 = {}", 5);
+//! // Non-severe logs (trace, debug) are ignored by default.
+//! // If you wish to enable all logs, call
+//! spdlog::default_logger().set_level_filter(spdlog::LevelFilter::All);
+//!
+//! info!("hello, world!");
 //! error!("oops!");
+//! debug!("3 + 2 = {}", 5);
 //! ```
 //!
 //! Output:
 //!
 //! <pre>
-//! [2022-11-02 09:23:12.263] [<font color="#11D116">info</font>] hello, world!
-//! [2022-11-02 09:23:12.263] [<font color="#FDBC4B">warn</font>] 3 + 2 = 5
-//! [2022-11-02 09:23:12.263] [<font color="#C0392B">error</font>] oops!
+//! [2022-11-02 09:23:12.263] [<font color="#0DBC79">info</font>] hello, world!
+//! [2022-11-02 09:23:12.263] [<font color="#F35E5E">error</font>] oops!
+//! [2022-11-02 09:23:12.263] [<font color="#11A8CD">debug</font>] 3 + 2 = 5
 //! </pre>
 //!
-//! If you want to learn more advanced features such as *asynchronous sink*,
-//! *compile-time pattern formatter*, etc., please see [./examples]
-//! directory.
+//! The basic use is through these logging macros: [`trace!`], [`debug!`],
+//! [`info!`], [`warn!`], [`error!`], [`critical!`], where `critical!`
+//! represents the most severe logs and `trace!` the most verbose. Each of these
+//! macros accept format strings similarly to [`println!`]. All log macros
+//! and common types are already under [`prelude`] module.
 //!
-//! ## Help
+//! ## Sink
 //!
-//! If you have any questions or need help while using this crate, feel free to
-//! [open a discussion]. For feature requests or bug reports, please [open an
-//! issue].
+//! Many real programs want more than just displaying logs to the terminal.
 //!
-//! # Overview of features
+//! [`Sink`]s are the objects that actually write logs to their targets. If you
+//! want logs to be written to files as well, [`FileSink`] is what you need.
 //!
-//! - [Compatible with log crate](#compatible-with-log-crate)
-//! - [Asynchronous support](#asynchronous-support)
-//! - [Configured via environment
-//!   variable](#configured-via-environment-variable)
-//! - [Compile-time and runtime pattern
-//!   formatter](#compile-time-and-runtime-pattern-formatter)
-//! - [Compile-time filters](#compile-time-filters)
-//!
-//! # Compatible with log crate
-//!
-//! This is optional and is controlled by crate feature `log`.
+//! ```
+//! # use std::sync::Arc;
+//! use spdlog::{prelude::*, sink::FileSink};
+//!
+//! # fn main() -> spdlog::Result<()> {
+//! let path = "path/to/somewhere.log";
+//!
+//! # let path = concat!(env!("OUT_DIR"), "/doctest-out/crate-1.txt");
+//! let new_logger = spdlog::default_logger().fork_with(|new| {
+//!     let file_sink = Arc::new(FileSink::builder().path(path).build()?);
+//!     new.sinks_mut().push(file_sink);
+//!     Ok(())
+//! })?;
+//! # let backup = spdlog::default_logger();
+//! spdlog::set_default_logger(new_logger);
+//!
+//! info!("from now on, logs will be written to both stdout/stderr and the file");
+//! # spdlog::set_default_logger(backup);
+//! # Ok(()) }
+//! ```
 //!
-//! The compatibility with [log crate] is mainly through a proxy layer
-//! [`LogCrateProxy`]. Call [`init_log_crate_proxy`] function to enable the
-//! proxy layer, and all logs from [log crate] will be handled by it. You can
-//! use it to output [log crate] logs of upstream dependencies or to quickly
-//! migrate from [log crate] for your projects.
+//! Take a look at [`sink`] module for more interesting sinks, such as
+//! [`RotatingFileSink`] that automatically rotates files by time point or file
+//! size, and [`AsyncPoolSink`] that outputs logs asynchronously.
 //!
-//! [`LogCrateProxy`] forwards all logs from [log crate] to [`default_logger`]
-//! by default, you can call [`log_crate_proxy()`] to get a reference to this
-//! proxy to configure it.
+//! ## Logger
 //!
-//! See [./examples] directory for examples.
+//! A complex program may consist of many separated components.
 //!
-//! # Asynchronous support
+//! [`Logger`] manages, controls and manipulates multiple sinks within it. In
+//! addition to having the global [`default_logger`], more loggers are allowed
+//! to be configured, stored and used independently.
 //!
-//! See [Asynchronous combined sink].
+//! Logging macros provide an optional parameter `logger`. If it is specified,
+//! logs will be processed by the specified logger instead of the global default
+//! logger.
 //!
-//! # Configured via environment variable
+//! And benefiting from the fact that a logger uses `Arc` to store sinks, a sink
+//! can be set and used by more than one logger, and you can combine them as you
+//! like.
 //!
-//! Users can optionally configure the level filter of loggers via the
-//! environment variable `SPDLOG_RS_LEVEL`.
+//! ```
+//! use spdlog::prelude::*;
+//! # use spdlog::Result;
 //!
-//! For more details, see the documentation of [`init_env_level`].
+//! struct AppDatabase {
+//!     logger: Logger,
+//!     // Database info...
+//! }
 //!
-//! # Compile-time and runtime pattern formatter
+//! impl AppDatabase {
+//!     fn new() -> Result<Self> {
+//!         let logger = Logger::builder()
+//!             .name("database")
+//!             // .sink( ... )
+//!             // .sink( ... )
+//!             // .level_filter( ... )
+//!             // ...
+//!             .build()?;
+//!         Ok(Self { logger, /* Database info... */ })
+//!     }
+//!
+//!     fn query<T>(&self) -> T {
+//!         let data = /* Query from the database */
+//!         # 114514;
+//!         trace!(logger: self.logger, "queried data {}", data);
+//!         data
+//!         # ; unreachable!()
+//!     }
+//! }
 //!
-//! spdlog-rs supports formatting your log records according to a pattern
-//! string. There are 2 ways to construct a pattern:
+//! struct AppNetwork { /* ... */ }
+//! struct AppAuth { /* ... */ }
+//! struct AppBlahBlah { /* ... */ }
+//! ```
 //!
-//! - Macro [`pattern!`]: Builds a pattern at compile-time.
-//! - Macro [`runtime_pattern!`]: Builds a pattern at runtime.
+//! ## Learn more
 //!
-//! ```
-//! use spdlog::formatter::{pattern, PatternFormatter};
-//! #[cfg(feature = "runtime-pattern")]
-//! use spdlog::formatter::runtime_pattern;
-//! # use spdlog::sink::{Sink, WriteSink};
-//!
-//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
-//! // This pattern is built at compile-time, the template accepts only a literal string.
-//! let pattern = pattern!("[{date} {time}.{millisecond}] [{level}] {payload}{eol}");
-//!
-//! #[cfg(feature = "runtime-pattern")]
-//! {
-//!     // This pattern is built at runtime, the template accepts a runtime string.
-//!     let input = "[{date} {time}.{millisecond}] [{level}] {payload}{eol}";
-//!     let pattern = runtime_pattern!(input)?;
-//! }
+//! Directory [./examples] contains more advanced usage examples. You can learn
+//! them along with their documentation.
 //!
-//! // Use the compile-time or runtime pattern.
-//! # let your_sink = WriteSink::builder().target(vec![]).build()?;
-//! your_sink.set_formatter(Box::new(PatternFormatter::new(pattern)));
-//! # Ok(()) }
-//! ```
+//! If you have any trouble while using this crate, please don't hesitate to
+//! [open a discussion] for help. For feature requests or bug reports, please
+//! [open an issue].
 //!
 //! # Compile-time filters
 //!
@@ -156,34 +181,33 @@
 //! debug, and info level logs in release builds with
 //! `features = ["level-debug", "release-level-warn"]`.
 //!
-//! # Crate Feature Flags
+//! # Crate feature flags
 //!
 //! The following crate feature flags are available in addition to the filters.
 //! They are configured in your `Cargo.toml`.
 //!
 //!  - `source-location` allows recording the source location of each log. When
-//!    it is enabled the default formatter [`FullFormatter`] will always format
-//!    the source location information, and some formatting patterns related to
-//!    source location will be available. If you do not want the source location
+//!    it is enabled, the source location will be present in [`Record`] and
+//!    visible to [`Formatter`], and formatting patterns related to source
+//!    location will be available. If you do not want the source location
 //!    information to appear in your binary file, you may prefer not to enable
 //!    it.
 //!
 //!  - `flexible-string` improves the performance of formatting records, however
-//!    contains unsafe code. For more details, see the documentation of
+//!    it contains unsafe code. For more details, see the documentation of
 //!    [`StringBuf`].
 //!
-//!  - `log` see [Compatible with log crate](#compatible-with-log-crate) above.
+//!  - `log` enables the compatibility with [log crate].
 //!
 //!  - `native` enables platform-specific components, such as
-//!    [`sink::WinDebugSink`], [`sink::JournaldSink`], etc. Note If the
-//!    component requires additional system dependencies, then more granular
-//!    features need to be enabled as well. See the documentation of the
-//!    component for these details.
+//!    [`sink::WinDebugSink`] for Windows, [`sink::JournaldSink`] for Linux,
+//!    etc. Note If the component requires additional system dependencies, then
+//!    more granular features need to be enabled as well.
 //!
 //!  - `runtime-pattern` enables the ability to build patterns with runtime
 //!    template string. See [`RuntimePattern`] for more details.
 //!
-//! # Supported Rust Versions
+//! # Supported Rust versions
 //!
 //! <!--
 //! When updating this, also update:
@@ -235,20 +259,17 @@
 //! [^2]: C++ `spdlog` is also planned to remove it in v2.x.
 //!
 //! [spdlog]: https://github.com/gabime/spdlog
+//! [`FileSink`]: crate::sink::FileSink
+//! [`RotatingFileSink`]: crate::sink::RotatingFileSink
+//! [`AsyncPoolSink`]: crate::sink::AsyncPoolSink
 //! [./examples]: https://github.com/SpriteOvO/spdlog-rs/tree/main/spdlog/examples
 //! [open a discussion]: https://github.com/SpriteOvO/spdlog-rs/discussions/new
 //! [open an issue]: https://github.com/SpriteOvO/spdlog-rs/issues/new/choose
 //! [log crate]: https://crates.io/crates/log
-//! [Asynchronous combined sink]: sink/index.html#asynchronous-combined-sink
-//! [`pattern!`]: crate::formatter::pattern
-//! [`runtime_pattern!`]: crate::formatter::runtime_pattern
-//! [`RuntimePattern`]: crate::formatter::RuntimePattern
-//! [`FullFormatter`]: crate::formatter::FullFormatter
-//! [`RotatingFileSink`]: crate::sink::RotatingFileSink
 //! [`Formatter`]: crate::formatter::Formatter
+//! [`RuntimePattern`]: crate::formatter::RuntimePattern
 //! [`RotationPolicy::Daily`]: crate::sink::RotationPolicy::Daily
 //! [`RotationPolicy::Hourly`]: crate::sink::RotationPolicy::Hourly
-//! [`AsyncPoolSink`]: crate::sink::AsyncPoolSink
 
 #![allow(unexpected_cfgs)]
 // Credits: https://blog.wnut.pw/2020/03/24/documentation-and-unstable-rustdoc-features/
@@ -385,20 +406,20 @@ fn default_logger_ref() -> &'static ArcSwap<Logger> {
     })
 }
 
-/// Returns an [`Arc`] default logger.
+/// Returns the global default logger.
 ///
 /// This default logger will be used by logging macros, if the `logger`
 /// parameter is not specified when logging macros are called.
 ///
 /// If the default logger has not been replaced, the default:
 ///
-///  - Contains a sink [`StdStreamSink`], writing logs on [`Level::Info`] and
+///  - contains a sink [`StdStreamSink`], writing logs on [`Level::Info`] and
 ///    more verbose levels to `stdout`.
 ///
-///  - Contains a sink [`StdStreamSink`], writing logs on [`Level::Warn`] level
+///  - contains a sink [`StdStreamSink`], writing logs on [`Level::Warn`] level
 ///    and more severe levels to `stderr`.
 ///
-///  - Level filter ignores logs on [`Level::Debug`] and more verbose levels.
+///  - level filter ignores logs on [`Level::Debug`] and more verbose levels.
 ///
 ///    However, if you want to enable logging for all levels:
 ///    ```
@@ -416,7 +437,7 @@ fn default_logger_ref() -> &'static ArcSwap<Logger> {
 /// # use std::sync::Arc;
 /// use spdlog::prelude::*;
 ///
-/// let default_logger: Arc<Logger> = spdlog::default_logger();
+/// let default_logger = spdlog::default_logger();
 ///
 /// default_logger.set_level_filter(LevelFilter::All);
 ///
@@ -433,8 +454,8 @@ pub fn default_logger() -> Arc<Logger> {
     default_logger_ref().load().clone()
 }
 
-/// Sets the given logger as the default logger, and returns the old default
-/// logger.
+/// Sets the given logger as the new global default logger, and returns the old
+/// one.
 ///
 /// # Examples
 ///
@@ -442,8 +463,9 @@ pub fn default_logger() -> Arc<Logger> {
 /// # use std::sync::Arc;
 /// use spdlog::prelude::*;
 ///
-/// # let new_logger = spdlog::default_logger();
-/// let old_logger: Arc<Logger> = spdlog::swap_default_logger(new_logger);
+/// let new_logger: Arc<Logger> = /* ... */
+/// # spdlog::default_logger();
+/// let old_logger = spdlog::swap_default_logger(new_logger);
 ///
 /// info!("this log will be handled by `new_logger`");
 /// info!(logger: old_logger, "this log will be handled by `old_logger`");
@@ -452,7 +474,7 @@ pub fn swap_default_logger(logger: Arc<Logger>) -> Arc<Logger> {
     default_logger_ref().swap(logger)
 }
 
-/// Sets the given logger as the default logger.
+/// Sets the given logger as the new global default logger.
 ///
 /// # Examples
 ///
@@ -469,7 +491,7 @@ pub fn set_default_logger(logger: Arc<Logger>) {
     swap_default_logger(logger);
 }
 
-/// Initialize environment variable level filters from environment variable
+/// Initializes environment variable level filters from environment variable
 /// `SPDLOG_RS_LEVEL`.
 ///
 /// Returns whether the level in the environment variable was applied if there
@@ -622,7 +644,7 @@ pub fn init_env_level() -> StdResult<bool, EnvLevelError> {
     init_env_level_from("SPDLOG_RS_LEVEL")
 }
 
-/// Initialize environment variable level filters from a specified environment
+/// Initializes environment variable level filters from a specified environment
 /// variable.
 ///
 /// For more information, see [`init_env_level`].
@@ -668,27 +690,25 @@ pub fn init_env_level_from<K: AsRef<OsStr>>(env_key: K) -> StdResult<bool, EnvLe
     Ok(true)
 }
 
-/// Initialize log crate proxy.
+/// Initializes the log crate proxy.
 ///
 /// This function calls [`log::set_logger`] to set up a [`LogCrateProxy`] and
 /// all logs from log crate will be forwarded to `spdlog-rs`'s logger.
 ///
-/// Users should call this function only once. Get the proxy to configure by
+/// Users should call this function only once, and then configure the proxy by
 /// calling [`log_crate_proxy()`].
 ///
 /// Note that the `log` crate uses a different log level filter and by default
 /// it rejects all log messages. To log messages via the `log` crate, you have
 /// to call [`log::set_max_level`] manually before logging. For more
-/// information, please read the documentation of [`log::set_max_level`].
-///
-/// For more details, please read documentation of [`log::set_logger`] and
-/// [`LogCrateProxy`].
+/// information, please read the upstream documentation of
+/// [`log::set_max_level`].
 #[cfg(feature = "log")]
 pub fn init_log_crate_proxy() -> StdResult<(), re_export::log::SetLoggerError> {
     log::set_logger(log_crate_proxy())
 }
 
-/// Returns a [`LogCrateProxy`].
+/// Returns the global instance of log crate proxy.
 #[cfg(feature = "log")]
 #[must_use]
 pub fn log_crate_proxy() -> &'static LogCrateProxy {
diff --git a/spdlog/src/log_crate_proxy.rs b/spdlog/src/log_crate_proxy.rs
index cb95391..ab20f3d 100644
--- a/spdlog/src/log_crate_proxy.rs
+++ b/spdlog/src/log_crate_proxy.rs
@@ -2,14 +2,14 @@ use std::time::SystemTime;
 
 use crate::{default_logger, sync::*, Logger, Record};
 
-/// Log crate proxy.
+/// Proxy layer for compatible [log crate].
 ///
-/// It forwards all log messages from `log` crate to [`default_logger`] by
-/// default, and you can set a separate logger for it via
-/// [`LogCrateProxy::set_logger`].
+/// Call [`init_log_crate_proxy`] to initialize the proxy, and then configure
+/// the proxy via [`log_crate_proxy`].
 ///
-/// If upstream dependencies use `log` crate to output log messages, they may
-/// also be received by `LogCrateProxy`.
+/// After the proxy is initialized, it will forward all log messages from `log`
+/// crate to the global default logger or the logger set by
+/// [`LogCrateProxy::set_logger`].
 ///
 /// Note that the `log` crate uses a different log level filter and by default
 /// it rejects all log messages. To make `LogCrateProxy` able to receive log
@@ -30,6 +30,9 @@ use crate::{default_logger, sync::*, Logger, Record};
 ///
 /// For more and detailed examples, see [./examples] directory.
 ///
+/// [log crate]: https://crates.io/crates/log
+/// [`init_log_crate_proxy`]: crate::init_log_crate_proxy
+/// [`log_crate_proxy`]: crate::log_crate_proxy()
 /// [`re_export::log::set_max_level`]: crate::re_export::log::set_max_level
 /// [`re_export::log::LevelFilter`]: crate::re_export::log::LevelFilter
 /// [./examples]: https://github.com/SpriteOvO/spdlog-rs/tree/main/spdlog/examples
@@ -44,18 +47,18 @@ impl LogCrateProxy {
         Self::default()
     }
 
-    /// Swaps a logger.
+    /// Sets a logger as the new receiver, and returens the old one.
     ///
-    /// If the argument `logger` is `None`, the return value of
-    /// [`default_logger`] will be used.
+    /// If the argument `logger` is `None`, the global default logger will be
+    /// used.
     pub fn swap_logger(&self, logger: Option<Arc<Logger>>) -> Option<Arc<Logger>> {
         self.logger.swap(logger)
     }
 
-    /// Sets a logger.
+    /// Sets a logger as the new receiver.
     ///
-    /// If the argument `logger` is `None`, the return value of
-    /// [`default_logger`] will be used.
+    /// If the argument `logger` is `None`, the global default logger will be
+    /// used.
     pub fn set_logger(&self, logger: Option<Arc<Logger>>) {
         self.swap_logger(logger);
     }
diff --git a/spdlog/src/log_macros.rs b/spdlog/src/log_macros.rs
index 71a5cb8..0ab0f07 100644
--- a/spdlog/src/log_macros.rs
+++ b/spdlog/src/log_macros.rs
@@ -1,10 +1,8 @@
-//! Provides log macros.
-
-/// Logs a message.
+/// Logs a message at the specified level.
 ///
 /// This macro will generically log with the specified [`Level`] and `format!`
 /// based argument list.
-///
+#[doc = include_str!("./include/doc/log-macro-nameed-opt-params.md")]
 /// # Examples
 ///
 /// ```
@@ -12,11 +10,12 @@
 ///
 /// # let app_events = spdlog::default_logger();
 /// let data = (42, "Forty-two");
-/// let private_data = "private";
 ///
-/// log!(Level::Error, "Received errors: {}, {}", data.0, data.1);
-/// log!(logger: app_events, Level::Warn, "App warning: {}, {}, {}",
-///     data.0, data.1, private_data);
+/// // Using the global default logger
+/// log!(Level::Info, "Received data: {}, {}", data.0, data.1);
+///
+/// // Or using the specified logger
+/// log!(logger: app_events, Level::Info, "Received data: {}, {}", data.0, data.1);
 /// ```
 ///
 /// [`Level`]: crate::Level
@@ -34,7 +33,7 @@ macro_rules! log {
 }
 
 /// Logs a message at the critical level.
-///
+#[doc = include_str!("./include/doc/log-macro-nameed-opt-params.md")]
 /// # Examples
 ///
 /// ```
@@ -43,7 +42,10 @@ macro_rules! log {
 /// # let app_events = spdlog::default_logger();
 /// let (left, right) = (true, false);
 ///
+/// // Using the global default logger
 /// critical!("Runtime assertion failed. Left: `{}`, Right: `{}`", left, right);
+///
+/// // Or using the specified logger
 /// critical!(logger: app_events, "Runtime assertion failed. Left: `{}`, Right: `{}`", left, right);
 /// ```
 #[macro_export]
@@ -57,7 +59,7 @@ macro_rules! critical {
 }
 
 /// Logs a message at the error level.
-///
+#[doc = include_str!("./include/doc/log-macro-nameed-opt-params.md")]
 /// # Examples
 ///
 /// ```
@@ -66,7 +68,10 @@ macro_rules! critical {
 /// # let app_events = spdlog::default_logger();
 /// let (err_info, port) = ("No connection", 22);
 ///
+/// // Using the global default logger
 /// error!("Error: {} on port {}", err_info, port);
+///
+/// // Or using the specified logger
 /// error!(logger: app_events, "App Error: {}, Port: {}", err_info, port);
 /// ```
 #[macro_export]
@@ -80,7 +85,7 @@ macro_rules! error {
 }
 
 /// Logs a message at the warn level.
-///
+#[doc = include_str!("./include/doc/log-macro-nameed-opt-params.md")]
 /// # Examples
 ///
 /// ```
@@ -89,7 +94,10 @@ macro_rules! error {
 /// # let input_events = spdlog::default_logger();
 /// let warn_description = "Invalid Input";
 ///
+/// // Using the global default logger
 /// warn!("Warning! {}!", warn_description);
+///
+/// // Or using the specified logger
 /// warn!(logger: input_events, "App received warning: {}", warn_description);
 /// ```
 #[macro_export]
@@ -103,19 +111,21 @@ macro_rules! warn {
 }
 
 /// Logs a message at the info level.
-///
+#[doc = include_str!("./include/doc/log-macro-nameed-opt-params.md")]
 /// # Examples
 ///
 /// ```
 /// use spdlog::info;
 ///
 /// # struct Connection { port: u32, speed: f32 }
-/// # let connection_events = spdlog::default_logger();
+/// # let conn_events = spdlog::default_logger();
 /// let conn_info = Connection { port: 40, speed: 3.20 };
 ///
+/// // Using the global default logger
 /// info!("Connected to port {} at {} Mb/s", conn_info.port, conn_info.speed);
-/// info!(logger: connection_events, "Successfull connection, port: {}, speed: {}",
-///       conn_info.port, conn_info.speed);
+///
+/// // Or using the specified logger
+/// info!(logger: conn_events, "Successfull connection, port: {}, speed: {}", conn_info.port, conn_info.speed);
 /// ```
 #[macro_export]
 macro_rules! info {
@@ -128,7 +138,7 @@ macro_rules! info {
 }
 
 /// Logs a message at the debug level.
-///
+#[doc = include_str!("./include/doc/log-macro-nameed-opt-params.md")]
 /// # Examples
 ///
 /// ```
@@ -138,7 +148,10 @@ macro_rules! info {
 /// # let app_events = spdlog::default_logger();
 /// let pos = Position { x: 3.234, y: -1.223 };
 ///
+/// // Using the global default logger
 /// debug!("New position: x: {}, y: {}", pos.x, pos.y);
+///
+/// // Or using the specified logger
 /// debug!(logger: app_events, "New position: x: {}, y: {}", pos.x, pos.y);
 /// ```
 #[macro_export]
@@ -152,7 +165,7 @@ macro_rules! debug {
 }
 
 /// Logs a message at the trace level.
-///
+#[doc = include_str!("./include/doc/log-macro-nameed-opt-params.md")]
 /// # Examples
 ///
 /// ```
@@ -162,7 +175,10 @@ macro_rules! debug {
 /// # let app_events = spdlog::default_logger();
 /// let pos = Position { x: 3.234, y: -1.223 };
 ///
+/// // Using the global default logger
 /// trace!("Position is: x: {}, y: {}", pos.x, pos.y);
+///
+/// // Or using the specified logger
 /// trace!(logger: app_events, "x is {} and y is {}",
 ///        if pos.x >= 0.0 { "positive" } else { "negative" },
 ///        if pos.y >= 0.0 { "positive" } else { "negative" });
diff --git a/spdlog/src/logger.rs b/spdlog/src/logger.rs
index 79f8443..778cdae 100644
--- a/spdlog/src/logger.rs
+++ b/spdlog/src/logger.rs
@@ -1,5 +1,3 @@
-//! Provides a logger structure.
-
 use std::{result::Result as StdResult, time::Duration};
 
 use crate::{
@@ -34,33 +32,79 @@ fn check_logger_name(name: impl AsRef<str>) -> StdResult<(), SetLoggerNameError>
     }
 }
 
-/// A logger structure.
+/// Manages, controls and manipulates multiple sinks.
+///
+/// Logger is an entry point for a log to be processed, the [`Logger::log`]
+/// method will be called by logging macros.
+///
+/// ---
+///
+/// A Logger:
+///
+/// - contains one or more [sink]s, each log will be passed into sinks in
+///   sequence;
+///
+/// - has a level filter of its own, which is not shared with the level filter
+///   of sinks;
 ///
-/// A logger contains a combination of sinks, and sinks implement writing log
-/// messages to actual targets.
+/// - has automatic flushing policies that can be optionally enabled:
+///   - Flush level filter: Flush once when the filter returns `true` for a log.
+///   - Flush period: Flush periodically.
 ///
-/// Users usually log messages through log macros.
+///   These two automatic flushing policies can work at the same time.
+///
+/// ---
+///
+/// *spdlog-rs* has a global [`default_logger`], you can modify it, or configure
+/// a new logger to suit your needs and then replace it. Basically for a
+/// lightweight program, such a global singleton logger is enough. For a complex
+/// program, for example if you have a number of different components, you can
+/// also configure multiple loggers and store them independently inside the
+/// component struct, which allows different components to have different
+/// approaches for logging.
 ///
 /// # Examples
 ///
+/// - Logging to the global default logger.
+///
 /// ```
-/// # use std::sync::Arc;
-/// use std::time::Duration;
 /// use spdlog::prelude::*;
 ///
-/// # let custom_logger: Arc<Logger> = spdlog::default_logger();
-/// let default_logger: Arc<Logger> = spdlog::default_logger();
-/// default_logger.set_level_filter(LevelFilter::All);
-/// default_logger.set_flush_period(Some(Duration::from_secs(10)));
-/// info!("logging with default logger");
+/// info!("logging to the default logger");
+///
+/// spdlog::default_logger().set_level_filter(LevelFilter::All);
+/// trace!("logging to the default logger at trace level");
+/// ```
+///
+/// - Logging to a separated logger.
+///
+/// ```
+/// # use spdlog::prelude::*;
+/// let separated_logger = /* ... */
+/// # spdlog::default_logger();
 ///
-/// custom_logger.set_level_filter(LevelFilter::All);
-/// custom_logger.set_flush_period(Some(Duration::from_secs(10)));
-/// info!(logger: custom_logger, "logging with custom logger");
+/// info!(logger: separated_logger, "logging to a separated logger");
+/// error!(logger: separated_logger, "logging to a separated logger at error level");
 /// ```
 ///
-/// For more examples, see [./examples] directory.
+/// - Fork, configure and replace the default logger.
+///
+/// ```
+/// # use spdlog::prelude::*;
+/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+/// let new_logger = spdlog::default_logger().fork_with(|new_logger| {
+///     // Configure the new logger...
+///     Ok(())
+/// })?;
+/// spdlog::set_default_logger(new_logger);
+/// info!("logging to the default logger, but it's reconfigured");
+/// # Ok(()) }
+/// ```
 ///
+/// - For more examples, see [./examples] directory.
+///
+/// [sink]: crate::sink
+/// [`default_logger`]: crate::default_logger
 /// [./examples]: https://github.com/SpriteOvO/spdlog-rs/tree/main/spdlog/examples
 pub struct Logger {
     name: Option<String>,
@@ -72,7 +116,24 @@ pub struct Logger {
 }
 
 impl Logger {
-    /// Constructs a [`LoggerBuilder`].
+    /// Gets a [`LoggerBuilder`] with default parameters:
+    ///
+    /// | Parameter            | Default Value           |
+    /// |----------------------|-------------------------|
+    /// | [name]               | `None`                  |
+    /// | [sinks]              | `[]`                    |
+    /// | [level_filter]       | `MoreSevereEqual(Info)` |
+    /// | [flush_level_filter] | `Off`                   |
+    /// | [flush_period]       | `None`                  |
+    /// | [error_handler]      | [default error handler] |
+    ///
+    /// [name]: LoggerBuilder::name
+    /// [sinks]: LoggerBuilder::sink
+    /// [level_filter]: LoggerBuilder::level_filter
+    /// [flush_level_filter]: LoggerBuilder::flush_level_filter
+    /// [flush_period]: Logger::set_flush_period
+    /// [error_handler]: LoggerBuilder::error_handler
+    /// [default error handler]: error/index.html#default-error-handler
     #[must_use]
     pub fn builder() -> LoggerBuilder {
         LoggerBuilder {
@@ -107,19 +168,17 @@ impl Logger {
         Ok(())
     }
 
-    /// Determines if a log message with the specified level would be
-    /// logged.
+    /// Determines if a log with the specified level would be logged.
     ///
-    /// This allows callers to avoid expensive computation of log message
-    /// arguments if the message would be discarded anyway.
+    /// This allows callers to avoid expensive computation of log arguments if
+    /// the would be discarded anyway.
     ///
     /// # Examples
     ///
     /// ```
     /// # use std::sync::Arc;
     /// use spdlog::prelude::*;
-    ///
-    /// let logger: Arc<Logger> = spdlog::default_logger();
+    /// # let logger = spdlog::default_logger();
     ///
     /// logger.set_level_filter(LevelFilter::MoreSevere(Level::Info));
     /// assert_eq!(logger.should_log(Level::Debug), false);
@@ -138,9 +197,14 @@ impl Logger {
         self.level_filter().test(level)
     }
 
-    /// Logs a record.
+    /// Passes a log into sinks in sequence.
+    ///
+    /// It calls [`Sink::log`] method internally for each sink in sequence.
     ///
-    /// Users usually do not use this function directly, use log macros instead.
+    /// # Note
+    ///
+    /// Users usually do not use this function directly, use logging macros
+    /// instead.
     pub fn log(&self, record: &Record) {
         if !self.should_log(record.level()) {
             return;
@@ -148,14 +212,16 @@ impl Logger {
         self.sink_record(record);
     }
 
-    /// Flushes any buffered records.
+    /// Flushes sinks explicitly.
+    ///
+    /// It calls [`Sink::flush`] method internally for each sink in sequence.
     ///
-    /// Users can call this function to flush manually or use auto-flush
-    /// policies. See also [`Logger::flush_level_filter`] and
+    /// Users can call this function to flush explicitly and/or use automatic
+    /// flushing policies. See also [`Logger::flush_level_filter`] and
     /// [`Logger::set_flush_period`].
     ///
-    /// Note that it is expensive, calling it frequently will affect
-    /// performance.
+    /// Be aware that the method can be expensive, calling it frequently may
+    /// affect performance.
     pub fn flush(&self) {
         self.flush_sinks();
     }
@@ -168,11 +234,11 @@ impl Logger {
 
     /// Sets a flush level filter.
     ///
-    /// When logging a new record, flush the buffer if this filter condition is
-    /// true.
+    /// When logging a new record, flush the buffer if this filter condition
+    /// returns `true`.
     ///
-    /// This auto-flush policy can work with [`Logger::set_flush_period`]
-    /// together.
+    /// This automatic flushing policy can work with
+    /// [`Logger::set_flush_period`] at the same time.
     ///
     /// # Examples
     ///
@@ -195,13 +261,13 @@ impl Logger {
             .store(level_filter, Ordering::Relaxed);
     }
 
-    /// Gets the log filter level.
+    /// Gets the log level filter.
     #[must_use]
     pub fn level_filter(&self) -> LevelFilter {
         self.level_filter.load(Ordering::Relaxed)
     }
 
-    /// Sets the log filter level.
+    /// Sets the log level filter.
     ///
     /// # Examples
     ///
@@ -210,13 +276,13 @@ impl Logger {
         self.level_filter.store(level_filter, Ordering::Relaxed);
     }
 
-    /// Sets periodic flush.
+    /// Sets automatic periodic flushing.
     ///
     /// This function receives a `&Arc<Self>`. Calling it will spawn a new
-    /// thread.
+    /// thread internally.
     ///
-    /// This auto-flush policy can work with [`Logger::set_flush_level_filter`]
-    /// together.
+    /// This automatic flushing policy can work with
+    /// [`Logger::set_flush_level_filter`] at the same time.
     ///
     /// # Panics
     ///
@@ -233,10 +299,10 @@ impl Logger {
     /// # use spdlog::prelude::*;
     ///
     /// # let logger: Arc<Logger> = spdlog::default_logger();
-    /// // From now on, auto-flush the `logger` buffer every 10 seconds.
+    /// // From now on, the `logger` will automatically call `flush` method the every 10 seconds.
     /// logger.set_flush_period(Some(Duration::from_secs(10)));
     ///
-    /// // Remove periodic auto-flush.
+    /// // Disable automatic periodic flushing.
     /// logger.set_flush_period(None);
     /// ```
     pub fn set_flush_period(self: &Arc<Self>, interval: Option<Duration>) {
@@ -283,15 +349,15 @@ impl Logger {
     /// ```
     /// use spdlog::prelude::*;
     ///
-    /// spdlog::default_logger().set_error_handler(Some(|err: spdlog::Error| {
-    ///     panic!("spdlog-rs error: {}", err)
+    /// spdlog::default_logger().set_error_handler(Some(|err| {
+    ///     panic!("An error occurred in the default logger: {}", err)
     /// }));
     /// ```
     pub fn set_error_handler(&self, handler: Option<ErrorHandler>) {
         *self.error_handler.write() = handler;
     }
 
-    /// Fork and configure a separate new logger.
+    /// Forks and configures a separate new logger.
     ///
     /// This function creates a new logger object that inherits logger
     /// properties from `Arc<Self>`. Then this function calls the given
@@ -312,7 +378,7 @@ impl Logger {
     /// # Arc::new(Logger::builder().build().unwrap());
     /// // Fork from an existing logger and add a new sink.
     /// # let new_sink = test_sink.clone();
-    /// let new: Arc<Logger> = old.fork_with(|new: &mut Logger| {
+    /// let new = old.fork_with(|new| {
     ///     new.sinks_mut().push(new_sink);
     ///     Ok(())
     /// })?;
@@ -341,7 +407,7 @@ impl Logger {
         Ok(new_logger)
     }
 
-    /// Fork a separate new logger with a new name.
+    /// Forks a separates new logger with a new name.
     ///
     /// This function creates a new logger object that inherits logger
     /// properties from `Arc<Self>` and rename the new logger object to the
@@ -357,8 +423,8 @@ impl Logger {
     /// # use spdlog::prelude::*;
     /// #
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let old: Arc<Logger> = Arc::new(Logger::builder().name("dog").build()?);
-    /// let new: Arc<Logger> = old.fork_with_name(Some("cat"))?;
+    /// let old = Arc::new(Logger::builder().name("dog").build()?);
+    /// let new = old.fork_with_name(Some("cat"))?;
     ///
     /// assert_eq!(old.name(), Some("dog"));
     /// assert_eq!(new.name(), Some("cat"));
@@ -447,7 +513,7 @@ impl Clone for Logger {
     }
 }
 
-/// The builder of [`Logger`].
+#[allow(missing_docs)]
 #[derive(Clone)]
 pub struct LoggerBuilder {
     name: Option<String>,
@@ -471,7 +537,7 @@ impl LoggerBuilder {
 
     /// Sets the name of the logger.
     ///
-    /// This parameter is **optional**, and defaults to `None`.
+    /// This parameter is **optional**.
     ///
     /// # Requirements
     ///
@@ -488,10 +554,9 @@ impl LoggerBuilder {
         self
     }
 
-    /// Sets the log filter level.
+    /// Sets the log level filter.
     ///
-    /// This parameter is **optional**, and defaults to
-    /// `LevelFilter::MoreSevereEqual(Level::Info)`.
+    /// This parameter is **optional**.
     pub fn level_filter(&mut self, level_filter: LevelFilter) -> &mut Self {
         self.level_filter = level_filter;
         self
@@ -514,7 +579,7 @@ impl LoggerBuilder {
 
     /// Sets the flush level filter.
     ///
-    /// This paramter is **optional**, and defaults to [`LevelFilter::Off`].
+    /// This paramter is **optional**.
     ///
     /// See the documentation of [`Logger::set_flush_level_filter`] for the
     /// description of this parameter.
@@ -525,7 +590,7 @@ impl LoggerBuilder {
 
     /// Sets the error handler.
     ///
-    /// This parameter is **optional**, and defaults to `None`.
+    /// This parameter is **optional**.
     ///
     /// See the documentation of [`Logger::set_error_handler`] for the
     /// description of this parameter.
diff --git a/spdlog/src/record.rs b/spdlog/src/record.rs
index 1018b48..70561cc 100644
--- a/spdlog/src/record.rs
+++ b/spdlog/src/record.rs
@@ -1,5 +1,3 @@
-//! Provides a log record structure.
-
 use std::{
     borrow::{Borrow, Cow},
     cell::RefCell,
@@ -38,9 +36,6 @@ struct RecordInner {
 }
 
 impl<'a> Record<'a> {
-    /// Constructs a `Record`.
-    ///
-    /// [`Sink`]: crate::sink::Sink
     #[must_use]
     pub(crate) fn new<S>(level: Level, payload: S) -> Record<'a>
     where
@@ -58,9 +53,6 @@ impl<'a> Record<'a> {
         }
     }
 
-    /// Constructs a [`RecordBuilder`].
-    ///
-    /// [`Sink`]: crate::sink::Sink
     #[must_use]
     pub(crate) fn builder<S>(level: Level, payload: S) -> RecordBuilder<'a>
     where
@@ -225,9 +217,7 @@ impl RecordOwned {
     // When adding more getters, also add to `Record`
 }
 
-/// The builder of [`Record`].
-///
-/// [`Sink`]: crate::sink::Sink
+#[allow(missing_docs)]
 #[derive(Clone, Debug)]
 pub(crate) struct RecordBuilder<'a> {
     record: Record<'a>,
diff --git a/spdlog/src/sink/async_sink/async_pool_sink.rs b/spdlog/src/sink/async_sink/async_pool_sink.rs
index 99b1e51..4adaf73 100644
--- a/spdlog/src/sink/async_sink/async_pool_sink.rs
+++ b/spdlog/src/sink/async_sink/async_pool_sink.rs
@@ -6,11 +6,31 @@ use crate::{
     Error, ErrorHandler, LevelFilter, Record, RecordOwned, Result, ThreadPool,
 };
 
-/// A [combined sink], logging and flushing [asynchronously]
-/// (thread-pool-based).
+/// A [combined sink], logging and flushing asynchronously (thread-pool-based).
+///
+/// Expensive operations (such as `log` and `flush`) on asynchronous sinks will
+/// be performed asynchronously on other threads.
+///
+/// Since there is no waiting, errors that occur while performing asynchronous
+/// operations will not be returned to the upper level, and instead the error
+/// handler of the sink will be called.
+///
+/// Users should only use asynchronous combined sinks to wrap actual sinks that
+/// require a long time for operations (e.g., file sinks that are frequently
+/// flushed, sinks involving networks), otherwise they will not get a
+/// performance boost or even worse.
+///
+/// Since the thread pool has a capacity limit, the queue may be full in some
+/// cases. When users encounter this situation, they have the following options:
+///
+///  - Adjust to a larger capacity via [`ThreadPoolBuilder::capacity`].
+///
+///  - Adjust the overflow policy via [`AsyncPoolSinkBuilder::overflow_policy`].
+///
+///  - Set up an error handler on asynchronous combined sinks via
+///    [`AsyncPoolSinkBuilder::error_handler`]. The handler will be called when
+///    a record is dropped or an operation has failed.
 ///
-/// This sink sends `log` and `flush` operations to the inside thread pool for
-/// asynchronous processing.
 ///
 /// # Note
 ///
@@ -22,7 +42,7 @@ use crate::{
 /// See [./examples] directory.
 ///
 /// [combined sink]: index.html#combined-sink
-/// [asynchronously]: index.html#asynchronous-combined-sink
+/// [`ThreadPoolBuilder::capacity`]: crate::ThreadPoolBuilder::capacity
 /// [./examples]: https://github.com/SpriteOvO/spdlog-rs/tree/main/examples
 // The names `AsyncSink` and `AsyncRuntimeSink` is reserved for future use.
 pub struct AsyncPoolSink {
@@ -33,7 +53,20 @@ pub struct AsyncPoolSink {
 }
 
 impl AsyncPoolSink {
-    /// Constructs a builder of `AsyncPoolSink`.
+    /// Constructs a builder of `AsyncPoolSink` with default parameters:
+    ///
+    /// | Parameter         | Default Value                       |
+    /// |-------------------|-------------------------------------|
+    /// | [level_filter]    | `All`                               |
+    /// | [error_handler]   | [default error handler]             |
+    /// | [overflow_policy] | `Block`                             |
+    /// | [thread_pool]     | internal shared default thread pool |
+    ///
+    /// [level_filter]: AsyncPoolSinkBuilder::level_filter
+    /// [error_handler]: AsyncPoolSinkBuilder::error_handler
+    /// [default error handler]: error/index.html#default-error-handler
+    /// [overflow_policy]: AsyncPoolSinkBuilder::overflow_policy
+    /// [thread_pool]: AsyncPoolSinkBuilder::thread_pool
     #[must_use]
     pub fn builder() -> AsyncPoolSinkBuilder {
         AsyncPoolSinkBuilder {
@@ -109,7 +142,7 @@ impl Sink for AsyncPoolSink {
     }
 }
 
-/// The builder of [`AsyncPoolSink`].
+#[allow(missing_docs)]
 pub struct AsyncPoolSinkBuilder {
     level_filter: LevelFilter,
     sinks: Sinks,
@@ -138,10 +171,10 @@ impl AsyncPoolSinkBuilder {
 
     /// Specifies a overflow policy.
     ///
-    /// This parameter is **optional**, and defaults to
-    /// [`OverflowPolicy::Block`].
+    /// This parameter is **optional**.
     ///
-    /// For more details, see the documentation of [`OverflowPolicy`].
+    /// When the channel is full, an incoming operation is handled according to
+    /// the specified policy.
     #[must_use]
     pub fn overflow_policy(mut self, overflow_policy: OverflowPolicy) -> Self {
         self.overflow_policy = overflow_policy;
@@ -150,10 +183,7 @@ impl AsyncPoolSinkBuilder {
 
     /// Specifies a custom thread pool.
     ///
-    /// This parameter is **optional**, and defaults to the built-in thread
-    /// pool.
-    ///
-    /// For more details, see the documentation of [`AsyncPoolSinkBuilder`].
+    /// This parameter is **optional**.
     #[must_use]
     pub fn thread_pool(mut self, thread_pool: Arc<ThreadPool>) -> Self {
         self.thread_pool = Some(thread_pool);
diff --git a/spdlog/src/sink/async_sink/mod.rs b/spdlog/src/sink/async_sink/mod.rs
index ef0df9c..fb09d97 100644
--- a/spdlog/src/sink/async_sink/mod.rs
+++ b/spdlog/src/sink/async_sink/mod.rs
@@ -7,7 +7,7 @@ pub use async_pool_sink::*;
 /// When the channel is full, an incoming operation is handled according to the
 /// specified policy.
 ///
-/// [asynchronous sinks]: index.html#asynchronous-combined-sink
+/// [asynchronous sinks]: crate::sink::AsyncPoolSink
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 #[non_exhaustive]
 pub enum OverflowPolicy {
diff --git a/spdlog/src/sink/dedup_sink.rs b/spdlog/src/sink/dedup_sink.rs
index 5974900..8b490e8 100644
--- a/spdlog/src/sink/dedup_sink.rs
+++ b/spdlog/src/sink/dedup_sink.rs
@@ -86,7 +86,23 @@ pub struct DedupSink {
 }
 
 impl DedupSink {
-    /// Constructs a builder of `DedupSink`.
+    /// Gets a builder of `DedupSink` with default parameters:
+    ///
+    /// | Parameter       | Default Value           |
+    /// |-----------------|-------------------------|
+    /// | [level_filter]  | `All`                   |
+    /// | [formatter]     | `FullFormatter`         |
+    /// | [error_handler] | [default error handler] |
+    /// |                 |                         |
+    /// | [sinks]         | `[]`                    |
+    /// | [skip_duration] | *must be specified*     |
+    ///
+    /// [level_filter]: DedupSinkBuilder::level_filter
+    /// [formatter]: DedupSinkBuilder::formatter
+    /// [error_handler]: DedupSinkBuilder::error_handler
+    /// [default error handler]: error/index.html#default-error-handler
+    /// [sinks]: DedupSinkBuilder::sink
+    /// [skip_duration]: DedupSinkBuilder::skip_duration
     #[must_use]
     pub fn builder() -> DedupSinkBuilder<()> {
         DedupSinkBuilder {
@@ -163,7 +179,8 @@ impl Sink for DedupSink {
     helper::common_impl!(@Sink: common_impl);
 }
 
-/// The builder of [`DedupSink`].
+/// #
+#[doc = include_str!("../include/doc/generic-builder-note.md")]
 pub struct DedupSinkBuilder<ArgS> {
     common_builder_impl: helper::CommonBuilderImpl,
     sinks: Sinks,
diff --git a/spdlog/src/sink/file_sink.rs b/spdlog/src/sink/file_sink.rs
index 6ccce64..f291d23 100644
--- a/spdlog/src/sink/file_sink.rs
+++ b/spdlog/src/sink/file_sink.rs
@@ -15,10 +15,16 @@ use crate::{
 
 /// A sink with a file as the target.
 ///
+/// It writes logs to a single file. If you want to automatically rotate into
+/// multiple files, see  [`RotatingFileSink`].
+///
+/// The file and directories will be created recursively if they do not exist.
+///
 /// # Examples
 ///
 /// See [./examples] directory.
 ///
+/// [`RotatingFileSink`]: crate::sink::RotatingFileSink
 /// [./examples]: https://github.com/SpriteOvO/spdlog-rs/tree/main/spdlog/examples
 pub struct FileSink {
     common_impl: helper::CommonImpl,
@@ -26,7 +32,23 @@ pub struct FileSink {
 }
 
 impl FileSink {
-    /// Constructs a builder of `FileSink`.
+    /// Gets a builder of `FileSink` with default parameters:
+    ///
+    /// | Parameter       | Default Value           |
+    /// |-----------------|-------------------------|
+    /// | [level_filter]  | `All`                   |
+    /// | [formatter]     | `FullFormatter`         |
+    /// | [error_handler] | [default error handler] |
+    /// |                 |                         |
+    /// | [path]          | *must be specified*     |
+    /// | [truncate]      | `false`                 |
+    ///
+    /// [level_filter]: FileSinkBuilder::level_filter
+    /// [formatter]: FileSinkBuilder::formatter
+    /// [error_handler]: FileSinkBuilder::error_handler
+    /// [default error handler]: error/index.html#default-error-handler
+    /// [path]: FileSinkBuilder::path
+    /// [truncate]: FileSinkBuilder::truncate
     #[must_use]
     pub fn builder() -> FileSinkBuilder<()> {
         FileSinkBuilder {
@@ -41,7 +63,7 @@ impl FileSink {
     /// If the parameter `truncate` is `true`, the existing contents of the file
     /// will be discarded.
     ///
-    /// # Errors
+    /// # Error
     ///
     /// If an error occurs opening the file, [`Error::CreateDirectory`] or
     /// [`Error::OpenFile`] will be returned.
@@ -95,36 +117,8 @@ impl Drop for FileSink {
 
 // --------------------------------------------------
 
-/// The builder of [`FileSink`].
+/// #
 #[doc = include_str!("../include/doc/generic-builder-note.md")]
-/// # Examples
-///
-/// - Building a [`FileSink`].
-///
-///   ```no_run
-///   use spdlog::sink::FileSink;
-///  
-///   # fn main() -> Result<(), spdlog::Error> {
-///   let sink: FileSink = FileSink::builder()
-///       .path("/path/to/log_file") // required
-///       // .truncate(true) // optional, defaults to `false`
-///       .build()?;
-///   # Ok(()) }
-///   ```
-///
-/// - If any required parameters are missing, a compile-time error will be
-///   raised.
-///
-///   ```compile_fail,E0061
-///   use spdlog::sink::FileSink;
-///   
-///   # fn main() -> Result<(), spdlog::Error> {
-///   let sink: FileSink = FileSink::builder()
-///       // .path("/path/to/log_file") // required
-///       .truncate(true) // optional, defaults to `false`
-///       .build()?;
-///   # Ok(()) }
-///   ```
 pub struct FileSinkBuilder<ArgPath> {
     common_builder_impl: helper::CommonBuilderImpl,
     path: ArgPath,
@@ -147,9 +141,11 @@ impl<ArgPath> FileSinkBuilder<ArgPath> {
         }
     }
 
-    /// If it is true, the existing contents of the filewill be discarded.
+    /// Truncates the contents when opening an existing file.
+    ///
+    /// If it is `true`, the existing contents of the file will be discarded.
     ///
-    /// This parameter is **optional**, and defaults to `false`.
+    /// This parameter is **optional**.
     #[must_use]
     pub fn truncate(mut self, truncate: bool) -> Self {
         self.truncate = truncate;
@@ -171,7 +167,7 @@ impl FileSinkBuilder<()> {
 impl FileSinkBuilder<PathBuf> {
     /// Builds a [`FileSink`].
     ///
-    /// # Errors
+    /// # Error
     ///
     /// If an error occurs opening the file, [`Error::CreateDirectory`] or
     /// [`Error::OpenFile`] will be returned.
diff --git a/spdlog/src/sink/helper.rs b/spdlog/src/sink/helper.rs
index 71bd374..f970346 100644
--- a/spdlog/src/sink/helper.rs
+++ b/spdlog/src/sink/helper.rs
@@ -139,9 +139,7 @@ macro_rules! common_impl {
         $crate::sink::helper::common_impl! {
             /// Specifies a log level filter.
             ///
-            /// This parameter is **optional**, and defaults to [`LevelFilter::All`].
-            ///
-            /// [`LevelFilter::All`]: crate::LevelFilter::All
+            /// This parameter is **optional**.
             @SinkBuilderCustomInner@level_filter: $($field).+
         }
     };
@@ -158,9 +156,7 @@ macro_rules! common_impl {
         $crate::sink::helper::common_impl! {
             /// Specifies a formatter.
             ///
-            /// This parameter is **optional**, and defaults to [`FullFormatter`].
-            ///
-            /// [`FullFormatter`]: crate::formatter::FullFormatter
+            /// This parameter is **optional**.
             @SinkBuilderCustomInner@formatter: $($field).+
         }
     };
@@ -177,9 +173,7 @@ macro_rules! common_impl {
         $crate::sink::helper::common_impl! {
             /// Specifies an error handler.
             ///
-            /// This parameter is **optional**, and defaults no handler, see [`Sink::set_error_handler`] for details.
-            ///
-            /// [`Sink::set_error_handler`]: crate::Sink::set_error_handler
+            /// This parameter is **optional**.
             @SinkBuilderCustomInner@error_handler: $($field).+
         }
     };
diff --git a/spdlog/src/sink/journald_sink.rs b/spdlog/src/sink/journald_sink.rs
index 4603a44..168154c 100644
--- a/spdlog/src/sink/journald_sink.rs
+++ b/spdlog/src/sink/journald_sink.rs
@@ -94,7 +94,18 @@ pub struct JournaldSink {
 impl JournaldSink {
     const SYSLOG_LEVELS: SyslogLevels = SyslogLevels::new();
 
-    /// Constructs a builder of `JournaldSink`.
+    /// Gets a builder of `JournaldSink` with default parameters:
+    ///
+    /// | Parameter       | Default Value           |
+    /// |-----------------|-------------------------|
+    /// | [level_filter]  | `All`                   |
+    /// | [formatter]     | `JournaldFormatter`     |
+    /// | [error_handler] | [default error handler] |
+    ///
+    /// [level_filter]: JournaldSinkBuilder::level_filter
+    /// [formatter]: JournaldSinkBuilder::formatter
+    /// [error_handler]: JournaldSinkBuilder::error_handler
+    /// [default error handler]: error/index.html#default-error-handler
     #[must_use]
     pub fn builder() -> JournaldSinkBuilder {
         JournaldSinkBuilder {
@@ -137,21 +148,7 @@ impl Sink for JournaldSink {
     helper::common_impl!(@Sink: common_impl);
 }
 
-/// The builder of [`JournaldSink`].
-///
-/// # Examples
-///
-/// - Building a [`JournaldSink`].
-///
-///   ```
-///   use spdlog::{prelude::*, sink::JournaldSink};
-///  
-///   # fn main() -> Result<(), spdlog::Error> {
-///   let sink: JournaldSink = JournaldSink::builder()
-///       .level_filter(LevelFilter::MoreSevere(Level::Info)) // optional
-///       .build()?;
-///   # Ok(()) }
-///   ```
+#[allow(missing_docs)]
 pub struct JournaldSinkBuilder {
     common_builder_impl: helper::CommonBuilderImpl,
 }
diff --git a/spdlog/src/sink/mod.rs b/spdlog/src/sink/mod.rs
index 38ef275..844eb1a 100644
--- a/spdlog/src/sink/mod.rs
+++ b/spdlog/src/sink/mod.rs
@@ -17,33 +17,7 @@
 //! Operations on a combined sink will be forwarded to its sub-sinks according
 //! to the implementation.
 //!
-//! # Asynchronous combined sink
-//!
-//! Asynchronous combined sink is a type of combined sink. Expensive operations
-//! (such as `log` and `flush`) on asynchronous sinks will be performed
-//! asynchronously on other threads.
-//!
-//! Since there is no waiting, errors that occur while performing asynchronous
-//! operations will not be returned to the upper level, and instead the error
-//! handler of the sink will be called.
-//!
-//! Users should only use asynchronous combined sinks to wrap actual sinks that
-//! require a long time for operations (e.g. involving UDP sends), otherwise
-//! they will not get a performance boost or even worse.
-//!
-//! Since the thread pool has a capacity limit, the queue may be full in some
-//! cases. When users encounter this situation, they have the following options:
-//!
-//!  - Adjust to a larger capacity via [`ThreadPoolBuilder::capacity`].
-//!
-//!  - Adjust the overflow policy via [`AsyncPoolSinkBuilder::overflow_policy`].
-//!
-//!  - Set up an error handler on asynchronous combined sinks via
-//!    [`AsyncPoolSinkBuilder::error_handler`]. The handler will be called when
-//!    a record is dropped or an operation has failed.
-//!
 //! [`Logger`]: crate::logger::Logger
-//! [`ThreadPoolBuilder::capacity`]: crate::ThreadPoolBuilder::capacity
 
 #[cfg(feature = "multi-thread")]
 pub(crate) mod async_sink;
@@ -78,7 +52,7 @@ pub use write_sink::*;
 
 use crate::{formatter::Formatter, sync::*, ErrorHandler, Level, LevelFilter, Record, Result};
 
-/// A trait for sinks.
+/// Represents a sink
 pub trait Sink: Sync + Send {
     /// Determines if a log message with the specified level would be logged.
     #[must_use]
@@ -104,16 +78,17 @@ pub trait Sink: Sync + Send {
 
     /// Sets a error handler.
     ///
-    /// Any errors that occur in `Sink` will be returned as directly as possible
-    /// (e.g. returned to [`Logger`]), but some errors that are not likely to be
-    /// returned directly will call this error handler. Most of these errors are
-    /// uncommon.
+    /// Most errors that occur in `Sink` will be returned as directly as
+    /// possible (e.g. returned to [`Logger`]), but some errors that cannot be
+    /// returned immediately, this function will be called. For example,
+    /// asynchronous errors.
     ///
-    /// If no handler is set, errors will be print to `stderr` and then ignored.
+    /// If no handler is set, [default error handler] will be used.
     ///
     /// [`Logger`]: crate::logger::Logger
+    /// [default error handler]: ../error/index.html#default-error-handler
     fn set_error_handler(&self, handler: Option<ErrorHandler>);
 }
 
-/// A container for [`Sink`]s.
+/// Container type for [`Sink`]s.
 pub type Sinks = Vec<Arc<dyn Sink>>;
diff --git a/spdlog/src/sink/rotating_file_sink.rs b/spdlog/src/sink/rotating_file_sink.rs
index 82b63e2..351c0e4 100644
--- a/spdlog/src/sink/rotating_file_sink.rs
+++ b/spdlog/src/sink/rotating_file_sink.rs
@@ -23,44 +23,44 @@ use crate::{
 
 /// Rotation policies for [`RotatingFileSink`].
 ///
-/// Rotation policy defines when and how to split log messages into log files,
+/// Rotation policy defines when and how to split logs into multiple files,
 /// during which new log files may be created and old log files may be deleted.
-/// Currently `spdlog` provides 3 different rotation policies:
 ///
-/// - Rotate by file size, which is represented by the
-///   `RotationPolicy::FileSize` variant. Under this rotation policy, the sink
-///   rotates log messages when the size of the current log file exceeds a
-///   limit. The sink will then create a new log file for further log messages
-///   and may optionally delete the oldest log files depending on the maximum
-///   number of files allowed.
-/// - Rotate daily, which is represented by the `RotationPolicy::Daily` variant.
-///   Under this rotation policy, the sink automatically creates a new log file
-///   at a specified time point within a day. The oldest log files may be
-///   deleted, depending on the maximum number of allowed log files.
-/// - Rotate hourly, which is represented by the `RotationPolicy::Hourly`
-///   variant. Under this rotation policy, the sink automatically creates a new
-///   log file at a specified time point within each hour. The oldest log files
-///   may be deleted, depending on the maximum number of allowed log files.
-///
-/// # Errors
+/// # Error
 ///
 /// Note that some parameters have range requirements, functions that receive it
 /// will return an error if the requirements are not met.
+///
+/// # Examples
+///
+/// ```
+/// use spdlog::sink::RotationPolicy;
+///
+/// // Rotating every 10 MB file.
+/// RotationPolicy::FileSize(1024 * 1024 * 10);
+///
+/// // Rotating every day at 15:30.
+/// RotationPolicy::Daily { hour: 15, minute: 30 };
+///
+/// // Rotating every hour.
+/// RotationPolicy::Hourly;
+/// ```
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 pub enum RotationPolicy {
-    /// Rotates when the log file reaches the given max file size.
+    /// Rotating to a new log file when the size of the current log file exceeds
+    /// the given limit.
     FileSize(
-        /// Max file size (in bytes). Range: (0, u64::MAX].
+        /// Maximum file size (in bytes). Range: (0, u64::MAX].
         u64,
     ),
-    /// Rotates daily at the given time point.
+    /// Rotating to a new log file at a specified time point within a day.
     Daily {
         /// Hour of the time point. Range: [0, 23].
         hour: u32,
         /// Minute of the time point. Range: [0, 59].
         minute: u32,
     },
-    /// Rotates hourly.
+    /// Rotating to a new log file at minute 0 of each hour.
     Hourly,
 }
 
@@ -109,49 +109,17 @@ struct RotatorTimePointInner {
     file_paths: Option<LinkedList<PathBuf>>,
 }
 
-/// A sink with a collection of files as the target, rotating according to the
-/// rotation policy.
+/// A sink with a file as the target, split files according to the rotation
+/// policy.
 ///
-/// A service program that runs for a long time in an environment with limited
-/// hard disk space may continue to write messages to the log file and
-/// eventually run out of hard disk space. `RotatingFileSink` is designed for
-/// such a usage scenario. It splits log messages into one or more log files
-/// and may be configured to delete old log files automatically to save disk
-/// space. The operation that splits log messages into multiple log files and
-/// optionally creates and deletes log files is called a **rotation**. The
+/// A service program running for a long time may continuously write logs to a
+/// single file, which makes the logs hard to view and manage.
+/// `RotatingFileSink` is designed for this usage scenario. It automatically
+/// splits logs into one or more files and can be configured to automatically
+/// delete old files to save disk space. The operation of splitting logs into
+/// multiple files and optionally deleting old files is called **rotation**. The
 /// **rotation policy** determines when and how log files are created or
-/// deleted, and how log messages are written to different log files.
-///
-/// # Parameters
-///
-/// A rotating file sink can be created with 3 parameters: the **base path**,
-/// the **maximum number of log files**, and the **rotation policy**.
-///
-/// ## The Base Path
-///
-/// Each rotating file sink requires a **base path** which serves as a template
-/// to form log file paths. You can set the base path with
-/// [`RotatingFileSinkBuilder::base_path`] when building a rotating file sink.
-/// Different rotation policy may use different file name patterns based on the
-/// base path. For more information about the base path, see the documentation
-/// of [`RotatingFileSinkBuilder::base_path`].
-///
-/// # Maximum Number of Log Files
-///
-/// This parameter defines the maximum number of log files allowed on the disk.
-/// You can set this parameter with [`RotatingFileSinkBuilder::max_files`] when
-/// building a rotating file sink. During a rotation, the sink won't delete old
-/// log files unless the number of log files on the disk exceeds this
-/// limit. Furthermore, setting this parameter to 0 indicates that no limits are
-/// applied and effectively prevents the sink from deleting any old log files.
-///
-/// # Rotation Policy
-///
-/// [`RotationPolicy`] defines the different available rotation policies. You
-/// can set the rotation policy with
-/// [`RotatingFileSinkBuilder::rotation_policy`] when building a rotating file
-/// sink. For more information about different rotation policies, please refer
-/// to the documentation of [`RotationPolicy`].
+/// deleted.
 ///
 /// # Examples
 ///
@@ -163,53 +131,8 @@ pub struct RotatingFileSink {
     rotator: RotatorKind,
 }
 
-/// The builder of [`RotatingFileSink`].
+/// #
 #[doc = include_str!("../include/doc/generic-builder-note.md")]
-/// # Examples
-///
-/// - Building a [`RotatingFileSink`].
-///
-///   ```no_run
-///   use spdlog::sink::{RotatingFileSink, RotationPolicy};
-///
-///   # fn main() -> Result<(), spdlog::Error> {
-///   let sink: RotatingFileSink = RotatingFileSink::builder()
-///       .base_path("/path/to/base_log_file") // required
-///       .rotation_policy(RotationPolicy::Hourly) // required
-///       // .max_files(100) // optional, defaults to `0` for no limit
-///       // .rotate_on_open(true) // optional, defaults to `false`
-///       .build()?;
-///   # Ok(()) }
-///   ```
-///
-/// - If any required parameters are missing, a compile-time error will be
-///   raised.
-///
-///   ```compile_fail,E0061
-///   use spdlog::sink::{RotatingFileSink, RotationPolicy};
-///
-///   # fn main() -> Result<(), spdlog::Error> {
-///   let sink: RotatingFileSink = RotatingFileSink::builder()
-///       // .base_path("/path/to/base_log_file") // required
-///       .rotation_policy(RotationPolicy::Hourly) // required
-///       .max_files(100) // optional, defaults to `0` for no limit
-///       .rotate_on_open(true) // optional, defaults to `false`
-///       .build()?;
-///   # Ok(()) }
-///   ```
-///
-///   ```compile_fail,E0061
-///   use spdlog::sink::{RotatingFileSink, RotationPolicy};
-///
-///   # fn main() -> Result<(), spdlog::Error> {
-///   let sink: RotatingFileSink = RotatingFileSink::builder()
-///       .base_path("/path/to/base_log_file") // required
-///       // .rotation_policy(RotationPolicy::Hourly) // required
-///       .max_files(100) // optional, defaults to `0` for no limit
-///       .rotate_on_open(true) // optional, defaults to `false`
-///       .build()?;
-///   # Ok(()) }
-///   ```
 pub struct RotatingFileSinkBuilder<ArgBP, ArgRP> {
     common_builder_impl: helper::CommonBuilderImpl,
     base_path: ArgBP,
@@ -219,7 +142,27 @@ pub struct RotatingFileSinkBuilder<ArgBP, ArgRP> {
 }
 
 impl RotatingFileSink {
-    /// Constructs a builder of `RotatingFileSink`.
+    /// Gets a builder of `RotatingFileSink` with default parameters:
+    ///
+    /// | Parameter         | Default Value           |
+    /// |-------------------|-------------------------|
+    /// | [level_filter]    | `All`                   |
+    /// | [formatter]       | `FullFormatter`         |
+    /// | [error_handler]   | [default error handler] |
+    /// |                   |                         |
+    /// | [base_path]       | *must be specified*     |
+    /// | [rotation_policy] | *must be specified*     |
+    /// | [max_files]       | `0`                     |
+    /// | [rotate_on_open]  | `false`                 |
+    ///
+    /// [level_filter]: RotatingFileSinkBuilder::level_filter
+    /// [formatter]: RotatingFileSinkBuilder::formatter
+    /// [error_handler]: RotatingFileSinkBuilder::error_handler
+    /// [default error handler]: error/index.html#default-error-handler
+    /// [base_path]: RotatingFileSinkBuilder::base_path
+    /// [rotation_policy]: RotatingFileSinkBuilder::rotation_policy
+    /// [max_files]: RotatingFileSinkBuilder::max_files
+    /// [rotate_on_open]: RotatingFileSinkBuilder::rotate_on_open
     #[must_use]
     pub fn builder() -> RotatingFileSinkBuilder<(), ()> {
         RotatingFileSinkBuilder {
@@ -243,7 +186,7 @@ impl RotatingFileSink {
     /// contents of the existing file if the parameter is `true`, since the file
     /// name is a time point and not an index.
     ///
-    /// # Errors
+    /// # Error
     ///
     /// If an error occurs opening the file, [`Error::CreateDirectory`] or
     /// [`Error::OpenFile`] will be returned.
@@ -770,9 +713,9 @@ impl<ArgBP, ArgRP> RotatingFileSinkBuilder<ArgBP, ArgRP> {
     /// If the number of existing files reaches this parameter, the oldest file
     /// will be deleted on the next rotation.
     ///
-    /// Pass `0` for no limit.
+    /// Specify `0` for no limit.
     ///
-    /// This parameter is **optional**, and defaults to `0`.
+    /// This parameter is **optional**.
     #[must_use]
     pub fn max_files(mut self, max_files: usize) -> Self {
         self.max_files = max_files;
@@ -787,7 +730,7 @@ impl<ArgBP, ArgRP> RotatingFileSinkBuilder<ArgBP, ArgRP> {
     /// the parameter is `true`, since the file name is a time point and not an
     /// index.
     ///
-    /// This parameter is **optional**, and defaults to `false`.
+    /// This parameter is **optional**.
     #[must_use]
     pub fn rotate_on_open(mut self, rotate_on_open: bool) -> Self {
         self.rotate_on_open = rotate_on_open;
@@ -818,7 +761,7 @@ impl RotatingFileSinkBuilder<PathBuf, ()> {
 impl RotatingFileSinkBuilder<PathBuf, RotationPolicy> {
     /// Builds a [`RotatingFileSink`].
     ///
-    /// # Errors
+    /// # Error
     ///
     /// If the argument `rotation_policy` is invalid, or an error occurs opening
     /// the file, [`Error::CreateDirectory`] or [`Error::OpenFile`] will be
diff --git a/spdlog/src/sink/std_stream_sink.rs b/spdlog/src/sink/std_stream_sink.rs
index 68ea0f9..18123dd 100644
--- a/spdlog/src/sink/std_stream_sink.rs
+++ b/spdlog/src/sink/std_stream_sink.rs
@@ -80,7 +80,8 @@ impl_write_for_dest!(StdStreamDest<io::StdoutLock<'_>, io::StderrLock<'_>>);
 
 /// A sink with a std stream as the target.
 ///
-/// It writes styled text or plain text according to the given [`StyleMode`].
+/// It writes styled text or plain text according to the given [`StyleMode`] and
+/// the current terminal environment.
 ///
 /// Note that this sink always flushes the buffer once with each logging.
 pub struct StdStreamSink {
@@ -91,7 +92,23 @@ pub struct StdStreamSink {
 }
 
 impl StdStreamSink {
-    /// Constructs a builder of `StdStreamSink`.
+    /// Gets a builder of `StdStreamSink` with default parameters:
+    ///
+    /// | Parameter         | Default Value           |
+    /// |-------------------|-------------------------|
+    /// | [level_filter]    | `All`                   |
+    /// | [formatter]       | `FullFormatter`         |
+    /// | [error_handler]   | [default error handler] |
+    /// |                   |                         |
+    /// | [std_stream]      | *must be specified*     |
+    /// | [style_mode]      | `Auto`                  |
+    ///
+    /// [level_filter]: StdStreamSinkBuilder::level_filter
+    /// [formatter]: StdStreamSinkBuilder::formatter
+    /// [error_handler]: StdStreamSinkBuilder::error_handler
+    /// [default error handler]: error/index.html#default-error-handler
+    /// [std_stream]: StdStreamSinkBuilder::std_stream
+    /// [style_mode]: StdStreamSinkBuilder::style_mode
     #[must_use]
     pub fn builder() -> StdStreamSinkBuilder<()> {
         StdStreamSinkBuilder {
@@ -190,44 +207,8 @@ impl Sink for StdStreamSink {
 
 // --------------------------------------------------
 
-/// The builder of [`StdStreamSink`].
+/// #
 #[doc = include_str!("../include/doc/generic-builder-note.md")]
-/// # Examples
-///
-/// - Building a [`StdStreamSink`].
-///
-///   ```
-///   use spdlog::{
-///       sink::{StdStreamSink, StdStream},
-///       terminal_style::StyleMode
-///   };
-///
-///   # fn main() -> Result<(), spdlog::Error> {
-///   let sink: StdStreamSink = StdStreamSink::builder()
-///       .std_stream(StdStream::Stdout) // required
-///       /* .style_mode(StyleMode::Never) // optional, defaults to
-///                                        // `StyleMode::Auto` */
-///       .build()?;
-///   # Ok(()) }
-///   ```
-///
-/// - If any required parameters are missing, a compile-time error will be
-///   raised.
-///
-///   ```compile_fail,E0061
-///   use spdlog::{
-///       sink::{StdStreamSink, StdStream},
-///       terminal_style::StyleMode
-///   };
-///
-///   # fn main() -> Result<(), spdlog::Error> {
-///   let sink: StdStreamSink = StdStreamSink::builder()
-///       // .std_stream(StdStream::Stdout) // required
-///       .style_mode(StyleMode::Never) /* optional, defaults to
-///                                      * `StyleMode::Auto` */
-///       .build()?;
-///   # Ok(()) }
-///   ```
 pub struct StdStreamSinkBuilder<ArgSS> {
     common_builder_impl: helper::CommonBuilderImpl,
     std_stream: ArgSS,
@@ -249,7 +230,7 @@ impl<ArgSS> StdStreamSinkBuilder<ArgSS> {
 
     /// Specifies the style mode.
     ///
-    /// This parameter is **optional**, and defaults to [`StyleMode::Auto`].
+    /// This parameter is **optional**.
     #[must_use]
     pub fn style_mode(mut self, style_mode: StyleMode) -> Self {
         self.style_mode = style_mode;
diff --git a/spdlog/src/sink/win_debug_sink.rs b/spdlog/src/sink/win_debug_sink.rs
index 2d3adab..70e22b9 100644
--- a/spdlog/src/sink/win_debug_sink.rs
+++ b/spdlog/src/sink/win_debug_sink.rs
@@ -11,7 +11,18 @@ pub struct WinDebugSink {
 }
 
 impl WinDebugSink {
-    /// Constructs a builder of `WinDebugSink`.
+    /// Gets a builder of `WinDebugSink` with default parameters:
+    ///
+    /// | Parameter       | Default Value           |
+    /// |-----------------|-------------------------|
+    /// | [level_filter]  | `All`                   |
+    /// | [formatter]     | `FullFormatter`         |
+    /// | [error_handler] | [default error handler] |
+    ///
+    /// [level_filter]: WinDebugSinkBuilder::level_filter
+    /// [formatter]: WinDebugSinkBuilder::formatter
+    /// [error_handler]: WinDebugSinkBuilder::error_handler
+    /// [default error handler]: error/index.html#default-error-handler
     #[must_use]
     pub fn builder() -> WinDebugSinkBuilder {
         WinDebugSinkBuilder {
@@ -60,21 +71,7 @@ impl Sink for WinDebugSink {
     helper::common_impl!(@Sink: common_impl);
 }
 
-/// The builder of [`WinDebugSink`].
-///
-/// # Examples
-///
-/// - Building a [`WinDebugSink`].
-///
-///   ```
-///   use spdlog::{prelude::*, sink::WinDebugSink};
-///  
-///   # fn main() -> Result<(), spdlog::Error> {
-///   let sink: WinDebugSink = WinDebugSink::builder()
-///       .level_filter(LevelFilter::MoreSevere(Level::Info)) // optional
-///       .build()?;
-///   # Ok(()) }
-///   ```
+#[allow(missing_docs)]
 pub struct WinDebugSinkBuilder {
     common_builder_impl: helper::CommonBuilderImpl,
 }
diff --git a/spdlog/src/sink/write_sink.rs b/spdlog/src/sink/write_sink.rs
index f149231..6966158 100644
--- a/spdlog/src/sink/write_sink.rs
+++ b/spdlog/src/sink/write_sink.rs
@@ -36,7 +36,21 @@ impl<W> WriteSink<W>
 where
     W: Write + Send,
 {
-    /// Constructs a builder of `WriteSink`.
+    /// Gets a builder of `WriteSink` with default parameters:
+    ///
+    /// | Parameter         | Default Value           |
+    /// |-------------------|-------------------------|
+    /// | [level_filter]    | `All`                   |
+    /// | [formatter]       | `FullFormatter`         |
+    /// | [error_handler]   | [default error handler] |
+    /// |                   |                         |
+    /// | [target]          | *must be specified*     |
+    ///
+    /// [level_filter]: WriteSinkBuilder::level_filter
+    /// [formatter]: WriteSinkBuilder::formatter
+    /// [error_handler]: WriteSinkBuilder::error_handler
+    /// [default error handler]: error/index.html#default-error-handler
+    /// [target]: WriteSinkBuilder::target
     #[must_use]
     pub fn builder() -> WriteSinkBuilder<W, ()> {
         WriteSinkBuilder {
@@ -117,37 +131,8 @@ where
     }
 }
 
-/// The builder of [`WriteSink`].
+/// #
 #[doc = include_str!("../include/doc/generic-builder-note.md")]
-/// # Examples
-///
-/// - Building a [`WriteSink`].
-///
-///   ```
-///   use spdlog::{prelude::*, sink::WriteSink};
-///  
-///   # fn main() -> Result<(), spdlog::Error> {
-///   # let target = Vec::new();
-///   let sink: WriteSink<_> = WriteSink::builder()
-///       .target(target) // required
-///       // .level_filter(LevelFilter::MoreSevere(Level::Info)) // optional
-///       .build()?;
-///   # Ok(()) }
-///   ```
-///
-/// - If any required parameters are missing, a compile-time error will be
-///   raised.
-///
-///   ```compile_fail,E0061
-///   use spdlog::{prelude::*, sink::WriteSink};
-///  
-///   # fn main() -> Result<(), spdlog::Error> {
-///   let sink: WriteSink<_> = WriteSink::builder()
-///       // .target(target) // required
-///       .level_filter(LevelFilter::MoreSevere(Level::Info)) // optional
-///       .build()?;
-///   # Ok(()) }
-///   ```
 pub struct WriteSinkBuilder<W, ArgW> {
     common_builder_impl: helper::CommonBuilderImpl,
     target: Option<W>,
diff --git a/spdlog/src/source_location.rs b/spdlog/src/source_location.rs
index ad47fcf..fcead47 100644
--- a/spdlog/src/source_location.rs
+++ b/spdlog/src/source_location.rs
@@ -1,5 +1,3 @@
-//! Provides stuff related to source location.
-
 use std::path;
 
 /// Represents a location in source code.
@@ -91,7 +89,8 @@ impl SourceLocation {
 
 /// Constructs a [`SourceLocation`] with current source location.
 ///
-/// Returns `None` if the feature `source-location` is not enabled.
+/// The return type of this macro is `Option<SourceLocation>`. Returns `None` if
+/// the feature `source-location` is not enabled.
 ///
 /// # Examples
 ///
diff --git a/spdlog/src/string_buf.rs b/spdlog/src/string_buf.rs
index 422f08c..89ae0b2 100644
--- a/spdlog/src/string_buf.rs
+++ b/spdlog/src/string_buf.rs
@@ -1,5 +1,3 @@
-//! Provides a string buffer type for sinks and formatters.
-
 /// A string buffer type.
 ///
 /// Used at [`Formatter`].
@@ -12,7 +10,7 @@
 /// consistent as possible with [`String`], but some APIs are not yet
 /// implemented or cannot be implemented.
 ///
-/// # Warnings
+/// # Warning
 ///
 /// `FlexibleString` can improve performance as it avoids memory allocation when
 /// formatting records as much as possible, however it contains unsafe code.
diff --git a/spdlog/src/terminal_style.rs b/spdlog/src/terminal_style.rs
index 767e88e..59f2cec 100644
--- a/spdlog/src/terminal_style.rs
+++ b/spdlog/src/terminal_style.rs
@@ -6,7 +6,7 @@
 
 use crate::Level;
 
-/// The terminal text color style.
+/// Text color for terminal rendering.
 #[allow(missing_docs)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 pub enum Color {
@@ -52,9 +52,7 @@ impl Color {
     }
 }
 
-/// The terminal text style structure.
-///
-/// You can construct it easily with [`StyleBuilder`].
+/// Expresses how to render a piece of text in the terminal.
 #[derive(Clone, Eq, PartialEq, Hash, Debug)]
 pub struct Style {
     color: Option<Color>,
@@ -83,7 +81,7 @@ impl Style {
         Style::builder().build()
     }
 
-    /// Constructs a [`StyleBuilder`].
+    /// Gets a [`StyleBuilder`].
     #[must_use]
     pub fn builder() -> StyleBuilder {
         StyleBuilder {
@@ -157,7 +155,7 @@ impl Style {
     }
 }
 
-/// The builder of [`Style`].
+#[allow(missing_docs)]
 #[derive(Clone, Eq, PartialEq, Hash, Debug)]
 pub struct StyleBuilder {
     style: Style,
@@ -221,7 +219,7 @@ impl StyleBuilder {
     }
 }
 
-/// Represents style enable mode.
+/// Represents terminal style enabling mode.
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 pub enum StyleMode {
     /// Always output style escape codes.
diff --git a/spdlog/src/thread_pool.rs b/spdlog/src/thread_pool.rs
index 9772af6..2ca2b39 100644
--- a/spdlog/src/thread_pool.rs
+++ b/spdlog/src/thread_pool.rs
@@ -22,8 +22,8 @@ use crate::{
 ///
 /// # fn main() -> Result<(), spdlog::Error> {
 /// # let underlying_sink = spdlog::default_logger().sinks().first().unwrap().clone();
-/// let thread_pool: Arc<ThreadPool> = Arc::new(ThreadPool::new()?);
-/// let async_pool_sink: AsyncPoolSink = AsyncPoolSink::builder()
+/// let thread_pool = Arc::new(ThreadPool::new()?);
+/// let async_pool_sink = AsyncPoolSink::builder()
 ///     .sink(underlying_sink)
 ///     .thread_pool(thread_pool)
 ///     .build()?;
@@ -40,7 +40,7 @@ struct ThreadPoolInner {
 
 type Callback = Arc<dyn Fn() + Send + Sync + 'static>;
 
-/// The builder of [`ThreadPool`].
+#[allow(missing_docs)]
 pub struct ThreadPoolBuilder {
     capacity: usize,
     threads: usize,
@@ -53,7 +53,17 @@ struct Worker {
 }
 
 impl ThreadPool {
-    /// Constructs a builder of `ThreadPool`.
+    /// Gets a builder of `ThreadPool` with default parameters:
+    ///
+    /// | Parameter          | Default Value                     |
+    /// |--------------------|-----------------------------------|
+    /// | [capacity]         | `8192` (may change in the future) |
+    /// | [on_thread_spawn]  | `None`                            |
+    /// | [on_thread_finish] | `None`                            |
+    ///
+    /// [capacity]: ThreadPoolBuilder::capacity
+    /// [on_thread_spawn]: ThreadPoolBuilder::on_thread_spawn
+    /// [on_thread_finish]: ThreadPoolBuilder::on_thread_finish
     #[must_use]
     pub fn builder() -> ThreadPoolBuilder {
         ThreadPoolBuilder {
@@ -64,7 +74,8 @@ impl ThreadPool {
         }
     }
 
-    /// Constructs a `ThreadPool` with default parameters.
+    /// Constructs a `ThreadPool` with default parameters (see documentation of
+    /// [`ThreadPool::builder`]).
     pub fn new() -> Result<Self> {
         Self::builder().build()
     }
@@ -108,8 +119,7 @@ impl Drop for ThreadPool {
 impl ThreadPoolBuilder {
     /// Specifies the capacity of the operation channel.
     ///
-    /// This parameter is **optional**, and defaults to 8192 (The value may
-    /// change in the future).
+    /// This parameter is **optional**.
     ///
     /// When a new operation is incoming, but the channel is full, it will be
     /// handled by sink according to the [`OverflowPolicy`] that has been set.