* Ignore commands starting with ' ' (space). This should make it
  easier to not record sensitive commands. This is configurable in a
  configuration file with the option `ignore_space`. By default this
  is enabled.
* Add configuration option `log_level` to change the default log level
  to run under.

 "toml",

 "serde",

name = "toml"
version = "0.5.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
dependencies = [
 "serde",
]
[[package]]

log = "0.4"

log = { version = "0.4", features = ["serde"] }

toml = "0.5"

## Configuration
There is also a way to configure `histdb-rs`. By default the configuration is stored under `$HOME/.config/histdb-rs/config.toml`. A different path can be specified using the `--config-path` option.
The default configuration looks like this:
```toml
# When true will not save commands that start with a space.
# Default: true
ignore_space = true
# The log level to run under.
# Default: Warn
log_level = "Warn"
```

# When true will not save commands that start with a space.
# Default: true
ignore_space = true
# The log level to run under.
# Default: Warn
log_level = "Warn"

use log::{
    debug,
    LevelFilter,
};
use std::path::Path;
use thiserror::Error;
use serde::Deserialize;
#[derive(Debug, Error)]
pub enum Error {
    #[error("can not read config file: {0}")]
    ReadFile(std::io::Error),
    #[error("can not parse config file: {0}")]
    ParseConfig(toml::de::Error),
}
#[derive(Debug, Deserialize)]
#[serde(default)]
pub struct Config {
    /// Then true disables recording commands that start with a space
    pub ignore_space: bool,
    /// The log level to run under
    pub log_level: LevelFilter,
}
impl Default for Config {
    fn default() -> Self {
        Self {
            ignore_space: true,
            log_level: LevelFilter::Warn,
        }
    }
}
impl Config {
    pub fn open(path: impl AsRef<Path>) -> Result<Self, Error> {
        if !path.as_ref().is_file() {
            debug!("no config file found using default");
            return Ok(Self::default());
        }
        let config_data = std::fs::read(path).map_err(Error::ReadFile)?;
        let config = toml::de::from_slice(&config_data).map_err(Error::ParseConfig)?;
        Ok(config)
    }
}

mod config;

    if std::env::var_os("RUST_LOG").is_none() {
        std::env::set_var("RUST_LOG", "info");
    }
    pretty_env_logger::init();

    config,

    Ok(socket_path.to_string_lossy().to_string())
}
fn default_config_path() -> Result<String, Error> {
    let project_dir = project_dir();
    let socket_path = project_dir?.config_dir().join("config.toml");

}
#[derive(StructOpt, Debug)]
struct Config {
    /// Path to the socket for communication with the server
    #[structopt(long, env = "HISTDBRS_CONFIG_PATH", default_value = into_str!(get_default_or_fail(default_config_path)))]
    config_path: PathBuf,

    #[structopt(flatten)]
    config: Config,

        let config = config::Config::open(self.default_args.config.config_path)
            .map_err(run::Error::ReadConfig)?;

        if std::env::var_os("RUST_LOG").is_none() {
            std::env::set_var("RUST_LOG", config.log_level.as_str());
        }
        pretty_env_logger::init();

                    run::zsh_add_history(o.command, o.socket_path.socket_path)

                    run::zsh_add_history(&config, o.command, o.socket_path.socket_path)

    config,

use log::debug;

    #[error("can not read configuration file: {0}")]
    ReadConfig(config::Error),

pub fn zsh_add_history(command: String, socket_path: PathBuf) -> Result<(), Error> {
    let data = CommandStart::from_env(command)?;
    client::new(socket_path).send(&Message::CommandStart(data))?;

pub fn zsh_add_history(
    config: &config::Config,
    command: String,
    socket_path: PathBuf,
) -> Result<(), Error> {
    if config.ignore_space && command.starts_with(' ') {
        debug!("not recording a command starting with a space");
    } else {
        let data = CommandStart::from_env(command)?;
        client::new(socket_path).send(&Message::CommandStart(data))?;
    }