wasmtime 12.0.1 → 13.0.0

data/ext/cargo-vendor/env_logger-0.10.0/README.md

@@ -1,183 +0,0 @@
-# env_logger
-
-[![crates.io](https://img.shields.io/crates/v/env_logger.svg)](https://crates.io/crates/env_logger)
-[![Documentation](https://docs.rs/env_logger/badge.svg)](https://docs.rs/env_logger)
-[![Documentation](https://img.shields.io/badge/docs-main-blue.svg)](https://env-logger-rs.github.io/env_logger/env_logger/index.html)
-
-Implements a logger that can be configured via environment variables.
-
-## Usage
-
-### In libraries
-
-`env_logger` makes sense when used in executables (binary projects). Libraries should use the [`log`](https://docs.rs/log) crate instead.
-
-### In executables
-
-It must be added along with `log` to the project dependencies:
-
-```toml
-[dependencies]
-log = "0.4.0"
-env_logger = "0.9.0"
-```
-
-`env_logger` must be initialized as early as possible in the project. After it's initialized, you can use the `log` macros to do actual logging.
-
-```rust
-#[macro_use]
-extern crate log;
-
-fn main() {
-    env_logger::init();
-
-    info!("starting up");
-
-    // ...
-}
-```
-
-Then when running the executable, specify a value for the **`RUST_LOG`**
-environment variable that corresponds with the log messages you want to show.
-
-```bash
-$ RUST_LOG=info ./main
-[2018-11-03T06:09:06Z INFO  default] starting up
-```
-
-The letter case is not significant for the logging level names; e.g., `debug`,
-`DEBUG`, and `dEbuG` all represent the same logging level. Therefore, the
-previous example could also have been written this way, specifying the log
-level as `INFO` rather than as `info`:
-
-```bash
-$ RUST_LOG=INFO ./main
-[2018-11-03T06:09:06Z INFO  default] starting up
-```
-
-So which form should you use? For consistency, our convention is to use lower
-case names. Where our docs do use other forms, they do so in the context of
-specific examples, so you won't be surprised if you see similar usage in the
-wild.
-
-The log levels that may be specified correspond to the [`log::Level`][level-enum]
-enum from the `log` crate. They are:
-
-   * `error`
-   * `warn`
-   * `info`
-   * `debug`
-   * `trace`
-
-[level-enum]:  https://docs.rs/log/latest/log/enum.Level.html  "log::Level (docs.rs)"
-
-There is also a pseudo logging level, `off`, which may be specified to disable
-all logging for a given module or for the entire application. As with the
-logging levels, the letter case is not significant.
-
-`env_logger` can be configured in other ways besides an environment variable. See [the examples](https://github.com/env-logger-rs/env_logger/tree/main/examples) for more approaches.
-
-### In tests
-
-Tests can use the `env_logger` crate to see log messages generated during that test:
-
-```toml
-[dependencies]
-log = "0.4.0"
-
-[dev-dependencies]
-env_logger = "0.9.0"
-```
-
-```rust
-#[macro_use]
-extern crate log;
-
-fn add_one(num: i32) -> i32 {
-    info!("add_one called with {}", num);
-    num + 1
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn init() {
-        let _ = env_logger::builder().is_test(true).try_init();
-    }
-
-    #[test]
-    fn it_adds_one() {
-        init();
-
-        info!("can log from the test too");
-        assert_eq!(3, add_one(2));
-    }
-
-    #[test]
-    fn it_handles_negative_numbers() {
-        init();
-
-        info!("logging from another test");
-        assert_eq!(-7, add_one(-8));
-    }
-}
-```
-
-Assuming the module under test is called `my_lib`, running the tests with the
-`RUST_LOG` filtering to info messages from this module looks like:
-
-```bash
-$ RUST_LOG=my_lib=info cargo test
-     Running target/debug/my_lib-...
-
-running 2 tests
-[INFO my_lib::tests] logging from another test
-[INFO my_lib] add_one called with -8
-test tests::it_handles_negative_numbers ... ok
-[INFO my_lib::tests] can log from the test too
-[INFO my_lib] add_one called with 2
-test tests::it_adds_one ... ok
-
-test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured
-```
-
-Note that `env_logger::try_init()` needs to be called in each test in which you
-want to enable logging. Additionally, the default behavior of tests to
-run in parallel means that logging output may be interleaved with test output.
-Either run tests in a single thread by specifying `RUST_TEST_THREADS=1` or by
-running one test by specifying its name as an argument to the test binaries as
-directed by the `cargo test` help docs:
-
-```bash
-$ RUST_LOG=my_lib=info cargo test it_adds_one
-     Running target/debug/my_lib-...
-
-running 1 test
-[INFO my_lib::tests] can log from the test too
-[INFO my_lib] add_one called with 2
-test tests::it_adds_one ... ok
-
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
-```
-
-## Configuring log target
-
-By default, `env_logger` logs to stderr. If you want to log to stdout instead,
-you can use the `Builder` to change the log target:
-
-```rust
-use std::env;
-use env_logger::{Builder, Target};
-
-let mut builder = Builder::from_default_env();
-builder.target(Target::Stdout);
-
-builder.init();
-```
-
-## Stability of the default format
-
-The default format won't optimise for long-term stability, and explicitly makes no guarantees about the stability of its output across major, minor or patch version bumps during `0.x`.
-
-If you want to capture or interpret the output of `env_logger` programmatically then you should use a custom format.

data/ext/cargo-vendor/env_logger-0.10.0/examples/custom_default_format.rs

@@ -1,40 +0,0 @@
-/*!
-Disabling parts of the default format.
-
-Before running this example, try setting the `MY_LOG_LEVEL` environment variable to `info`:
-
-```no_run,shell
-$ export MY_LOG_LEVEL='info'
-```
-
-Also try setting the `MY_LOG_STYLE` environment variable to `never` to disable colors
-or `auto` to enable them:
-
-```no_run,shell
-$ export MY_LOG_STYLE=never
-```
-
-If you want to control the logging output completely, see the `custom_logger` example.
-*/
-
-#[macro_use]
-extern crate log;
-
-use env_logger::{Builder, Env};
-
-fn init_logger() {
-    let env = Env::default()
-        .filter("MY_LOG_LEVEL")
-        .write_style("MY_LOG_STYLE");
-
-    Builder::from_env(env)
-        .format_level(false)
-        .format_timestamp_nanos()
-        .init();
-}
-
-fn main() {
-    init_logger();
-
-    info!("a log from `MyLogger`");
-}

data/ext/cargo-vendor/env_logger-0.10.0/examples/custom_format.rs

@@ -1,54 +0,0 @@
-/*!
-Changing the default logging format.
-
-Before running this example, try setting the `MY_LOG_LEVEL` environment variable to `info`:
-
-```no_run,shell
-$ export MY_LOG_LEVEL='info'
-```
-
-Also try setting the `MY_LOG_STYLE` environment variable to `never` to disable colors
-or `auto` to enable them:
-
-```no_run,shell
-$ export MY_LOG_STYLE=never
-```
-
-If you want to control the logging output completely, see the `custom_logger` example.
-*/
-
-#[cfg(all(feature = "color", feature = "humantime"))]
-fn main() {
-    use env_logger::{fmt::Color, Builder, Env};
-
-    use std::io::Write;
-
-    fn init_logger() {
-        let env = Env::default()
-            .filter("MY_LOG_LEVEL")
-            .write_style("MY_LOG_STYLE");
-
-        Builder::from_env(env)
-            .format(|buf, record| {
-                let mut style = buf.style();
-                style.set_bg(Color::Yellow).set_bold(true);
-
-                let timestamp = buf.timestamp();
-
-                writeln!(
-                    buf,
-                    "My formatted log ({}): {}",
-                    timestamp,
-                    style.value(record.args())
-                )
-            })
-            .init();
-    }
-
-    init_logger();
-
-    log::info!("a log from `MyLogger`");
-}
-
-#[cfg(not(all(feature = "color", feature = "humantime")))]
-fn main() {}

data/ext/cargo-vendor/env_logger-0.10.0/examples/custom_logger.rs

@@ -1,62 +0,0 @@
-/*!
-Using `env_logger` to drive a custom logger.
-
-Before running this example, try setting the `MY_LOG_LEVEL` environment variable to `info`:
-
-```no_run,shell
-$ export MY_LOG_LEVEL='info'
-```
-
-If you only want to change the way logs are formatted, look at the `custom_format` example.
-*/
-
-#[macro_use]
-extern crate log;
-
-use env_logger::filter::{Builder, Filter};
-
-use log::{Log, Metadata, Record, SetLoggerError};
-
-const FILTER_ENV: &str = "MY_LOG_LEVEL";
-
-struct MyLogger {
-    inner: Filter,
-}
-
-impl MyLogger {
-    fn new() -> MyLogger {
-        let mut builder = Builder::from_env(FILTER_ENV);
-
-        MyLogger {
-            inner: builder.build(),
-        }
-    }
-
-    fn init() -> Result<(), SetLoggerError> {
-        let logger = Self::new();
-
-        log::set_max_level(logger.inner.filter());
-        log::set_boxed_logger(Box::new(logger))
-    }
-}
-
-impl Log for MyLogger {
-    fn enabled(&self, metadata: &Metadata) -> bool {
-        self.inner.enabled(metadata)
-    }
-
-    fn log(&self, record: &Record) {
-        // Check if the record is matched by the logger before logging
-        if self.inner.matches(record) {
-            println!("{} - {}", record.level(), record.args());
-        }
-    }
-
-    fn flush(&self) {}
-}
-
-fn main() {
-    MyLogger::init().unwrap();
-
-    info!("a log from `MyLogger`");
-}

data/ext/cargo-vendor/env_logger-0.10.0/examples/default.rs

@@ -1,38 +0,0 @@
-/*!
-Using `env_logger`.
-
-Before running this example, try setting the `MY_LOG_LEVEL` environment variable to `info`:
-
-```no_run,shell
-$ export MY_LOG_LEVEL='info'
-```
-
-Also try setting the `MY_LOG_STYLE` environment variable to `never` to disable colors
-or `auto` to enable them:
-
-```no_run,shell
-$ export MY_LOG_STYLE=never
-```
-*/
-
-#[macro_use]
-extern crate log;
-
-use env_logger::Env;
-
-fn main() {
-    // The `Env` lets us tweak what the environment
-    // variables to read are and what the default
-    // value is if they're missing
-    let env = Env::default()
-        .filter_or("MY_LOG_LEVEL", "trace")
-        .write_style_or("MY_LOG_STYLE", "always");
-
-    env_logger::init_from_env(env);
-
-    trace!("some trace log");
-    debug!("some debug log");
-    info!("some information log");
-    warn!("some warning log");
-    error!("some error log");
-}

data/ext/cargo-vendor/env_logger-0.10.0/examples/direct_logger.rs

@@ -1,39 +0,0 @@
-/*!
-Using `env_logger::Logger` and the `log::Log` trait directly.
-
-This example doesn't rely on environment variables, or having a static logger installed.
-*/
-
-use env_logger::{Builder, WriteStyle};
-
-use log::{Level, LevelFilter, Log, MetadataBuilder, Record};
-
-fn record() -> Record<'static> {
-    let error_metadata = MetadataBuilder::new()
-        .target("myApp")
-        .level(Level::Error)
-        .build();
-
-    Record::builder()
-        .metadata(error_metadata)
-        .args(format_args!("Error!"))
-        .line(Some(433))
-        .file(Some("app.rs"))
-        .module_path(Some("server"))
-        .build()
-}
-
-fn main() {
-    let stylish_logger = Builder::new()
-        .filter(None, LevelFilter::Error)
-        .write_style(WriteStyle::Always)
-        .build();
-
-    let unstylish_logger = Builder::new()
-        .filter(None, LevelFilter::Error)
-        .write_style(WriteStyle::Never)
-        .build();
-
-    stylish_logger.log(&record());
-    unstylish_logger.log(&record());
-}

data/ext/cargo-vendor/env_logger-0.10.0/examples/filters_from_code.rs

@@ -1,20 +0,0 @@
-/*!
-Specify logging filters in code instead of using an environment variable.
-*/
-
-#[macro_use]
-extern crate log;
-
-use env_logger::Builder;
-
-use log::LevelFilter;
-
-fn main() {
-    Builder::new().filter_level(LevelFilter::max()).init();
-
-    trace!("some trace log");
-    debug!("some debug log");
-    info!("some information log");
-    warn!("some warning log");
-    error!("some error log");
-}

data/ext/cargo-vendor/env_logger-0.10.0/examples/in_tests.rs

@@ -1,54 +0,0 @@
-/*!
-Using `env_logger` in tests.
-
-Log events will be captured by `cargo` and only printed if the test fails.
-You can run this example by calling:
-
-```text
-cargo test --example in_tests
-```
-
-You should see the `it_does_not_work` test fail and include its log output.
-*/
-
-#[cfg_attr(test, macro_use)]
-extern crate log;
-
-fn main() {}
-
-#[cfg(test)]
-mod tests {
-    fn init_logger() {
-        let _ = env_logger::builder()
-            // Include all events in tests
-            .filter_level(log::LevelFilter::max())
-            // Ensure events are captured by `cargo test`
-            .is_test(true)
-            // Ignore errors initializing the logger if tests race to configure it
-            .try_init();
-    }
-
-    #[test]
-    fn it_works() {
-        init_logger();
-
-        let a = 1;
-        let b = 2;
-
-        debug!("checking whether {} + {} = 3", a, b);
-
-        assert_eq!(3, a + b);
-    }
-
-    #[test]
-    fn it_does_not_work() {
-        init_logger();
-
-        let a = 1;
-        let b = 2;
-
-        debug!("checking whether {} + {} = 6", a, b);
-
-        assert_eq!(6, a + b);
-    }
-}

data/ext/cargo-vendor/env_logger-0.10.0/examples/syslog_friendly_format.rs

@@ -1,24 +0,0 @@
-use std::io::Write;
-
-fn main() {
-    match std::env::var("RUST_LOG_STYLE") {
-        Ok(s) if s == "SYSTEMD" => env_logger::builder()
-            .format(|buf, record| {
-                writeln!(
-                    buf,
-                    "<{}>{}: {}",
-                    match record.level() {
-                        log::Level::Error => 3,
-                        log::Level::Warn => 4,
-                        log::Level::Info => 6,
-                        log::Level::Debug => 7,
-                        log::Level::Trace => 7,
-                    },
-                    record.target(),
-                    record.args()
-                )
-            })
-            .init(),
-        _ => env_logger::init(),
-    };
-}