diff --git a/src/filter.rs b/src/filter.rs
index 7446eb074..e3f40920b 100644
--- a/src/filter.rs
+++ b/src/filter.rs
@@ -2,7 +2,7 @@ use std::cell::RefCell;
 use enum_iterator::all;
 use std::collections::{HashMap};
 use std::rc::Rc;
-use log::{debug, error};
+use log::{debug, error, Level, log_enabled};
 use pest::iterators::Pair;
 use pest::Parser;
 use petgraph::algo::toposort;
@@ -129,7 +129,9 @@ impl Filter {
                 let value = provider.call(field);
                 let is_match = rewc.re.is_match(value.as_str());
                 if is_match {
-                    debug!("Match found: {:?} {} => {}={}", &rewc, &rewc.restr, &field, &value);
+                    if log_enabled!(Level::Debug) {
+                        debug!("Match found: {:?} {} => {}={}", &rewc, &rewc.restr, &field, &value);
+                    }
                     processor.process(field, &value, rewc);
                 }
                 is_match
@@ -204,7 +206,9 @@ fn get_parser_regexp(expr: Pair<Rule>, templates: &Vec<PatternTemplate>) -> Resu
         let regexp = re.unwrap();
         let captures = regexp.capture_names()
             .flatten().map(String::from).filter(|x| !x.is_empty()).collect::<Vec<String>>();
-        debug!("Created regex: {} with captures: [{}]", regstr, captures.join(", "));
+        if log_enabled!(Level::Debug) {
+            debug!("Created regex: {} with captures: [{}]", regstr, captures.join(", "));
+        }
         return Ok(RegexWithCaptures {
             restr: regstr,
             re: regexp,
@@ -430,7 +434,9 @@ pub(crate) fn prepare_templates(templates: &Vec<PatternTemplate>) -> Result<Vec<
             if graph.edges_directed(*node, petgraph::Incoming).count() > 0 {
                 let node_name = node_map.get(&node.index()).unwrap();
                 if let Some(deps) = node_deps.get(node_name) {
-                    debug!("template {}  depends on [{}]", node_name, deps.join(", "));
+                    if log_enabled!(Level::Debug) {
+                        debug!("template {}  depends on [{}]", node_name, deps.join(", "));
+                    }
                     let mut node_template = dep_value_map.get(node_name).unwrap().clone();
                     for dep_name in deps {
                         let dep_template = dep_value_map.get(dep_name).unwrap().clone();
@@ -445,6 +451,8 @@ pub(crate) fn prepare_templates(templates: &Vec<PatternTemplate>) -> Result<Vec<
             }
         }
     }
-    debug!("{:#?}", result);
+    if log_enabled!(Level::Debug) {
+        debug!("{:#?}", result);
+    }
     Ok(result)
 }
diff --git a/src/main.rs b/src/main.rs
index 1454dcaf4..5e4964701 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -78,12 +78,13 @@ fn main() {
 
     let mut cfg = config_reader::read_config(config_path.as_str(), config_file.as_str(), sources_file.as_str()).unwrap_or_else(|err| exit!("{}", err));
 
-    if args.log_level.is_none() {
-         if let Some(log_level) =  &cfg.log_level {
-             info!("Setting log level to: {}", get_log_level(log_level.as_str()));
-             log::set_max_level(get_log_level(log_level.as_str()));
-         }
-    }
+    // this does not work
+    // if args.log_level.is_none() {
+    //      if let Some(log_level) =  &cfg.log_level {
+    //          info!("Setting log level to: {}", log_level.as_str());
+    //          log::set_max_level(get_log_level(log_level.as_str()));
+    //      }
+    // }
 
     let targets = validate_targets(&args.target, &cfg.sources).unwrap_or_else(|err| exit!("{}", err));
 
diff --git a/src/model/config.rs b/src/model/config.rs
index beccda499..efefd70b7 100644
--- a/src/model/config.rs
+++ b/src/model/config.rs
@@ -569,7 +569,6 @@ pub(crate) struct Config {
     pub video: Option<VideoConfig>,
     pub schedule: Option<String>,
     pub messaging: Option<MessagingConfig>,
-    pub log_level: Option<String>,
     #[serde(skip_serializing, skip_deserializing)]
     pub _api_proxy: Arc<RwLock<Option<ApiProxyConfig>>>,
     #[serde(skip_serializing, skip_deserializing)]
diff --git a/src/processing/playlist_processor.rs b/src/processing/playlist_processor.rs
index a0d2b5fc3..3f5acac57 100644
--- a/src/processing/playlist_processor.rs
+++ b/src/processing/playlist_processor.rs
@@ -7,7 +7,7 @@ use std::sync::{Arc, Mutex};
 use std::thread;
 use actix_rt::System;
 
-use log::{debug, error, info};
+use log::{debug, error, info, Level, log_enabled};
 use unidecode::unidecode;
 
 use crate::{Config, get_errors_notify_message, model::config, valid_property};
@@ -31,14 +31,18 @@ fn filter_playlist(playlist: &mut [PlaylistGroup], target: &ConfigTarget) -> Opt
     debug!("Filtering {} groups", playlist.len());
     let mut new_playlist = Vec::new();
     playlist.iter_mut().for_each(|pg| {
-        debug!("Filtering group {} with {} items", pg.title, pg.channels.len());
+        if log_enabled!(Level::Debug) {
+            debug!("Filtering group {} with {} items", pg.title, pg.channels.len());
+        }
         let mut channels = Vec::new();
         pg.channels.iter_mut().for_each(|pli| {
             if is_valid(pli, target) {
                 channels.push(pli.clone());
             }
         });
-        debug!("Filtered group {} has now {} items", pg.title, channels.len());
+        if log_enabled!(Level::Debug) {
+            debug!("Filtered group {} has now {} items", pg.title, channels.len());
+        }
         if !channels.is_empty() {
             new_playlist.push(PlaylistGroup {
                 id: pg.id,
@@ -82,14 +86,18 @@ fn apply_affixes(fetched_playlists: &mut [FetchedPlaylist]) {
                         if apply_suffix {
                             if let Some(suffix) = &input.suffix {
                                 let value = get_affix_applied_value(&mut channel.header.borrow_mut(), suffix, false);
-                                debug!("Applying input suffix:  {}={}", &suffix.field, &value);
+                                if log_enabled!(Level::Debug) {
+                                    debug!("Applying input suffix:  {}={}", &suffix.field, &value);
+                                }
                                 channel.header.borrow_mut().set_field(&suffix.field, value.as_str());
                             }
                         }
                         if apply_prefix {
                             if let Some(prefix) = &input.prefix {
                                 let value = get_affix_applied_value(&mut channel.header.borrow_mut(), prefix, true);
-                                debug!("Applying input prefix:  {}={}", &prefix.field, &value);
+                                if log_enabled!(Level::Debug) {
+                                    debug!("Applying input prefix:  {}={}", &prefix.field, &value);
+                                }
                                 channel.header.borrow_mut().set_field(&prefix.field, value.as_str());
                             }
                         }
@@ -151,7 +159,9 @@ fn exec_rename(pli: &mut PlaylistItem, rename: &Option<Vec<config::ConfigRename>
             for r in renames {
                 let value = get_field_value(result, &r.field);
                 let cap = r.re.as_ref().unwrap().replace_all(value.as_str(), &r.new_name);
-                debug!("Renamed {}={} to {}", &r.field, value, cap);
+                if log_enabled!(Level::Debug) {
+                    debug!("Renamed {}={} to {}", &r.field, value, cap);
+                }
                 let value = cap.into_owned();
                 set_field_value(result, &r.field, Rc::new(value));
             }
@@ -169,7 +179,9 @@ fn rename_playlist(playlist: &mut [PlaylistGroup], target: &ConfigTarget) -> Opt
                     for r in renames {
                         if let ItemField::Group = r.field {
                             let cap = r.re.as_ref().unwrap().replace_all(&grp.title, &r.new_name);
-                            debug!("Renamed group {} to {} for {}", &grp.title, cap, target.name);
+                            if log_enabled!(Level::Debug) {
+                                debug!("Renamed group {} to {} for {}", &grp.title, cap, target.name);
+                            }
                             grp.title = Rc::new(cap.into_owned());
                         }
                     }
@@ -197,7 +209,7 @@ fn map_channel(channel: PlaylistItem, mapping: &Mapping) -> PlaylistItem {
     if !mapping.mapper.is_empty() {
         let header = channel.header.borrow();
         let channel_name = if mapping.match_as_ascii { Rc::new(unidecode(&header.name)) } else { header.name.clone() };
-        if mapping.match_as_ascii { debug!("Decoded {} for matching to {}", &header.name, &channel_name); };
+        if mapping.match_as_ascii && log_enabled!(Level::Debug) { debug!("Decoded {} for matching to {}", &header.name, &channel_name); };
         drop(header);
         let ref_chan = RefCell::new(&channel);
         let provider = ValueProvider { pli: ref_chan.clone() };
@@ -327,10 +339,14 @@ async fn process_source(cfg: Arc<Config>, source_idx: usize, user_targets: Arc<P
         }
     }
     if all_playlist.is_empty() {
-        debug!("Source at {} input is empty", source_idx);
+        if log_enabled!(Level::Debug) {
+            debug!("Source at {} input is empty", source_idx);
+        }
         errors.push(M3uFilterError::new(M3uFilterErrorKind::Notify, format!("Source at {} input is empty", source_idx)));
     } else {
-        debug!("Input has {} groups", all_playlist.len());
+        if log_enabled!(Level::Debug) {
+            debug!("Input has {} groups", all_playlist.len());
+        }
         for target in &source.targets {
             if is_target_enabled(target, &user_targets) {
                 match process_playlist(&mut all_playlist, target, &cfg, &mut stats, &mut errors).await {
@@ -347,7 +363,7 @@ pub(crate) async fn process_sources(config: Arc<Config>, user_targets: Arc<Proce
     let mut handle_list = vec![];
     let thread_num = config.threads;
     let process_parallel = thread_num > 1 && config.sources.len() > 1;
-    if process_parallel {
+    if process_parallel && log_enabled!(Level::Debug) {
         debug!("Using {} threads", thread_num);
     }
     let errors = Arc::new(Mutex::<Vec<M3uFilterError>>::new(vec![]));
@@ -405,8 +421,9 @@ pub(crate) async fn process_playlist<'a>(playlists: &mut [FetchedPlaylist<'a>],
                                          stats: &mut HashMap<u16, InputStats>,
                                          errors: &mut Vec<M3uFilterError>) -> Result<(), Vec<M3uFilterError>> {
     let pipe = get_processing_pipe(target);
-
-    debug!("Processing order is {}", &target.processing_order);
+    if log_enabled!(Level::Debug) {
+        debug!("Processing order is {}", &target.processing_order);
+    }
 
     let mut new_fetched_playlists: Vec<FetchedPlaylist> = vec![];
     for fpl in playlists.iter_mut() {
@@ -469,14 +486,16 @@ pub(crate) async fn process_playlist<'a>(playlists: &mut [FetchedPlaylist<'a>],
         if let Some(tv_guide) = fp.epg {
             tv_guides.push(tv_guide);
             let guide = tv_guides.last().unwrap();
-            debug!("found epg information for {}", &target.name);
+            if log_enabled!(Level::Debug) {
+                debug!("found epg information for {}", &target.name);
+            }
             let channel_ids: HashSet<_> = new_playlist.iter().flat_map(|g| &g.channels)
                 .filter_map(|c| c.header.borrow().epg_channel_id.clone()).collect();
             if !channel_ids.is_empty() {
                 if let Some(epg) = guide.filter(&channel_ids) {
                     new_epg.push(epg);
                 }
-            } else {
+            } else if log_enabled!(Level::Debug) {
                 debug!("channel ids are empty");
             }
         }
diff --git a/src/repository/epg_repository.rs b/src/repository/epg_repository.rs
index 151c5841f..d726cd095 100644
--- a/src/repository/epg_repository.rs
+++ b/src/repository/epg_repository.rs
@@ -1,7 +1,7 @@
 use std::fs::File;
 use std::io::{Cursor, Write};
 use std::path::{Path};
-use log::debug;
+use log::{debug, log_enabled, Level};
 use quick_xml::{Writer};
 use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
 use crate::model::config::{Config, ConfigTarget, TargetOutput};
@@ -24,7 +24,9 @@ fn write_epg_file(target: &ConfigTarget, epg: &Epg, path: &Path) -> Result<(), M
                     }
                     match epg_file.write_all(&result) {
                         Ok(_) => {
-                            debug!("Epg for target {} written to {}", target.name, path.to_str().unwrap_or("?"))
+                            if log_enabled!(Level::Debug) {
+                                debug!("Epg for target {} written to {}", target.name, path.to_str().unwrap_or("?"))
+                            }
                         }
                         Err(err) => return Err(M3uFilterError::new(
                             M3uFilterErrorKind::Notify, format!("failed to write epg: {} - {}", path.to_str().unwrap_or("?"), err))),
@@ -50,7 +52,9 @@ pub(crate) fn write_epg(target: &ConfigTarget, cfg: &Config, epg: &Option<Epg>,
                         format!("write epg for target {} failed: No filename set", target.name)));
                 }
                 if let Some(path) = get_m3u_epg_file_path(cfg, &output.filename) {
-                    debug!("writing m3u epg to {}", path.to_str().unwrap_or("?"));
+                    if log_enabled!(Level::Debug) {
+                        debug!("writing m3u epg to {}", path.to_str().unwrap_or("?"));
+                    }
                     write_epg_file(target, epg_data, &path)?
                 }
             }
@@ -58,7 +62,9 @@ pub(crate) fn write_epg(target: &ConfigTarget, cfg: &Config, epg: &Option<Epg>,
                 match get_xtream_storage_path(cfg, &target.name) {
                     Some(path) => {
                         let epg_path = get_xtream_epg_file_path(&path);
-                        debug!("writing xtream epg to {}", epg_path.to_str().unwrap_or("?"));
+                        if log_enabled!(Level::Debug) {
+                            debug!("writing xtream epg to {}", epg_path.to_str().unwrap_or("?"));
+                        }
                         write_epg_file(target, epg_data, &epg_path)?
                     }
                     None => return Err(M3uFilterError::new(
diff --git a/src/utils/request_utils.rs b/src/utils/request_utils.rs
index be3e43cfd..f64e5859f 100644
--- a/src/utils/request_utils.rs
+++ b/src/utils/request_utils.rs
@@ -2,7 +2,7 @@ use std::collections::{HashMap, HashSet};
 use std::fs;
 use std::io::{Read};
 use std::path::{PathBuf};
-use log::{debug, error, Level};
+use log::{debug, error, Level, log_enabled};
 use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
 use crate::create_m3u_filter_error_result;
 use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
@@ -14,7 +14,9 @@ pub(crate) fn bytes_to_megabytes(bytes: u64) -> u64 {
 }
 
 pub(crate) async fn get_input_text_content(input: &ConfigInput, working_dir: &String, url_str: &str, persist_filepath: Option<PathBuf>) -> Result<String, M3uFilterError> {
-    debug!("getting input text content working_dir: {}, url: {}", working_dir, url_str);
+    if log_enabled!(Level::Debug) {
+        debug!("getting input text content working_dir: {}, url: {}", working_dir, url_str);
+    }
     match url_str.parse::<url::Url>() {
         Ok(url) => match download_text_content(input, url, persist_filepath).await {
             Ok(content) => Ok(content),
@@ -95,12 +97,12 @@ pub(crate) fn get_request_headers(defined_headers: &HashMap<String, String>, cus
                 headers.insert(
                     HeaderName::from_bytes(key.as_bytes()).unwrap(),
                     HeaderValue::from_bytes(value).unwrap());
-            } else {
+            } else if log_enabled!(Level::Debug) {
                 debug!("Ignoring request header {}={}", key_lc, String::from_utf8_lossy(value));
             }
         }
     }
-    if log::max_level() == Level::Debug {
+    if log_enabled!(Level::Debug) {
         let he: HashMap<String, String> = headers.iter().map(|(k, v)| (k.to_string(), String::from_utf8_lossy(v.as_bytes()).to_string())).collect();
         debug!("Request headers {:?}", he);
     }
@@ -108,9 +110,15 @@ pub(crate) fn get_request_headers(defined_headers: &HashMap<String, String>, cus
 }
 
 async fn download_json_content(input: &ConfigInput, url: url::Url, persist_filepath: Option<PathBuf>) -> Result<serde_json::Value, String> {
+    if log_enabled!(Level::Debug) {
+        debug!("downloading json content from {}", url.to_string());
+    }
     let request = get_client_request(input, url, None);
     match request.send().await {
         Ok(response) => {
+            if log_enabled!(Level::Debug) {
+                debug!("downloading json content response code: {}", response.status().as_str());
+            }
             if response.status().is_success() {
                 match response.json::<serde_json::Value>().await {
                     Ok(content) => {