diff --git a/cfg_checker/common/settings.py b/cfg_checker/common/settings.py
index eac81c1..993f92f 100644
--- a/cfg_checker/common/settings.py
+++ b/cfg_checker/common/settings.py
@@ -40,14 +40,20 @@
     return _json
 
 
+def _get_env_value(_key, _default):
+    _value = os.environ.get(_key, _default)
+    logger_cli.debug("... shell env: {}={}".format(_key, _value))
+    return _value
+
+
 class CheckerConfiguration(object):
     @staticmethod
     def load_nodes_list():
-        _file = os.environ.get('SALT_NODE_LIST_FILE', None)
+        _file = _get_env_value('SALT_NODE_LIST_FILE', None)
         if _file:
             _v, _ = utils.get_nodes_list(
                 os.path.join(pkg_dir, _file),
-                env_sting=os.environ.get('CFG_ALL_NODES', None)
+                env_sting=_get_env_value('CFG_ALL_NODES', None)
             )
             return _v
         else:
@@ -181,7 +187,7 @@
                     )
                 )
         self.name = "CheckerConfig"
-        self.working_folder = os.environ.get(
+        self.working_folder = _get_env_value(
             'CFG_TESTS_WORK_DIR',
             _default_work_folder
         )
@@ -191,21 +197,21 @@
         self.pkg_versions_map = 'versions_map.csv'
 
         # self.ssh_uses_sudo = False
-        self.ssh_key = os.environ.get('MCP_SSH_KEY', None)
-        self.ssh_user = os.environ.get('MCP_SSH_USER', None)
-        self.ssh_host = os.environ.get('MCP_SSH_HOST', None)
+        self.ssh_key = _get_env_value('MCP_SSH_KEY', None)
+        self.ssh_user = _get_env_value('MCP_SSH_USER', None)
+        self.ssh_host = _get_env_value('MCP_SSH_HOST', None)
         self.ssh_connect_timeout = int(
-            os.environ.get('MCP_SSH_TIMEOUT', "15")
+            _get_env_value('MCP_SSH_TIMEOUT', "15")
         )
 
-        self.mcp_host = os.environ.get('MCP_ENV_HOST', None)
-        self.salt_port = os.environ.get('MCP_SALT_PORT', '6969')
-        self.threads = int(os.environ.get('MCP_THREADS', "5"))
+        self.mcp_host = _get_env_value('MCP_ENV_HOST', None)
+        self.salt_port = _get_env_value('MCP_SALT_PORT', '6969')
+        self.threads = int(_get_env_value('MCP_THREADS', "5"))
         self.script_execution_timeout = int(
-            os.environ.get('MCP_SCRIPT_RUN_TIMEOUT', "300")
+            _get_env_value('MCP_SCRIPT_RUN_TIMEOUT', "300")
         )
 
-        self.skip_nodes = utils.node_string_to_list(os.environ.get(
+        self.skip_nodes = utils.node_string_to_list(_get_env_value(
             'CFG_SKIP_NODES',
             None
         ))
@@ -226,13 +232,13 @@
                 if _key not in os.environ:
                     os.environ[_key] = _value
 
-            self.salt_user = os.environ.get('SALT_USER', 'salt')
-            self.salt_timeout = os.environ.get('SALT_TIMEOUT', 30)
-            self.salt_file_root = os.environ.get(
+            self.salt_user = _get_env_value('SALT_USER', 'salt')
+            self.salt_timeout = _get_env_value('SALT_TIMEOUT', 30)
+            self.salt_file_root = _get_env_value(
                 'SALT_FILE_ROOT',
                 "/usr/share/salt-formulas/env/"
             )
-            self.salt_scripts_folder = os.environ.get(
+            self.salt_scripts_folder = _get_env_value(
                 'SALT_SCRIPTS_FOLDER',
                 'cfg_checker_scripts'
             )
@@ -241,16 +247,16 @@
                 if _key not in os.environ:
                     os.environ[_key] = _value
 
-            self.kube_config_root = os.environ.get('KUBE_CONFIG_ROOT', "/root")
-            self.kube_scripts_folder = os.environ.get(
+            self.kube_config_root = _get_env_value('KUBE_CONFIG_ROOT', "/root")
+            self.kube_scripts_folder = _get_env_value(
                 'KUBE_SCRIPTS_FOLDER',
                 "cfg-checker-scripts"
             )
-            self.kube_node_user = os.environ.get(
+            self.kube_node_user = _get_env_value(
                 'KUBE_NODE_USER',
                 'ubuntu'
             )
-            self.kube_node_keypath = os.environ.get(
+            self.kube_node_keypath = _get_env_value(
                 'KUBE_NODE_KEYPATH',
                 None
             )
@@ -302,7 +308,7 @@
             ConfigException -- on env file failed validation
         """
         # detect kubeconfig placement
-        _env_kubeconf_path = os.environ.get('KUBECONFIG', None)
+        _env_kubeconf_path = _get_env_value('KUBECONFIG', None)
         if not os.path.exists(self.kube_config_path):
             logger_cli.debug(
                 "... kubeconfig not detected at '{}'".format(
@@ -419,21 +425,32 @@
 
         # if env name is default, check var too
         if args.env_name == ENV_LOCAL:
-            _env = os.getenv('MCP_ENV', None)
+            _env = _get_env_value('MCP_ENV', None)
             _env = _env if _env else args.env_name
             _env_config_path = os.path.join(pkg_dir, 'etc', _env + '.env')
         else:
             _env = args.env_name
             _env_config_path = args.env_config
+        logger_cli.debug(
+            "... env is '{}', config path is '{}'".format(
+                _env,
+                _env_config_path
+            )
+        )
 
         # Init environment variables from file, validate
+        logger_cli.debug(
+            "... init environment values from '{}'".format(_env_config_path)
+        )
         self._init_env(_env_config_path, env_name=_env)
         # Load Common vars for any type of the env
+        logger_cli.debug("... loading common variables")
         self._init_mcp_values()
         # Detect env types present
         self._detect_types()
         # handle forced env type var
-        _forced_type = os.getenv('MCP_TYPE_FORCE', None)
+        logger_cli.debug("... handling forced env types")
+        _forced_type = _get_env_value('MCP_TYPE_FORCE', None)
         if _forced_type in supported_envs:
             self.detected_envs.append(_forced_type)
         elif _forced_type is not None:
@@ -461,6 +478,9 @@
             # names and folders in case of remote env
             self.user = self.ssh_user
             self.homepath = os.path.join('/home', self.ssh_user)
+        logger_cli.debug("... system user for ssh is '{}'".format(self.user))
+        logger_cli.debug("... system home path is '{}'".format(self.homepath))
 
         # Init vars that is specific to detected envs only
+        logger_cli.debug("... loading detected environment type vars")
         self._init_env_values()
diff --git a/cfg_checker/nodes.py b/cfg_checker/nodes.py
index 0559132..cf2bdf7 100644
--- a/cfg_checker/nodes.py
+++ b/cfg_checker/nodes.py
@@ -694,12 +694,13 @@
         _h = self.nodes[node]['internalip']
         _p = 22
         if self.kube.is_local or self.kube.config.ssh_direct:
-            return None,
-            self._get_ssh_shell(
+            logger.debug("Getting shell with no port forward")
+            return [None, self._get_ssh_shell(
                 _h, _u, _k, _p, silent, piped,
                 timeout=self.kube.config.ssh_connect_timeout
-            )
+            )]
         else:
+            logger.debug("Getting shell with with forward")
             _fh = "localhost"
             _p = 10022 if not fport else fport
             _pfwd = PortForward(
@@ -720,7 +721,7 @@
                 piped,
                 timeout=self.kube.config.ssh_connect_timeout
             )
-            return _pfwd, _ssh
+            return [_pfwd, _ssh]
 
     def execute_script_on_node(self, node, script_filename, args=[]):
         # Prepare path