Merge ~xavpaice/charm-telegraf:blacken-20.08 into charm-telegraf:master

[Xav Paice]

Blackened repository to 88 lines

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

This merge proposal is being monitored by mergebot. Change the status to Approved to merge.

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

Unable to determine commit message from repository - please click "Set commit message" and enter the commit message manually.

[Celia Wang (ziyiwang)]

LGTM

review: Approve

[Alvaro Uria (aluria)]

+1 to this and the other 2 related MPs (makefile and linting)

review: Approve

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

Change has no commit message, setting status to needs review.

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

Change successfully merged at revision 7a23dee3004cf081dbf37a2b5ac365bdf1e8671f

diff --git a/src/files/telegraf_exec_metrics.py b/src/files/telegraf_exec_metrics.py
index 6922e01..f03e23a 100755
--- a/src/files/telegraf_exec_metrics.py
+++ b/src/files/telegraf_exec_metrics.py
@@ -27,89 +27,91 @@ def register_metric(MetricClass):
 
 
 class FileMetric:
-    name = ''
-    input_file = ''
-    config_template = dedent('''
+    name = ""
+    input_file = ""
+    config_template = dedent(
+        """
     [[inputs.exec]]
     commands = ["{python} {script} --metric {name}"]
     name_override = "{name}"
     data_format = "json"
-    ''')
+    """
+    )
 
     def config_path(self, configs_dir):
-        return os.path.join(configs_dir, '{}.conf'.format(self.name))
+        return os.path.join(configs_dir, "{}.conf".format(self.name))
 
     def render_config(self, configs_dir, python, dry_run=False):
         config_path = self.config_path(configs_dir)
-        LOG.info('rendering config to %s', config_path)
+        LOG.info("rendering config to %s", config_path)
         script = os.path.abspath(__file__)
         output = self.config_template.format(
-            python=python or sys.executable,
-            script=script,
-            name=self.name,
+            python=python or sys.executable, script=script, name=self.name,
         )
         LOG.debug(output)
         if not dry_run:
-            with open(config_path, mode='w', encoding='utf8') as f:
+            with open(config_path, mode="w", encoding="utf8") as f:
                 f.write(output)
         return output
 
     def remove_config(self, configs_dir, dry_run=False):
         config_path = self.config_path(configs_dir)
         if os.path.isfile(config_path):
-            LOG.info('removing %s', config_path)
+            LOG.info("removing %s", config_path)
             if not dry_run:
                 os.remove(config_path)
         else:
-            LOG.info('config file %s is absent, skip removing', config_path)
+            LOG.info("config file %s is absent, skip removing", config_path)
 
     def get_input_content(self):
-        with open(self.input_file, mode='r', encoding='utf8') as f:
+        with open(self.input_file, mode="r", encoding="utf8") as f:
             return f.read()
 
     def parse(self, input_content):
-        raise NotImplementedError('parse method not implemented for this metric')
+        raise NotImplementedError("parse method not implemented for this metric")
 
 
 @register_metric
 class SockStatFileMetric(FileMetric):
-    name = 'sockstat'
-    input_file = '/proc/net/sockstat'
+    name = "sockstat"
+    input_file = "/proc/net/sockstat"
 
     def parse(self, content):
         results = {}
         for line in content.splitlines():
-            LOG.debug('parsing line: %s', line)
+            LOG.debug("parsing line: %s", line)
             # line example: TCP: inuse 62 orphan 0 tw 5 alloc 222 mem 20
-            key, value = line.split(':', maxsplit=1)
+            key, value = line.split(":", maxsplit=1)
             items = value.strip().split()
             count = len(items)
             assert count % 2 == 0
             group = {}
             for i in range(0, count, 2):
-                group[items[i]] = int(items[i+1])
+                group[items[i]] = int(items[i + 1])
             results[key.strip()] = group
         return results
 
 
 @register_metric
 class SockStat6FileMetric(SockStatFileMetric):
-    name = 'sockstat6'
-    input_file = '/proc/net/sockstat6'
+    name = "sockstat6"
+    input_file = "/proc/net/sockstat6"
 
 
 @register_metric
 class SoftNetStatFileMetric(FileMetric):
-    name = 'softnet_stat'
-    input_file = '/proc/net/softnet_stat'
+    name = "softnet_stat"
+    input_file = "/proc/net/softnet_stat"
     # customize config template with tag_keys
-    config_template = dedent('''
+    config_template = dedent(
+        """
     [[inputs.exec]]
     commands = ["{python} {script} --metric {name}"]
     name_override = "{name}"
     data_format = "json"
     tag_keys = ["cpu"]
-    ''')
+    """
+    )
 
     def parse(self, input_content):
         """Use package `insights` to parse /proc/net/softnet_stat file content.
@@ -133,85 +135,98 @@ class SoftNetStatFileMetric(FileMetric):
         cpu_nstats = softnet_stats.cpu_nstats
 
         for i, cpu_nstat in enumerate(cpu_nstats):
-            cpu_nstat['cpu'] = 'cpu{}'.format(i)
+            cpu_nstat["cpu"] = "cpu{}".format(i)
 
         return cpu_nstats
 
 
 @register_metric
 class BuddyinfoFileMetric(FileMetric):
-    name = 'buddyinfo'
-    input_file = '/proc/buddyinfo'
+    name = "buddyinfo"
+    input_file = "/proc/buddyinfo"
     # customize config template with tag_keys
-    config_template = dedent('''
+    config_template = dedent(
+        """
     [[inputs.exec]]
     commands = ["{python} {script} --metric {name}"]
     name_override = "{name}"
     data_format = "json"
     tag_keys = ["node", "zone", "size"]
-    ''')
+    """
+    )
 
     def _get_human_size(self, num):
         """Convert num in bytes to human size."""
-        for unit in ['B', 'K', 'M', 'G']:
+        for unit in ["B", "K", "M", "G"]:
             if num < 1024:
-                return '{}{}'.format(num, unit)
+                return "{}{}".format(num, unit)
             else:
                 num = num // 1024
 
     def parse(self, content):
         page_size = os.sysconf("SC_PAGE_SIZE")  # normally 4096, should be 2^N
-        LOG.info('SC_PAGE_SIZE: %s', page_size)
+        LOG.info("SC_PAGE_SIZE: %s", page_size)
         human_sizes = None
 
         # in telegraf.conf:
         # name_override = "buddyinfo"
         # tag_keys = ["node", "zone", "size"]
         items = []
-        re_line = re.compile(r"Node\s+(?P<node>\d+).*zone\s+(?P<zone>\w+)\s+(?P<pages>.*)")
+        re_line = re.compile(
+            r"Node\s+(?P<node>\d+).*zone\s+(?P<zone>\w+)\s+(?P<pages>.*)"
+        )
         for line in content.splitlines():
             LOG.debug(line)
             match = re_line.match(line)
             if match:
                 data = match.groupdict()
                 LOG.debug(data)
-                pages = data['pages'].split()
+                pages = data["pages"].split()
                 if not human_sizes:
-                    human_sizes = [self._get_human_size(page_size * 2 ** i) for i, _ in enumerate(pages)]
+                    human_sizes = [
+                        self._get_human_size(page_size * 2 ** i)
+                        for i, _ in enumerate(pages)
+                    ]
                 for k, v in zip(human_sizes, pages):
-                    items.append({
-                        'node': data['node'],
-                        'zone': data['zone'],
-                        'size': k,
-                        'count': int(v),
-                    })
+                    items.append(
+                        {
+                            "node": data["node"],
+                            "zone": data["zone"],
+                            "size": k,
+                            "count": int(v),
+                        }
+                    )
         return items
 
 
 @register_metric
 class ZoneinfoFileMetric(FileMetric):
-    name = 'zoneinfo'
-    input_file = '/proc/zoneinfo'
+    name = "zoneinfo"
+    input_file = "/proc/zoneinfo"
     # customize config template with tag_keys
-    config_template = dedent('''
+    config_template = dedent(
+        """
     [[inputs.exec]]
     commands = ["{python} {script} --metric {name}"]
     name_override = "{name}"
     data_format = "json"
     tag_keys = ["node", "zone"]
-    ''')
+    """
+    )
 
     def parse(self, content):
-        pattern = re.compile(r'^Node\s+(?P<node>\d+),\s+zone\s+(?P<zone>\S+)\n'
-            r'+.*?'  # match anything in between non-greedy
-            r'^\s+pages free\s+(?P<pages_free>\d+)\n'
-            r'^\s+min\s+(?P<min>\d+)\n'
-            r'^\s+low\s+(?P<low>\d+)\n'
-            r'^\s+high\s+(?P<high>\d+)\n'
-            r'^\s+spanned\s+(?P<spanned>\d+)\n'
-            r'^\s+present\s+(?P<present>\d+)\n'
-            r'^\s+managed\s+(?P<managed>\d+)',
-            re.MULTILINE + re.DOTALL)
+        pattern = re.compile(
+            r"^Node\s+(?P<node>\d+),\s+zone\s+(?P<zone>\S+)\n"
+            r"+.*?"  # match anything in between non-greedy
+            r"^\s+pages free\s+(?P<pages_free>\d+)\n"
+            r"^\s+min\s+(?P<min>\d+)\n"
+            r"^\s+low\s+(?P<low>\d+)\n"
+            r"^\s+high\s+(?P<high>\d+)\n"
+            r"^\s+spanned\s+(?P<spanned>\d+)\n"
+            r"^\s+present\s+(?P<present>\d+)\n"
+            r"^\s+managed\s+(?P<managed>\d+)",
+            re.MULTILINE + re.DOTALL,
+        )
         items = []
         for match in pattern.finditer(content):
             data = match.groupdict()
@@ -229,8 +244,8 @@ class CmdMetric(FileMetric):
     cmd = []
 
     def get_cmd_output(self, cmd, is_json=False):
-        LOG.debug('running cmd: %s', ' '.join(cmd))
-        output = subprocess.check_output(cmd).decode('utf8').strip()
+        LOG.debug("running cmd: %s", " ".join(cmd))
+        output = subprocess.check_output(cmd).decode("utf8").strip()
         return json.loads(output) if is_json else output
 
     def get_input_content(self):
@@ -243,52 +258,53 @@ class CmdMetric(FileMetric):
 
 @register_metric
 class NetNSCmdMetric(CmdMetric):
-    name = 'netns'
-    cmd = ['ip', 'netns', 'list']
+    name = "netns"
+    cmd = ["ip", "netns", "list"]
     # customize config template with tag_keys and interval
     # the output could be huge, so increase the interval
-    config_template = dedent('''
+    config_template = dedent(
+        """
     [[inputs.exec]]
     commands = ["{python} {script} --metric {name}"]
     name_override = "{name}"
     data_format = "json"
     tag_keys = ["namespace", "id"]
     interval = "600s"
-    ''')
+    """
+    )
 
     def parse(self, content):
         items = []
         # find openstack/neutron netns list pattern
         pattern = re.compile(r"^([\w-]+)\s+\(id:\s+(\d+)\)", flags=re.M)
         for match in pattern.finditer(content):
-            items.append({
-                'namespace': match.group(1),
-                'id': match.group(2),
-                'state': 1,
-            })
+            items.append(
+                {"namespace": match.group(1), "id": match.group(2), "state": 1,}
+            )
 
         # no re matches, should be in simple list format
         if not items:
             for line in content.splitlines():
-                items.append({
-                    'namespace': line.strip(),
-                    'state': 1,
-                })
+                items.append(
+                    {"namespace": line.strip(), "state": 1,}
+                )
         return items
 
 
 @register_metric
 class OvsDumpFlowsCmdMetric(CmdMetric):
-    name = 'ovs_dump_flows'
+    name = "ovs_dump_flows"
     # customize config template with tag_keys and interval
     # the output could be huge, so increase the interval
-    config_template = dedent('''
+    config_template = dedent(
+        """
     [[inputs.exec]]
     commands = ["{python} {script} --metric {name}"]
     name_override = "{name}"
     data_format = "json"
     tag_keys = ["bridge"]
-    ''')
+    """
+    )
 
     def get_input_content(self):
         """Get ovs dump-flows output for each bridge in a dict.
@@ -304,13 +320,13 @@ class OvsDumpFlowsCmdMetric(CmdMetric):
         """
         flows = {}
 
-        ovs_cmd = 'ovs-ofctl'
+        ovs_cmd = "ovs-ofctl"
         if not shutil.which(ovs_cmd):
             LOG.error('openvswitch command "%s" is not available, exit', ovs_cmd)
             return flows
 
-        for bridge in ['br-int', 'br-tun', 'br-data']:
-            cmd = ['sudo', ovs_cmd, 'dump-flows', bridge]
+        for bridge in ["br-int", "br-tun", "br-data"]:
+            cmd = ["sudo", ovs_cmd, "dump-flows", bridge]
             output = self.get_cmd_output(cmd)
             flows[bridge] = output
 
@@ -351,16 +367,18 @@ class OvsDumpFlowsCmdMetric(CmdMetric):
 
 @register_metric
 class OvsDpCtlCmdMetric(CmdMetric):
-    name = 'ovs_dpctl'
-    cmd = ['sudo', 'ovs-appctl', 'dpctl/show', '-s']
+    name = "ovs_dpctl"
+    cmd = ["sudo", "ovs-appctl", "dpctl/show", "-s"]
     # customize tag_keys
-    config_template = dedent('''
+    config_template = dedent(
+        """
     [[inputs.exec]]
     commands = ["{python} {script} --metric {name}"]
     name_override = "{name}"
     data_format = "json"
     tag_keys = ["datapath", "portname", "port"]
-    ''')
+    """
+    )
 
     def parse_fields(self, text):
         """
@@ -443,15 +461,17 @@ class OvsDpCtlCmdMetric(CmdMetric):
         return result
 
 
-def render_config_files(configs_dir, python, disabled_metrics='', dry_run=False):
+def render_config_files(configs_dir, python, disabled_metrics="", dry_run=False):
     """Render config files for any metrics not disabled, and remove any disabled"""
 
-    disabled_metrics_set = set(disabled_metrics.split(':')) if disabled_metrics else set([])
+    disabled_metrics_set = (
+        set(disabled_metrics.split(":")) if disabled_metrics else set([])
+    )
     for metric in disabled_metrics_set:
         try:
             METRICS[metric].remove_config(configs_dir, dry_run=dry_run)
         except KeyError:
-            LOG.warning('metric name %s not in %s', metric, ','.join(METRICS))
+            LOG.warning("metric name %s not in %s", metric, ",".join(METRICS))
     enabled_metrics_set = set(METRICS.keys()) - disabled_metrics_set
     for metric in enabled_metrics_set:
         METRICS[metric].render_config(configs_dir, python, dry_run=dry_run)
@@ -459,56 +479,67 @@ def render_config_files(configs_dir, python, disabled_metrics='', dry_run=False)
 
 def main():
     argparser = argparse.ArgumentParser(
-        description='Telegraf exec metrics',
+        description="Telegraf exec metrics",
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
     choices = list(METRICS)  # sorted dict
     argparser.add_argument(
-        '--metric', choices=choices,
+        "--metric",
+        choices=choices,
         default=choices[0],
-        help='which metric to execuate',
+        help="which metric to execuate",
     )
     argparser.add_argument(
-        '-f', '--input-file', dest='input_file',
-        help='read input content from this file',
+        "-f",
+        "--input-file",
+        dest="input_file",
+        help="read input content from this file",
     )
     argparser.add_argument(
-        '--render-config-files', dest='render_config_files', action='store_true',
-        help='render config files for all metrics, use --disabled-metrics to exclude specific ones',
+        "--render-config-files",
+        dest="render_config_files",
+        action="store_true",
+        help="render config files for all metrics, use --disabled-metrics to exclude specific ones",
     )
     argparser.add_argument(
-        '--disabled-metrics', dest='disabled_metrics', default='',
-        help='colon separated metric names to disable, e.g.: buddyinfo:zoneinfo',
+        "--disabled-metrics",
+        dest="disabled_metrics",
+        default="",
+        help="colon separated metric names to disable, e.g.: buddyinfo:zoneinfo",
     )
     argparser.add_argument(
-        '--python', dest='python', default=sys.executable,
-        help='python interperter path in config file to execute this script, required for venv',
+        "--python",
+        dest="python",
+        default=sys.executable,
+        help="python interperter path in config file to execute this script, required for venv",
     )
     # useful for testing
     argparser.add_argument(
-        '--configs-dir', dest='configs_dir', default='/etc/telegraf/telegraf.d/',
-        help='telegraf configs dir for exec metrics',
+        "--configs-dir",
+        dest="configs_dir",
+        default="/etc/telegraf/telegraf.d/",
+        help="telegraf configs dir for exec metrics",
     )
     argparser.add_argument(
-        '--dry-run', action='store_true',
-        help='dry run without real actions',
+        "--dry-run", action="store_true", help="dry run without real actions",
     )
     argparser.add_argument(
-        '-v', '--verbose', action='store_true',
-        help='be verbose in log',
+        "-v", "--verbose", action="store_true", help="be verbose in log",
     )
 
     cli = argparser.parse_args()
     logging.basicConfig(
         level=logging.DEBUG if cli.verbose else logging.WARNING,
-        format='%(asctime)s %(levelname)s: %(message)s')
+        format="%(asctime)s %(levelname)s: %(message)s",
+    )
 
     if cli.render_config_files:
         render_config_files(
             cli.configs_dir,
             cli.python,
             disabled_metrics=cli.disabled_metrics,
-            dry_run=cli.dry_run)
+            dry_run=cli.dry_run,
+        )
     else:
         metric = METRICS[cli.metric]
         if cli.input_file:
@@ -517,5 +548,5 @@ def main():
         print(json.dumps(output, indent=4))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/src/hooks/relations/apache-website/requires.py b/src/hooks/relations/apache-website/requires.py
index 0423c2d..ecb663a 100644
--- a/src/hooks/relations/apache-website/requires.py
+++ b/src/hooks/relations/apache-website/requires.py
@@ -22,12 +22,12 @@ from charms.reactive import scopes
 class WSGIRequires(RelationBase):
     scope = scopes.UNIT
 
-    @hook('{requires:apache-website}-relation-{joined,changed}')
+    @hook("{requires:apache-website}-relation-{joined,changed}")
     def changed(self):
         conv = self.conversation()
-        conv.set_state('{relation_name}.available')
+        conv.set_state("{relation_name}.available")
 
-    @hook('{requires:apache-website}-relation-{departed,broken}')
+    @hook("{requires:apache-website}-relation-{departed,broken}")
     def broken(self):
         conv = self.conversation()
-        conv.remove_state('{relation_name}.available')
+        conv.remove_state("{relation_name}.available")
diff --git a/src/hooks/relations/statistics/requires.py b/src/hooks/relations/statistics/requires.py
index 284b671..4aafb2a 100644
--- a/src/hooks/relations/statistics/requires.py
+++ b/src/hooks/relations/statistics/requires.py
@@ -22,16 +22,16 @@ from charms.reactive import scopes
 class WSGIRequires(RelationBase):
     scope = scopes.UNIT
 
-    @hook('{requires:statistics}-relation-{joined,changed}')
+    @hook("{requires:statistics}-relation-{joined,changed}")
     def changed(self):
         conv = self.conversation()
-        conv.set_state('{relation_name}.connected')
-        if conv.get_remote('enabled'):
+        conv.set_state("{relation_name}.connected")
+        if conv.get_remote("enabled"):
             # this unit's conversation has a port, so
             # it is part of the set of available units
-            conv.set_state('{relation_name}.available')
+            conv.set_state("{relation_name}.available")
 
-    @hook('{requires:statistics}-relation-{departed,broken}')
+    @hook("{requires:statistics}-relation-{departed,broken}")
     def broken(self):
         conv = self.conversation()
-        conv.remove_state('{relation_name}.available')
+        conv.remove_state("{relation_name}.available")
diff --git a/src/hooks/relations/telegraf-exec/requires.py b/src/hooks/relations/telegraf-exec/requires.py
index 6582ebb..42bb783 100644
--- a/src/hooks/relations/telegraf-exec/requires.py
+++ b/src/hooks/relations/telegraf-exec/requires.py
@@ -24,37 +24,37 @@ from charms.reactive import scopes
 class ExecRequires(RelationBase):
     scope = scopes.UNIT
 
-    @hook('{requires:telegraf-exec}-relation-{joined,changed}')
+    @hook("{requires:telegraf-exec}-relation-{joined,changed}")
     def changed(self):
         conv = self.conversation()
-        conv.set_state('{relation_name}.connected')
-        commands_json_dict = conv.get_remote('commands') # list of commands to run
+        conv.set_state("{relation_name}.connected")
+        commands_json_dict = conv.get_remote("commands")  # list of commands to run
         if commands_json_dict is not None and json.loads(commands_json_dict):
-            conv.set_state('{relation_name}.available')
+            conv.set_state("{relation_name}.available")
 
-    @hook('{requires:telegraf-exec}-relation-{departed,broken}')
+    @hook("{requires:telegraf-exec}-relation-{departed,broken}")
     def broken(self):
         conv = self.conversation()
-        conv.remove_state('{relation_name}.connected')
-        conv.remove_state('{relation_name}.available')
+        conv.remove_state("{relation_name}.connected")
+        conv.remove_state("{relation_name}.available")
 
     def commands(self):
         cmds = []
         for conv in self.conversations():
-            commands_json_dict = conv.get_remote('commands') # list of commands dicts
+            commands_json_dict = conv.get_remote("commands")  # list of commands dicts
             for cmd_info in json.loads(commands_json_dict):
-                commands = cmd_info.pop('commands', []) # list of commands
-                if commands is None and 'command' in cmd_info:
-                    commands = [cmd_info.pop('command')]
+                commands = cmd_info.pop("commands", [])  # list of commands
+                if commands is None and "command" in cmd_info:
+                    commands = [cmd_info.pop("command")]
                 if not commands:
                     continue
-                data_format = cmd_info.pop('data_format') # json, graphite, influx
-                cmd = {'commands': commands, 'data_format': data_format}
+                data_format = cmd_info.pop("data_format")  # json, graphite, influx
+                cmd = {"commands": commands, "data_format": data_format}
                 # timeout is otional because we have telegraf 0.12.1 around
-                cmd['timeout'] = cmd_info.pop('timeout', '5s')
+                cmd["timeout"] = cmd_info.pop("timeout", "5s")
                 # by default run_on_this_unit is True, we risk to run the command
                 # everywhere than not running it at all
-                cmd['run_on_this_unit'] = cmd_info.pop('run_on_this_unit', True)
+                cmd["run_on_this_unit"] = cmd_info.pop("run_on_this_unit", True)
                 cmd.update(cmd_info)
                 cmds.append(cmd)
         return cmds
diff --git a/src/reactive/telegraf.py b/src/reactive/telegraf.py
index 83264e7..ba47505 100644
--- a/src/reactive/telegraf.py
+++ b/src/reactive/telegraf.py
@@ -51,20 +51,20 @@ from charmhelpers.contrib.charmsupport import nrpe
 import charms.promreg
 from jinja2 import Template, Environment, FileSystemLoader, exceptions
 
-DEB_BASE_DIR = '/etc/telegraf'
-SNAP_BASE_DIR = '/var/snap/telegraf/current'
-SUDOERS_DIR = '/etc/sudoers.d'
+DEB_BASE_DIR = "/etc/telegraf"
+SNAP_BASE_DIR = "/var/snap/telegraf/current"
+SUDOERS_DIR = "/etc/sudoers.d"
 
-CONFIG_FILE = 'telegraf.conf'
+CONFIG_FILE = "telegraf.conf"
 
-CONFIG_DIR = 'telegraf.d'
+CONFIG_DIR = "telegraf.d"
 
-GRAFANA_DASHBOARD_TELEGRAF_FILE_NAME = 'Telegraf.json.j2'
+GRAFANA_DASHBOARD_TELEGRAF_FILE_NAME = "Telegraf.json.j2"
 
-GRAFANA_DASHBOARD_NAME = 'telegraf'
+GRAFANA_DASHBOARD_NAME = "telegraf"
 
-SNAP_SERVICE = 'snap.telegraf.telegraf'
-DEB_SERVICE = 'telegraf'
+SNAP_SERVICE = "snap.telegraf.telegraf"
+DEB_SERVICE = "telegraf"
 
 # Utilities #
 
@@ -75,43 +75,46 @@ class InvalidInstallMethod(Exception):
 
 def get_install_method():
     config = hookenv.config()
-    if config['install_method'] in ['deb', 'snap']:
-        return config['install_method']
+    if config["install_method"] in ["deb", "snap"]:
+        return config["install_method"]
     else:
         hookenv.log(
-            "Invalid install_method for telegraf: {}".format(config['install_method']),
-            level=hookenv.ERROR)
+            "Invalid install_method for telegraf: {}".format(config["install_method"]),
+            level=hookenv.ERROR,
+        )
         raise InvalidInstallMethod()
 
 
 def get_base_dir():
     config = hookenv.config()
-    if config['install_method'] == 'deb':
+    if config["install_method"] == "deb":
         return DEB_BASE_DIR
-    elif config['install_method'] == 'snap':
+    elif config["install_method"] == "snap":
         return SNAP_BASE_DIR
     else:
         hookenv.log(
-            "Invalid install_method for telegraf: {}".format(config['install_method']),
-            level=hookenv.ERROR)
+            "Invalid install_method for telegraf: {}".format(config["install_method"]),
+            level=hookenv.ERROR,
+        )
         raise InvalidInstallMethod()
 
 
 def get_service():
     config = hookenv.config()
-    if config['install_method'] == 'deb':
+    if config["install_method"] == "deb":
         return DEB_SERVICE
-    elif config['install_method'] == 'snap':
+    elif config["install_method"] == "snap":
         return SNAP_SERVICE
     else:
         hookenv.log(
-            "Invalid install_method for telegraf: {}".format(config['install_method']),
-            level=hookenv.ERROR)
+            "Invalid install_method for telegraf: {}".format(config["install_method"]),
+            level=hookenv.ERROR,
+        )
         raise InvalidInstallMethod()
 
 
 def get_templates_dir():
-    return os.path.join(hookenv.charm_dir(), 'templates')
+    return os.path.join(hookenv.charm_dir(), "templates")
 
 
 def get_main_config_path():
@@ -123,14 +126,13 @@ def get_configs_dir():
 
 
 def get_files_dir():
-    return os.path.join(hookenv.charm_dir(), 'files')
+    return os.path.join(hookenv.charm_dir(), "files")
 
 
 def list_supported_plugins():
-    return [k for k in hookenv.metadata()['requires'].keys()
-            if k != 'juju-info'] + \
-        [k for k in hookenv.metadata()['provides'].keys()
-            if k != 'juju-info']
+    return [k for k in hookenv.metadata()["requires"].keys() if k != "juju-info"] + [
+        k for k in hookenv.metadata()["provides"].keys() if k != "juju-info"
+    ]
 
 
 def list_config_files():
@@ -138,27 +140,26 @@ def list_config_files():
     # only include config files for configured plugins
     current_states = get_states()
     for plugin in list_supported_plugins():
-        if 'plugins.{}.configured'.format(plugin) in current_states.keys():
-            config_path = '{}/{}.conf'.format(get_configs_dir(), plugin)
+        if "plugins.{}.configured".format(plugin) in current_states.keys():
+            config_path = "{}/{}.conf".format(get_configs_dir(), plugin)
             config_files.append(config_path)
-    if 'extra_plugins.configured' in current_states.keys():
-        config_files.append('{}/extra_plugins.conf'.format(get_configs_dir()))
-    config_files.append('{}/socket_listener.conf'.format(get_configs_dir()))
+    if "extra_plugins.configured" in current_states.keys():
+        config_files.append("{}/extra_plugins.conf".format(get_configs_dir()))
+    config_files.append("{}/socket_listener.conf".format(get_configs_dir()))
     return config_files
 
 
 def get_hostname_label():
     config = hookenv.config()
-    hostname_fmt = config['hostname']
-    unit = get_remote_unit_name().replace('/', '-')  # / is invalid in labels.
-    if hostname_fmt == 'UNIT_NAME':  # Deprecated
+    hostname_fmt = config["hostname"]
+    unit = get_remote_unit_name().replace("/", "-")  # / is invalid in labels.
+    if hostname_fmt == "UNIT_NAME":  # Deprecated
         return unit
     env = os.environ
-    model = env.get('JUJU_ENV_NAME') or env.get('JUJU_MODEL_NAME', '')
-    uuid = env.get('JUJU_ENV_UUID') or env.get('JUJU_MODEL_UUID', '')
+    model = env.get("JUJU_ENV_NAME") or env.get("JUJU_MODEL_NAME", "")
+    uuid = env.get("JUJU_ENV_UUID") or env.get("JUJU_MODEL_UUID", "")
     syshost = socket.gethostname()
-    return hostname_fmt.format(unit=unit, model=model, uuid=uuid,
-                               host=syshost)
+    return hostname_fmt.format(unit=unit, model=model, uuid=uuid, host=syshost)
 
 
 def get_remote_unit_name():
@@ -170,19 +171,19 @@ def get_remote_unit_name():
         # Note(aluria): lookup all available IPv4/IPv6 addresses (except lo)
         ip_addresses = set()
         for iface in netifaces.interfaces():
-            if iface == 'lo':
+            if iface == "lo":
                 continue
             ip_addrs = netifaces.ifaddresses(iface)
             for iface_type in ip_addrs:
                 if iface_type in (netifaces.AF_INET, netifaces.AF_INET6):
                     for addrs in ip_addrs[iface_type]:
-                        ip_addresses.add(addrs['addr'])
+                        ip_addresses.add(addrs["addr"])
 
         # Note(aluria): and try to match them against rel['private-address']
-        for rel_type in hookenv.metadata()['requires'].keys():
+        for rel_type in hookenv.metadata()["requires"].keys():
             for rel in hookenv.relations_of_type(rel_type):
-                if rel['private-address'] in ip_addresses:
-                    return rel['__unit__']
+                if rel["private-address"] in ip_addresses:
+                    return rel["__unit__"]
 
 
 def get_base_inputs():
@@ -192,28 +193,28 @@ def get_base_inputs():
     extra_options = get_extra_options()
     conntrack = os.path.exists("/proc/sys/net/netfilter/nf_conntrack_max")
     config = hookenv.config()
-    str_disabled_plugins = config['disabled_plugins']
-    disabled_plugins = str_disabled_plugins.split(':') if str_disabled_plugins else []
+    str_disabled_plugins = config["disabled_plugins"]
+    disabled_plugins = str_disabled_plugins.split(":") if str_disabled_plugins else []
     return {
-        'extra_options': extra_options['inputs'],
-        'bcache': is_bcache(),
-        'python': sys.executable,
-        'files_dir': get_files_dir(),
-        'disabled_plugins': disabled_plugins,
-        'openvswitch': host.service_running('openvswitch-switch'),
-        'conntrack': conntrack,
+        "extra_options": extra_options["inputs"],
+        "bcache": is_bcache(),
+        "python": sys.executable,
+        "files_dir": get_files_dir(),
+        "disabled_plugins": disabled_plugins,
+        "openvswitch": host.service_running("openvswitch-switch"),
+        "conntrack": conntrack,
     }
 
 
 def render_base_inputs():
     # use base inputs from charm templates
-    with open(os.path.join(get_templates_dir(), 'base_inputs.conf'), 'r') as fd:
+    with open(os.path.join(get_templates_dir(), "base_inputs.conf"), "r") as fd:
         return render_template(fd.read(), get_base_inputs())
 
 
 def get_extra_options():
-    extra_options = {'inputs': {}, 'outputs': {}}
-    extra_options_raw = hookenv.config()['extra_options']
+    extra_options = {"inputs": {}, "outputs": {}}
+    extra_options_raw = hookenv.config()["extra_options"]
     extra_opts = yaml.full_load(extra_options_raw) or {}
     extra_options.update(extra_opts)
     # jsonify value, required as the telegraf config values format is similar
@@ -227,7 +228,7 @@ def get_extra_options():
             json_vals[k][plugin] = {}
             # inner plugin (aka key:value)
             for key, val in values.items():
-                if key in ('tagpass', 'tagdrop'):
+                if key in ("tagpass", "tagdrop"):
                     # this is a tagpass/drop, we need to go deeper
                     json_vals[k][plugin][key] = {}
                     for tag, tagvalue in val.items():
@@ -257,9 +258,11 @@ def render_extra_options(kind, name, extra_options=None):
   """
     if extra_options is None:
         extra_options = get_extra_options()
-    context = {"extra_options": extra_options[kind].get(name, {}),
-               "kind": kind,
-               "name": name}
+    context = {
+        "extra_options": extra_options[kind].get(name, {}),
+        "kind": kind,
+        "name": name,
+    }
     return render_template(template, context)
 
 
@@ -269,7 +272,7 @@ def render_template(template, context):
 
 
 def check_prometheus_port(key, new_port):
-    unitdata_key = '{}.port'.format(key)
+    unitdata_key = "{}.port".format(key)
     kv = unitdata.kv()
     existing_port = kv.get(unitdata_key)
     if existing_port != new_port:
@@ -286,31 +289,35 @@ def check_prometheus_port(key, new_port):
 
 def get_prometheus_port():
     config = hookenv.config()
-    if not config.get('prometheus_output_port', False):
+    if not config.get("prometheus_output_port", False):
         return False
-    if config.get('prometheus_output_port') == 'default':
+    if config.get("prometheus_output_port") == "default":
         return 9103
     else:
-        return int(config.get('prometheus_output_port'))
+        return int(config.get("prometheus_output_port"))
 
 
 def get_socket_listener_port():
     config = hookenv.config()
-    if not config.get('socket_listener_port', False):
+    if not config.get("socket_listener_port", False):
         return 8094
     else:
-        return int(config.get('socket_listener_port'))
+        return int(config.get("socket_listener_port"))
 
 
 def render_socket_listener_config(context):
     # Remove deprecated config file
-    old_config_path = '{}/tcp_listener.conf'.format(get_configs_dir())
+    old_config_path = "{}/tcp_listener.conf".format(get_configs_dir())
     if os.path.exists(old_config_path):
         os.remove(old_config_path)
 
-    config_path = '{}/socket_listener.conf'.format(get_configs_dir())
-    render(source='socket_listener.tmpl', templates_dir=get_templates_dir(),
-           target=config_path, context=context)
+    config_path = "{}/socket_listener.conf".format(get_configs_dir())
+    render(
+        source="socket_listener.tmpl",
+        templates_dir=get_templates_dir(),
+        target=config_path,
+        context=context,
+    )
 
 
 def get_sysstat_config_with_sadc_xall(content):
@@ -337,23 +344,35 @@ def get_sysstat_config_with_sadc_xall(content):
         value = match.group(1)
         if "-S" in value:
             # if `-S` in value, replace it to XALL, keep other options unchanged.
-            return re.sub(r'^SADC_OPTIONS="(.*-S\s+)(\w+)(.*)"', r'SADC_OPTIONS="\1XALL\3"', content, flags=re.M)
+            return re.sub(
+                r'^SADC_OPTIONS="(.*-S\s+)(\w+)(.*)"',
+                r'SADC_OPTIONS="\1XALL\3"',
+                content,
+                flags=re.M,
+            )
         else:
             # if `-S` not in value, append `-S XALL` to value
-            return re.sub(r'^SADC_OPTIONS="(.*)"', r'SADC_OPTIONS="\1 -S XALL"', content, flags=re.M)
+            return re.sub(
+                r'^SADC_OPTIONS="(.*)"',
+                r'SADC_OPTIONS="\1 -S XALL"',
+                content,
+                flags=re.M,
+            )
 
 
-def update_sysstat_config_with_sdac_xall(path='/etc/sysstat/sysstat'):
+def update_sysstat_config_with_sdac_xall(path="/etc/sysstat/sysstat"):
     """Update `/etc/sysstat/sysstat` to ensure `-S XALL` in `SADC_OPTIONS`."""
     if os.path.isfile(path):
-        with open(path, mode='r', encoding='utf8') as f:
+        with open(path, mode="r", encoding="utf8") as f:
             new_text = get_sysstat_config_with_sadc_xall(f.read())
         if new_text:
             hookenv.log("updating {} to ensure `-S XALL` in SADC_OPTIONS".format(path))
-            with open(path, mode='w', encoding='utf8') as f:
+            with open(path, mode="w", encoding="utf8") as f:
                 f.write(new_text)
     else:
-        hookenv.log("sysstat config file not found: {}".format(path), level=hookenv.WARNING)
+        hookenv.log(
+            "sysstat config file not found: {}".format(path), level=hookenv.WARNING
+        )
 
 
 def configure_telegraf():  # noqa: C901
@@ -363,39 +382,46 @@ def configure_telegraf():  # noqa: C901
     try:
         config_path = get_main_config_path()
     except InvalidInstallMethod:
-        hookenv.status_set('blocked', 'Wrong install_method provided: {!r}'.format(config['install_method']))
+        hookenv.status_set(
+            "blocked",
+            "Wrong install_method provided: {!r}".format(config["install_method"]),
+        )
         return
     if get_remote_unit_name() is None:
-        hookenv.status_set('waiting', 'Waiting for juju-info relation')
+        hookenv.status_set("waiting", "Waiting for juju-info relation")
         # if UNIT_NAME in hostname config and relation not yet available,
         # make telegraf unable to start to not get weird metrics names
         if os.path.exists(config_path):
             os.unlink(config_path)
         return
 
-    inputs = config.get('inputs_config', '')
-    outputs = config.get('outputs_config', '')
+    inputs = config.get("inputs_config", "")
+    outputs = config.get("outputs_config", "")
     # just for the migration out of base64
     if inputs:
         try:
-            inputs = base64.b64decode(inputs.encode('utf-8'), validate=True).decode('utf-8')
+            inputs = base64.b64decode(inputs.encode("utf-8"), validate=True).decode(
+                "utf-8"
+            )
         except binascii.Error:
             # not bas64, probably already up to date configs
             pass
     if outputs:
         try:
-            outputs = base64.b64decode(outputs.encode('utf-8'), validate=True).decode('utf-8')
+            outputs = base64.b64decode(outputs.encode("utf-8"), validate=True).decode(
+                "utf-8"
+            )
         except binascii.Error:
             # not bas64, probably already up to date configs
             pass
     tags = []
-    if config['tags']:
-        for tag in config['tags'].split(','):
+    if config["tags"]:
+        for tag in config["tags"].split(","):
             key, value = tag.split("=")
             tags.append('{} = "{}"'.format(key, value))
     # add extra juju-related tags to be exposed as labels
-    tags.append('juju_application = "{}"'.format(get_remote_unit_name().split('/')[0]))
-    tags.append('juju_unit = "{}"'.format(get_remote_unit_name().replace('/', '-')))
+    tags.append('juju_application = "{}"'.format(get_remote_unit_name().split("/")[0]))
+    tags.append('juju_unit = "{}"'.format(get_remote_unit_name().replace("/", "-")))
     tags.append('juju_model = "{}"'.format(hookenv.model_name()))
     context["tags"] = tags
     if inputs:
@@ -412,42 +438,56 @@ def configure_telegraf():  # noqa: C901
     context["hostname"] = get_hostname_label()
 
     logfile_path = os.path.normpath(context["logfile"])
-    if (context["logfile"] and not logfile_path.startswith("/var/log/") and not
-       (config["install_method"] == 'snap' and
-           logfile_path.startswith("/var/snap/telegraf/common/"))):
+    if (
+        context["logfile"]
+        and not logfile_path.startswith("/var/log/")
+        and not (
+            config["install_method"] == "snap"
+            and logfile_path.startswith("/var/snap/telegraf/common/")
+        )
+    ):
         # only allow logging in /var/log, syslog, or /var/snap/telegraf/common
-        hookenv.log("logfile value reset to stderr."
-                    " Original value: {}".format(context["logfile"]),
-                    hookenv.DEBUG)
+        hookenv.log(
+            "logfile value reset to stderr."
+            " Original value: {}".format(context["logfile"]),
+            hookenv.DEBUG,
+        )
         context["logfile"] = ""
 
     if get_prometheus_port():
         context["prometheus_output_port"] = get_prometheus_port()
         check_prometheus_port("prometheus_output", get_prometheus_port())
-    context['extra_options'] = get_extra_options()
+    context["extra_options"] = get_extra_options()
 
     if get_socket_listener_port():
         context["socket_listener_port"] = get_socket_listener_port()
 
     render_socket_listener_config(context=context)
 
-    telegraf_exec_metrics = os.path.join(get_files_dir(), 'telegraf_exec_metrics.py')
+    telegraf_exec_metrics = os.path.join(get_files_dir(), "telegraf_exec_metrics.py")
     cmd = [
         telegraf_exec_metrics,
-        '--render-config-files',
-        '--disabled-metrics', config['disabled_plugins'],
-        '--configs-dir', get_configs_dir(),  # unit test can monkeypatch this path
-        '--python', sys.executable,  # this will be venv python interpreter path
+        "--render-config-files",
+        "--disabled-metrics",
+        config["disabled_plugins"],
+        "--configs-dir",
+        get_configs_dir(),  # unit test can monkeypatch this path
+        "--python",
+        sys.executable,  # this will be venv python interpreter path
     ]
-    hookenv.log("Rendering exec metrics config files: {}".format(' '.join(cmd)))
+    hookenv.log("Rendering exec metrics config files: {}".format(" ".join(cmd)))
     subprocess.check_call(cmd)
 
     hookenv.log("Updating main config file")
-    render(source='telegraf.conf.tmpl', templates_dir=get_templates_dir(),
-           target=config_path, context=context)
+    render(
+        source="telegraf.conf.tmpl",
+        templates_dir=get_templates_dir(),
+        target=config_path,
+        context=context,
+    )
 
     # add sudoers file for telegraf if openvswitch is running
-    if host.service_running('openvswitch-switch'):
+    if host.service_running("openvswitch-switch"):
         sudoers_filename = "telegraf_sudoers"
         src = os.path.join(get_files_dir(), sudoers_filename)
         dst = os.path.join(SUDOERS_DIR, sudoers_filename)
@@ -466,360 +506,388 @@ def configure_telegraf():  # noqa: C901
                 # If we're using the snap, and the deb failed to install, it's fine too
                 pass
 
-    set_flag('telegraf.configured')
-    set_flag('telegraf.needs_reload')
-    if config["install_method"] == 'deb':
-        set_flag('telegraf.apt.configured')
+    set_flag("telegraf.configured")
+    set_flag("telegraf.needs_reload")
+    if config["install_method"] == "deb":
+        set_flag("telegraf.apt.configured")
     else:
-        set_flag('telegraf.snap.configured')
+        set_flag("telegraf.snap.configured")
 
 
 # States
 
-@when_not('telegraf.installed')
+
+@when_not("telegraf.installed")
 def install_telegraf():
     try:
         install_method = get_install_method()
     except InvalidInstallMethod:
-        hookenv.status_set('blocked', "Wrong install_method provided. Expected either 'deb' or 'snap'.")
+        hookenv.status_set(
+            "blocked", "Wrong install_method provided. Expected either 'deb' or 'snap'."
+        )
         return
-    if install_method == 'deb':
+    if install_method == "deb":
         try:
-            snap.remove('telegraf')
+            snap.remove("telegraf")
         except Exception:
             # the snap may already be absent, or snaps may not even be supported in this environment
             pass
-        apt.queue_install(['telegraf'])
-    elif install_method == 'snap':
-        apt.purge('telegraf')
+        apt.queue_install(["telegraf"])
+    elif install_method == "snap":
+        apt.purge("telegraf")
         config = hookenv.config()
-        snap_channel = config.get('snap_channel')
-        snap.install('telegraf', channel=snap_channel, classic=True)
+        snap_channel = config.get("snap_channel")
+        snap.install("telegraf", channel=snap_channel, classic=True)
     if install_method:
-        set_flag('telegraf.installed')
+        set_flag("telegraf.installed")
 
 
-@when('telegraf.installed')
-@when('apt.installed.telegraf')
-@when_not('telegraf.configured')
-@when_not('telegraf.apt.configured')
+@when("telegraf.installed")
+@when("apt.installed.telegraf")
+@when_not("telegraf.configured")
+@when_not("telegraf.apt.configured")
 def configure_telegraf_deb():
     configure_telegraf()
 
 
-@when('telegraf.installed')
-@when('snap.installed.telegraf')
-@when_not('telegraf.configured')
-@when_not('telegraf.snap.configured')
+@when("telegraf.installed")
+@when("snap.installed.telegraf")
+@when_not("telegraf.configured")
+@when_not("telegraf.snap.configured")
 def configure_telegraf_snap():
     configure_telegraf()
 
 
-@hook('upgrade-charm')
+@hook("upgrade-charm")
 def upgrade_charm():
     for plugin in list_supported_plugins():
-        clear_flag('plugins.{}.configured'.format(plugin))
-    clear_flag('extra_plugins.configured')
-    clear_flag('telegraf.configured')
-    clear_flag('telegraf.apt.configured')
-    clear_flag('telegraf.snap.configured')
-    clear_flag('grafana.configured')
+        clear_flag("plugins.{}.configured".format(plugin))
+    clear_flag("extra_plugins.configured")
+    clear_flag("telegraf.configured")
+    clear_flag("telegraf.apt.configured")
+    clear_flag("telegraf.snap.configured")
+    clear_flag("grafana.configured")
 
 
-@when('config.changed')
+@when("config.changed")
 def handle_config_changes():
     config = hookenv.config()
-    if config.changed('extra_options'):
+    if config.changed("extra_options"):
         for plugin in list_supported_plugins():
-            clear_flag('plugins.{}.configured'.format(plugin))
+            clear_flag("plugins.{}.configured".format(plugin))
     # if something else changed, let's reconfigure telegraf itself just in case
-    if config.changed('extra_plugins'):
-        clear_flag('extra_plugins.configured')
-    if config.changed('install_method') or config.changed('snap_channel') or config.changed('install_sources'):
-        clear_flag('telegraf.installed')
-    clear_flag('telegraf.configured')
-    clear_flag('telegraf.apt.configured')
-    clear_flag('telegraf.snap.configured')
-    clear_flag('telegraf.nagios-setup.complete')
-
-
-@when('telegraf.configured')
-@when_not('extra_plugins.configured')
+    if config.changed("extra_plugins"):
+        clear_flag("extra_plugins.configured")
+    if (
+        config.changed("install_method")
+        or config.changed("snap_channel")
+        or config.changed("install_sources")
+    ):
+        clear_flag("telegraf.installed")
+    clear_flag("telegraf.configured")
+    clear_flag("telegraf.apt.configured")
+    clear_flag("telegraf.snap.configured")
+    clear_flag("telegraf.nagios-setup.complete")
+
+
+@when("telegraf.configured")
+@when_not("extra_plugins.configured")
 def configure_extra_plugins():
     config = hookenv.config()
-    plugins = config['extra_plugins']
+    plugins = config["extra_plugins"]
     if plugins:
-        config_path = '{}/extra_plugins.conf'.format(get_configs_dir())
-        host.write_file(config_path, plugins.encode('utf-8'))
-        set_flag('extra_plugins.configured')
-        set_flag('telegraf.needs_reload')
+        config_path = "{}/extra_plugins.conf".format(get_configs_dir())
+        host.write_file(config_path, plugins.encode("utf-8"))
+        set_flag("extra_plugins.configured")
+        set_flag("telegraf.needs_reload")
 
 
-@when('elasticsearch.available')
+@when("elasticsearch.available")
 def elasticsearch_input(es):
     template = """
 [[inputs.elasticsearch]]
   servers = {{ servers }}
 """
     hosts = []
-    rels = hookenv.relations_of_type('elasticsearch')
+    rels = hookenv.relations_of_type("elasticsearch")
     for rel in rels:
-        es_host = rel.get('host')
-        port = rel.get('port')
+        es_host = rel.get("host")
+        port = rel.get("port")
         if not es_host or not port:
-            hookenv.log('No host received for relation: {}.'.format(rel))
+            hookenv.log("No host received for relation: {}.".format(rel))
             continue
         hosts.append("http://{}:{}".format(es_host, port))
-    config_path = '{}/{}.conf'.format(get_configs_dir(), 'elasticsearch')
+    config_path = "{}/{}.conf".format(get_configs_dir(), "elasticsearch")
     if hosts:
         context = {"servers": json.dumps(hosts)}
-        input_config = render_template(template, context) + \
-            render_extra_options("inputs", "elasticsearch")
-        hookenv.log("Updating {} plugin config file".format('elasticsearch'))
-        host.write_file(config_path, input_config.encode('utf-8'))
-        set_flag('plugins.elasticsearch.configured')
+        input_config = render_template(template, context) + render_extra_options(
+            "inputs", "elasticsearch"
+        )
+        hookenv.log("Updating {} plugin config file".format("elasticsearch"))
+        host.write_file(config_path, input_config.encode("utf-8"))
+        set_flag("plugins.elasticsearch.configured")
     elif os.path.exists(config_path):
         os.unlink(config_path)
-        clear_flag('plugins.elasticsearch.configured')
-    set_flag('telegraf.needs_reload')
+        clear_flag("plugins.elasticsearch.configured")
+    set_flag("telegraf.needs_reload")
 
 
-@when('memcached.available')
+@when("memcached.available")
 def memcached_input(memcache):
     template = """
 [[inputs.memcached]]
   servers = {{ servers }}
 """
-    required_keys = ['host', 'port']
-    rels = hookenv.relations_of_type('memcached')
+    required_keys = ["host", "port"]
+    rels = hookenv.relations_of_type("memcached")
     addresses = []
     for rel in rels:
         if all([rel.get(key) for key in required_keys]):
-            addr = rel['host']
-            port = rel['port']
-            address = '{}:{}'.format(addr, port)
+            addr = rel["host"]
+            port = rel["port"]
+            address = "{}:{}".format(addr, port)
             addresses.append(address)
-    config_path = '{}/{}.conf'.format(get_configs_dir(), 'memcached')
+    config_path = "{}/{}.conf".format(get_configs_dir(), "memcached")
     if addresses:
         context = {"servers": json.dumps(addresses)}
-        input_config = render_template(template, context) + \
-            render_extra_options("inputs", "memcached")
-        hookenv.log("Updating {} plugin config file".format('memcached'))
-        host.write_file(config_path, input_config.encode('utf-8'))
-        set_flag('plugins.memcached.configured')
+        input_config = render_template(template, context) + render_extra_options(
+            "inputs", "memcached"
+        )
+        hookenv.log("Updating {} plugin config file".format("memcached"))
+        host.write_file(config_path, input_config.encode("utf-8"))
+        set_flag("plugins.memcached.configured")
     elif os.path.exists(config_path):
         os.unlink(config_path)
-    set_flag('telegraf.needs_reload')
+    set_flag("telegraf.needs_reload")
 
 
-@when('mongodb.database.available')
+@when("mongodb.database.available")
 def mongodb_input(mongodb):
     template = """
 [[inputs.mongodb]]
   servers = {{ servers }}
 """
-    rels = hookenv.relations_of_type('mongodb')
+    rels = hookenv.relations_of_type("mongodb")
     mongo_addresses = []
     for rel in rels:
-        addr = rel['private-address']
-        port = rel.get('port', None)
+        addr = rel["private-address"]
+        port = rel.get("port", None)
         if port:
-            mongo_address = '{}:{}'.format(addr, port)
+            mongo_address = "{}:{}".format(addr, port)
         else:
             mongo_address = addr
         mongo_addresses.append(mongo_address)
-    config_path = '{}/{}.conf'.format(get_configs_dir(), 'mongodb')
+    config_path = "{}/{}.conf".format(get_configs_dir(), "mongodb")
     if mongo_addresses:
         context = {"servers": json.dumps(mongo_addresses)}
-        input_config = render_template(template, context) + \
-            render_extra_options("inputs", "mongodb")
-        hookenv.log("Updating {} plugin config file".format('mongodb'))
-        host.write_file(config_path, input_config.encode('utf-8'))
-        set_flag('plugins.mongodb.configured')
+        input_config = render_template(template, context) + render_extra_options(
+            "inputs", "mongodb"
+        )
+        hookenv.log("Updating {} plugin config file".format("mongodb"))
+        host.write_file(config_path, input_config.encode("utf-8"))
+        set_flag("plugins.mongodb.configured")
     elif os.path.exists(config_path):
         os.unlink(config_path)
-    set_flag('telegraf.needs_reload')
+    set_flag("telegraf.needs_reload")
 
 
-@when('mysql.available')
+@when("mysql.available")
 def mysql_input(mysql):
     contexts = []
     for relid, relation in context.Relations()[mysql.relation_name].items():
         for unit, reldata in relation.items():
             hookenv.log("Available relations", level="DEBUG")
-            if reldata['private-address'] == hookenv.unit_private_ip():
+            if reldata["private-address"] == hookenv.unit_private_ip():
                 if mysql.connection_string():
-                    contexts.append({'host': mysql.host(),
-                                     'port': mysql.port(),
-                                     'user': mysql.user(),
-                                     'pass': mysql.password(),
-                                     'is_secure': 'false',   # TODO: provide config intf for this
-                                     'slave': reldata.get('slave', None)})
+                    contexts.append(
+                        {
+                            "host": mysql.host(),
+                            "port": mysql.port(),
+                            "user": mysql.user(),
+                            "pass": mysql.password(),
+                            "is_secure": "false",  # TODO: provide config intf for this
+                            "slave": reldata.get("slave", None),
+                        }
+                    )
                     break
 
     render_mysql_tmpl(contexts)
-    toggle_flag('plugins.mysql.configured', bool(contexts))
-    set_flag('telegraf.needs_reload')
+    toggle_flag("plugins.mysql.configured", bool(contexts))
+    set_flag("telegraf.needs_reload")
 
 
-@when('postgresql.database.connected')
+@when("postgresql.database.connected")
 def choose_postgresql_database():
     # We have no need for our own database. If we need to create
     # custom views, we can remove this handler. Or maybe it should
     # be configurable, so people can use telegraf to export custom
     # metrics about their data.
-    pgsql = endpoint_from_flag('postgresql.database.connected')
-    pgsql.set_database('postgres')
+    pgsql = endpoint_from_flag("postgresql.database.connected")
+    pgsql.set_database("postgres")
 
 
-@when('postgresql.database.connected')
-@when_not('postgresql.database.available')
+@when("postgresql.database.connected")
+@when_not("postgresql.database.available")
 def postgresql_waiting():
-    hookenv.status_set('waiting', 'Waiting for PostgreSQL relation')
+    hookenv.status_set("waiting", "Waiting for PostgreSQL relation")
 
 
-@when('postgresql.database.available',
-      'postgresql.database.changed')
+@when("postgresql.database.available", "postgresql.database.changed")
 def postgresql_input():
     # The subordinate may be connected to several services.
     contexts = []
     extra_options = get_extra_options()
-    pg_options = extra_options['inputs'].get('postgresql')
+    pg_options = extra_options["inputs"].get("postgresql")
     principal = hookenv.principal_unit()
 
     if principal not in hookenv.expected_related_units("postgresql"):
         return
 
-    pgsql = endpoint_from_flag('postgresql.database.available')
+    pgsql = endpoint_from_flag("postgresql.database.available")
     assert pgsql is not None
     for css in pgsql:
         cs = css.get(principal)
         if cs:
-            ver = css.version or '9.3'
-            contexts.append({'conn_str': str(cs),
-                             'server': cs.host,
-                             'replica': 'master' if cs == css.master else 'hot standby',
-                             'extra_options': pg_options,
-                             'version': ver,
-                             'pg10': LooseVersion(ver + '.0') >= LooseVersion('10.0')})
-            hookenv.status_set('maintenance', 'Monitoring PostgreSQL {} on {}'.format(css.version, principal))
+            ver = css.version or "9.3"
+            contexts.append(
+                {
+                    "conn_str": str(cs),
+                    "server": cs.host,
+                    "replica": "master" if cs == css.master else "hot standby",
+                    "extra_options": pg_options,
+                    "version": ver,
+                    "pg10": LooseVersion(ver + ".0") >= LooseVersion("10.0"),
+                }
+            )
+            hookenv.status_set(
+                "maintenance",
+                "Monitoring PostgreSQL {} on {}".format(css.version, principal),
+            )
     if not contexts:
-        hookenv.status_set('waiting', 'Waiting for PostgreSQL database on {}'.format(principal))
-        clear_flag('plugins.postgresql.configured')
+        hookenv.status_set(
+            "waiting", "Waiting for PostgreSQL database on {}".format(principal)
+        )
+        clear_flag("plugins.postgresql.configured")
         return
 
     render_postgresql_tmpl(contexts)
-    set_flag('plugins.postgresql.configured')
-    set_flag('telegraf.needs_reload')
+    set_flag("plugins.postgresql.configured")
+    set_flag("telegraf.needs_reload")
 
 
 def render_mysql_tmpl(contexts):
-    config_path = '{}/{}.conf'.format(get_configs_dir(), 'mysql')
+    config_path = "{}/{}.conf".format(get_configs_dir(), "mysql")
 
     if contexts:
         f = io.StringIO()
-        template = open(os.path.join(get_templates_dir(),
-                                     'mysql.tmpl'), 'r').read()
+        template = open(os.path.join(get_templates_dir(), "mysql.tmpl"), "r").read()
         for ctx in contexts:
             f.write(render_template(template, ctx))
             f.write(render_extra_options("inputs", "mysql"))
-        host.write_file(config_path, f.getvalue().encode('UTF-8'))
+        host.write_file(config_path, f.getvalue().encode("UTF-8"))
     elif os.path.exists(config_path):
         os.unlink(config_path)
 
 
 def render_postgresql_tmpl(contexts):
-    config_path = '{}/{}.conf'.format(get_configs_dir(), 'postgresql')
+    config_path = "{}/{}.conf".format(get_configs_dir(), "postgresql")
 
     if contexts:
         f = io.StringIO()
-        template = open(os.path.join(get_templates_dir(),
-                                     'postgresql.tmpl'), 'r').read()
+        template = open(
+            os.path.join(get_templates_dir(), "postgresql.tmpl"), "r"
+        ).read()
         for ctx in contexts:
             f.write(render_template(template, ctx))
-        host.write_file(config_path, f.getvalue().encode('UTF-8'))
+        host.write_file(config_path, f.getvalue().encode("UTF-8"))
     elif os.path.exists(config_path):
         os.unlink(config_path)
 
 
-@when('haproxy.available')
+@when("haproxy.available")
 def haproxy_input(haproxy):
     template = """
 [[inputs.haproxy]]
   servers = {{ servers }}
 """
-    rels = hookenv.relations_of_type('haproxy')
+    rels = hookenv.relations_of_type("haproxy")
     haproxy_addresses = []
     for rel in rels:
-        enabled = rel.get('enabled', False)
+        enabled = rel.get("enabled", False)
         # Juju gives us a string instead of a boolean, fix it
         if isinstance(enabled, str):
-            if enabled in ['y', 'yes', 'true', 't', 'on', 'True']:
+            if enabled in ["y", "yes", "true", "t", "on", "True"]:
                 enabled = True
             else:
                 enabled = False
         if not enabled:
             continue
-        addr = rel['private-address']
+        addr = rel["private-address"]
         if addr == hookenv.unit_private_ip():
             addr = "localhost"
-        port = rel['port']
-        user = rel['user']
-        password = rel.get('password', None)
+        port = rel["port"]
+        user = rel["user"]
+        password = rel.get("password", None)
         userpass = user
         if password:
             userpass += ":{}".format(password)
-        haproxy_address = 'http://{}@{}:{}'.format(userpass, addr, port)
+        haproxy_address = "http://{}@{}:{}".format(userpass, addr, port)
         haproxy_addresses.append(haproxy_address)
-    config_path = '{}/{}.conf'.format(get_configs_dir(), 'haproxy')
+    config_path = "{}/{}.conf".format(get_configs_dir(), "haproxy")
     if haproxy_addresses:
-        input_config = render_template(template, {"servers": json.dumps(haproxy_addresses)}) + \
-            render_extra_options("inputs", "haproxy")
-        hookenv.log("Updating {} plugin config file".format('haproxy'))
-        host.write_file(config_path, input_config.encode('utf-8'))
-        set_flag('plugins.haproxy.configured')
+        input_config = render_template(
+            template, {"servers": json.dumps(haproxy_addresses)}
+        ) + render_extra_options("inputs", "haproxy")
+        hookenv.log("Updating {} plugin config file".format("haproxy"))
+        host.write_file(config_path, input_config.encode("utf-8"))
+        set_flag("plugins.haproxy.configured")
     elif os.path.exists(config_path):
         os.unlink(config_path)
-    set_flag('telegraf.needs_reload')
+    set_flag("telegraf.needs_reload")
 
 
-@when('apache.available')
+@when("apache.available")
 def apache_input(apache):
     template = """
 [[inputs.apache]]
   urls = {{ urls }}
 """
-    config_path = '{}/{}.conf'.format(get_configs_dir(), 'apache')
-    port = '8080'
-    vhost = render(source='apache-server-status.tmpl',
-                   templates_dir=get_templates_dir(),
-                   target=None,
-                   context={'port': port})
-    relation_info = {"ports": port,
-                     "domain": "apache-status",
-                     "enabled": True,
-                     "site_config": vhost,
-                     "site_modules": "status"}
+    config_path = "{}/{}.conf".format(get_configs_dir(), "apache")
+    port = "8080"
+    vhost = render(
+        source="apache-server-status.tmpl",
+        templates_dir=get_templates_dir(),
+        target=None,
+        context={"port": port},
+    )
+    relation_info = {
+        "ports": port,
+        "domain": "apache-status",
+        "enabled": True,
+        "site_config": vhost,
+        "site_modules": "status",
+    }
     urls = []
-    rels = hookenv.relations_of_type('apache')
+    rels = hookenv.relations_of_type("apache")
     for rel in rels:
-        hookenv.relation_set(rel['__relid__'], relation_settings=relation_info)
-        addr = rel['private-address']
-        url = 'http://{}:{}/server-status?auto'.format(addr, port)
+        hookenv.relation_set(rel["__relid__"], relation_settings=relation_info)
+        addr = rel["private-address"]
+        url = "http://{}:{}/server-status?auto".format(addr, port)
         urls.append(url)
     if urls:
         context = {"urls": json.dumps(urls)}
-        input_config = render_template(template, context) + \
-            render_extra_options("inputs", "apache")
-        hookenv.log("Updating {} plugin config file".format('apache'))
-        host.write_file(config_path, input_config.encode('utf-8'))
-        set_flag('plugins.apache.configured')
+        input_config = render_template(template, context) + render_extra_options(
+            "inputs", "apache"
+        )
+        hookenv.log("Updating {} plugin config file".format("apache"))
+        host.write_file(config_path, input_config.encode("utf-8"))
+        set_flag("plugins.apache.configured")
     elif os.path.exists(config_path):
         os.unlink(config_path)
-    set_flag('telegraf.needs_reload')
+    set_flag("telegraf.needs_reload")
 
 
-@when('endpoint.redis.available')
+@when("endpoint.redis.available")
 def redis_input(redis):
     template = """
 [[inputs.redis]]
@@ -827,30 +895,34 @@ def redis_input(redis):
   # Until https://github.com/influxdata/telegraf/issues/5036 is fixed
   fielddrop = ["aof_last_bgrewrite_status","aof_last_write_status","maxmemory_policy","rdb_last_bgsave_status","used_memory_dataset_perc","used_memory_peak_perc"]
 """
-    config_path = '{}/{}.conf'.format(get_configs_dir(), 'redis')
+    config_path = "{}/{}.conf".format(get_configs_dir(), "redis")
 
-    rels = hookenv.relations_of_type('redis')
+    rels = hookenv.relations_of_type("redis")
     if rels:
         if len(rels) != 1:
-            hookenv.log("Unexpected number of units in the redis relation."
-                        "Expected 1, got {}".format(len(rels)), "WARNING")
+            hookenv.log(
+                "Unexpected number of units in the redis relation."
+                "Expected 1, got {}".format(len(rels)),
+                "WARNING",
+            )
 
         ctxt = {}
-        ctxt["host"] = rels[0]['host'].strip('"')
-        ctxt["port"] = rels[0]['port']
-        input_config = render_template(template, ctxt) + \
-            render_extra_options("inputs", "redis")
-        hookenv.log("Updating {} plugin config file".format('redis'))
-        host.write_file(config_path, input_config.encode('utf-8'))
-        set_flag('plugins.redis.configured')
+        ctxt["host"] = rels[0]["host"].strip('"')
+        ctxt["port"] = rels[0]["port"]
+        input_config = render_template(template, ctxt) + render_extra_options(
+            "inputs", "redis"
+        )
+        hookenv.log("Updating {} plugin config file".format("redis"))
+        host.write_file(config_path, input_config.encode("utf-8"))
+        set_flag("plugins.redis.configured")
     elif os.path.exists(config_path):
         os.unlink(config_path)
-        clear_flag('plugins.redis.configured')
+        clear_flag("plugins.redis.configured")
 
-    set_flag('telegraf.needs_reload')
+    set_flag("telegraf.needs_reload")
 
 
-@when('endpoint.sentry.joined')
+@when("endpoint.sentry.joined")
 def sentry_input(sentry):
     template = """
 [[inputs.statsd]]
@@ -861,24 +933,25 @@ def sentry_input(sentry):
   delete_sets = false
   delete_timings = false
 """
-    config_path = '{}/{}.conf'.format(get_configs_dir(), 'sentry')
+    config_path = "{}/{}.conf".format(get_configs_dir(), "sentry")
 
-    rels = hookenv.relations_of_type('sentry')
+    rels = hookenv.relations_of_type("sentry")
     if rels:
         for rel in rels:
-            input_config = render_template(template, {}) + \
-                render_extra_options("inputs", "sentry")
-            hookenv.log("Updating {} plugin config file".format('sentry'))
-            host.write_file(config_path, input_config.encode('utf-8'))
-            set_flag('plugins.sentry.configured')
+            input_config = render_template(template, {}) + render_extra_options(
+                "inputs", "sentry"
+            )
+            hookenv.log("Updating {} plugin config file".format("sentry"))
+            host.write_file(config_path, input_config.encode("utf-8"))
+            set_flag("plugins.sentry.configured")
     elif os.path.exists(config_path):
         os.unlink(config_path)
-        clear_flag('plugins.sentry.configured')
+        clear_flag("plugins.sentry.configured")
 
-    set_flag('telegraf.needs_reload')
+    set_flag("telegraf.needs_reload")
 
 
-@when('exec.available')
+@when("exec.available")
 def exec_input(exec_rel):
     template = """
 {% for cmd in commands %}
@@ -898,52 +971,52 @@ def exec_input(exec_rel):
 
 {% endfor %}
 """
-    config_path = '{}/{}.conf'.format(get_configs_dir(), 'exec')
+    config_path = "{}/{}.conf".format(get_configs_dir(), "exec")
     commands = exec_rel.commands()
     if not commands:
         hookenv.log("No Commands defined in the exec relation, doing nothing.")
         return
     pre_proc_cmds = []
     for command in commands:
-        run_on_this_unit = command.pop('run_on_this_unit')
+        run_on_this_unit = command.pop("run_on_this_unit")
         if run_on_this_unit:
             pre_proc_cmds.append(command)
     if pre_proc_cmds:
-        input_config = render_template(template, {'commands': pre_proc_cmds})
-        hookenv.log("Updating {} plugin config file".format('exec'))
-        host.write_file(config_path, input_config.encode('utf-8'))
-        set_flag('plugins.exec.configured')
+        input_config = render_template(template, {"commands": pre_proc_cmds})
+        hookenv.log("Updating {} plugin config file".format("exec"))
+        host.write_file(config_path, input_config.encode("utf-8"))
+        set_flag("plugins.exec.configured")
     else:
         # if no commands, remove previous config
         if os.path.exists(config_path):
             os.unlink(config_path)
-    set_flag('telegraf.needs_reload')
+    set_flag("telegraf.needs_reload")
 
 
-@when_not('exec.available')
-@when('plugins.exec.configured')
+@when_not("exec.available")
+@when("plugins.exec.configured")
 def exec_input_departed():
-    config_path = '{}/{}.conf'.format(get_configs_dir(), 'exec')
-    rels = hookenv.relations_of_type('exec')
+    config_path = "{}/{}.conf".format(get_configs_dir(), "exec")
+    rels = hookenv.relations_of_type("exec")
     if not rels:
-        clear_flag('plugins.exec.configured')
+        clear_flag("plugins.exec.configured")
         if os.path.exists(config_path):
             os.unlink(config_path)
-        set_flag('telegraf.needs_reload')
+        set_flag("telegraf.needs_reload")
 
 
-@when('amqp.connected')
-@when_not('amqp.available')
+@when("amqp.connected")
+@when_not("amqp.available")
 def rabbitmq_input_setup(rabbitmq):
     # Requires management_plugin=true on the rabbitmq-server application.
     # vhost will not be used, but still needs to be requested.
-    username = vhost = 'telegraf-' + hookenv.local_unit().replace('/', '-')
+    username = vhost = "telegraf-" + hookenv.local_unit().replace("/", "-")
     rabbitmq.set_local(admin=True)
     rabbitmq.set_remote(admin=True)
     rabbitmq.request_access(username=username, vhost=vhost)
 
 
-@when('amqp.available')
+@when("amqp.available")
 def rabbitmq_input(rabbitmq):
     template = """
 [[inputs.rabbitmq]]
@@ -953,113 +1026,123 @@ def rabbitmq_input(rabbitmq):
   fielddrop = ["idle_since"]
 """
     addr = rabbitmq.private_address()
-    port = '15672'
+    port = "15672"
     username = rabbitmq.username()
     password = rabbitmq.password()
 
     if not (addr and username and password):
         return
 
-    config_path = '{}/{}.conf'.format(get_configs_dir(), 'rabbitmq')
-    input_config = render_template(template, {'server': addr, 'username': username, 'password': password, 'port': port})
+    config_path = "{}/{}.conf".format(get_configs_dir(), "rabbitmq")
+    input_config = render_template(
+        template,
+        {"server": addr, "username": username, "password": password, "port": port},
+    )
 
-    hookenv.log('Updating {} plugin config file'.format('rabbitmq'))
-    host.write_file(config_path, input_config.encode('utf-8'))
+    hookenv.log("Updating {} plugin config file".format("rabbitmq"))
+    host.write_file(config_path, input_config.encode("utf-8"))
 
-    set_flag('plugins.rabbitmq.configured')
-    set_flag('telegraf.needs_reload')
+    set_flag("plugins.rabbitmq.configured")
+    set_flag("telegraf.needs_reload")
 
 
-@when_not('amqp.available')
-@when('plugins.rabbitmq.configured')
+@when_not("amqp.available")
+@when("plugins.rabbitmq.configured")
 def rabbitmq_input_departed():
-    config_path = '{}/{}.conf'.format(get_configs_dir(), 'rabbitmq')
-    clear_flag('plugins.rabbitmq.configured')
+    config_path = "{}/{}.conf".format(get_configs_dir(), "rabbitmq")
+    clear_flag("plugins.rabbitmq.configured")
     if os.path.exists(config_path):
         os.unlink(config_path)
-    set_flag('telegraf.needs_reload')
+    set_flag("telegraf.needs_reload")
 
 
-@when('influxdb-api.available')
+@when("influxdb-api.available")
 def influxdb_api_output(influxdb):
-    required_keys = ['hostname', 'port', 'user', 'password']
-    rels = hookenv.relations_of_type('influxdb-api')
+    required_keys = ["hostname", "port", "user", "password"]
+    rels = hookenv.relations_of_type("influxdb-api")
     endpoints = []
     user = None
     password = None
     for rel in rels:
         if all([rel.get(key) for key in required_keys]):
-            endpoints.append("http://{}:{}".format(rel['hostname'], rel['port']))
+            endpoints.append("http://{}:{}".format(rel["hostname"], rel["port"]))
             if user is None:
-                user = rel['user']
+                user = rel["user"]
             if password is None:
-                password = rel['password']
-    config_path = '{}/{}.conf'.format(get_configs_dir(), 'influxdb-api')
+                password = rel["password"]
+    config_path = "{}/{}.conf".format(get_configs_dir(), "influxdb-api")
     if endpoints:
-        hookenv.log("Updating {} plugin config file".format('influxdb-api'))
-        content = render(source='influxdb-api.conf.tmpl', target=None,
-                         templates_dir=get_templates_dir(),
-                         context={'urls': json.dumps(endpoints),
-                                  'username': '{}'.format(user),
-                                  'password': '{}'.format(password)})
+        hookenv.log("Updating {} plugin config file".format("influxdb-api"))
+        content = render(
+            source="influxdb-api.conf.tmpl",
+            target=None,
+            templates_dir=get_templates_dir(),
+            context={
+                "urls": json.dumps(endpoints),
+                "username": "{}".format(user),
+                "password": "{}".format(password),
+            },
+        )
         extra_opts = render_extra_options("outputs", "influxdb")
-        host.write_file(config_path, '\n'.join([content, extra_opts]).encode('utf-8'))
-        set_flag('plugins.influxdb-api.configured')
+        host.write_file(config_path, "\n".join([content, extra_opts]).encode("utf-8"))
+        set_flag("plugins.influxdb-api.configured")
     elif os.path.exists(config_path):
         os.unlink(config_path)
-    set_flag('telegraf.needs_reload')
+    set_flag("telegraf.needs_reload")
 
 
-@when('prometheus-client.available')
+@when("prometheus-client.available")
 def prometheus_client(prometheus):
     template = """
 [[outputs.prometheus_client]]
   listen = "{{ listen }}"
 """
-    for relation_id in hookenv.relation_ids('prometheus-client'):
+    for relation_id in hookenv.relation_ids("prometheus-client"):
         # if juju 2.x+ then we'll attempt to get the network space address
         try:
-            hookenv.log('Network Info')
-            network_info = hookenv.network_get('prometheus-client', relation_id=relation_id)
+            hookenv.log("Network Info")
+            network_info = hookenv.network_get(
+                "prometheus-client", relation_id=relation_id
+            )
             hookenv.log(network_info)
-            if 'ingress-addresses' in network_info:
-                ip_addr = network_info.get('ingress-addresses')[0]
+            if "ingress-addresses" in network_info:
+                ip_addr = network_info.get("ingress-addresses")[0]
             else:
-                ip_addr = hookenv.network_get_primary_address('prometheus-client')
+                ip_addr = hookenv.network_get_primary_address("prometheus-client")
         except NotImplementedError:
             # if that fails, just let prometheus.configure(...) do it's default
             ip_addr = None
         if get_prometheus_port():
             hookenv.log("Prometheus configured globally, skipping plugin setup")
-            prometheus.configure(get_prometheus_port(),
-                                 hostname=ip_addr,
-                                 private_address=ip_addr)
-            set_flag('prometheus-client.configured')
+            prometheus.configure(
+                get_prometheus_port(), hostname=ip_addr, private_address=ip_addr
+            )
+            set_flag("prometheus-client.configured")
             # bail out, nothing more need to be configured here
             return
         port = 9126
         extra_options = get_extra_options()
-        options = extra_options['outputs'].get('prometheus-client', {})
-        listen = options.pop('listen', None)
+        options = extra_options["outputs"].get("prometheus-client", {})
+        listen = options.pop("listen", None)
         if listen is not None:
-            hookenv.log("Configuring prometheus_client plugin to listen on: '{}'".format(listen))
+            hookenv.log(
+                "Configuring prometheus_client plugin to listen on: '{}'".format(listen)
+            )
             port = int(listen.split(":", 1)[1])
         else:
             listen = ":{}".format(port)
         check_prometheus_port("prometheus_output", port)
-        prometheus.configure(port,
-                             hostname=ip_addr,
-                             private_address=ip_addr)
-        config_path = '{}/{}.conf'.format(get_configs_dir(), 'prometheus-client')
-        hookenv.log("Updating {} plugin config file".format('prometheus-client'))
+        prometheus.configure(port, hostname=ip_addr, private_address=ip_addr)
+        config_path = "{}/{}.conf".format(get_configs_dir(), "prometheus-client")
+        hookenv.log("Updating {} plugin config file".format("prometheus-client"))
         context = {"listen": listen}
-        content = render_template(template, context) + \
-            render_extra_options("outputs", "prometheus_client",
-                                 extra_options=extra_options)
-        host.write_file(config_path, content.encode('utf-8'))
-        set_flag('plugins.prometheus-client.configured')
-        set_flag('telegraf.needs_reload')
-        set_flag('prometheus-client.configured')
+        content = render_template(template, context) + render_extra_options(
+            "outputs", "prometheus_client", extra_options=extra_options
+        )
+        host.write_file(config_path, content.encode("utf-8"))
+        set_flag("plugins.prometheus-client.configured")
+        set_flag("telegraf.needs_reload")
+        set_flag("prometheus-client.configured")
 
 
 def convert_days(time_string):
@@ -1070,91 +1153,98 @@ def convert_days(time_string):
     Not included, months and years, because the number of days in each changes.
     Also not included, seconds.
     """
-    days = re.search(r'(\d+)d$', time_string)
+    days = re.search(r"(\d+)d$", time_string)
     if days:
         return days.group(1)
-    weeks = re.search(r'(\d+)w$', time_string)
+    weeks = re.search(r"(\d+)w$", time_string)
     if weeks:
         days = int(weeks.group(1)) * 7
         return str(days)
-    hours = re.search(r'(\d+)h$', time_string)
+    hours = re.search(r"(\d+)h$", time_string)
     if hours:
         days = int(hours.group(1)) / 24
         return str(days)
-    mins = re.search(r'(\d+)m$', time_string)
+    mins = re.search(r"(\d+)m$", time_string)
     if mins:
         days = int(hours.group(1)) / 24 * 60
         return str(days)
 
 
-@when('prometheus-rules.available')
+@when("prometheus-rules.available")
 def render_prometheus_rules(prometheus_rules):
     # Send a list of rules for alerting to Prometheus
     config = hookenv.config()
-    unit_name = os.environ.get('JUJU_PRINCIPAL_UNIT')
-    lead_time = config.get('lead_time')
-    context = {'hostname': socket.gethostname(),
-               'cpu_idle': config.get('cpu_idle'),
-               'wait_time': config.get('wait_time'),
-               'lead_time': lead_time,
-               'lead_days': convert_days(lead_time),
-               'prometheus_context': config.get('prometheus_context'),
-               'unit_name': unit_name,
-               'application_name': unit_name.split('/')[0],
-               }
+    unit_name = os.environ.get("JUJU_PRINCIPAL_UNIT")
+    lead_time = config.get("lead_time")
+    context = {
+        "hostname": socket.gethostname(),
+        "cpu_idle": config.get("cpu_idle"),
+        "wait_time": config.get("wait_time"),
+        "lead_time": lead_time,
+        "lead_days": convert_days(lead_time),
+        "prometheus_context": config.get("prometheus_context"),
+        "unit_name": unit_name,
+        "application_name": unit_name.split("/")[0],
+    }
     formatted_rules = []
-    template_files = ['rule_cpu_usage.tmpl',
-                      'rule_disk_predictive.tmpl',
-                      'rule_mem_starvation.tmpl',
-                      ]
+    template_files = [
+        "rule_cpu_usage.tmpl",
+        "rule_disk_predictive.tmpl",
+        "rule_mem_starvation.tmpl",
+    ]
     for template_file in template_files:
-        with open(os.path.join(get_templates_dir(), template_file), 'r') as fd:
+        with open(os.path.join(get_templates_dir(), template_file), "r") as fd:
             formatted_rules.append(render_template(fd.read(), context))
     prometheus_rules.configure("\n".join(formatted_rules))
 
 
-@when_not('prometheus-client.available')
-@when('plugins.prometheus-client.configured')
+@when_not("prometheus-client.available")
+@when("plugins.prometheus-client.configured")
 def prometheus_client_departed():
     hookenv.log("prometheus-client relation not available")
-    config_path = '{}/{}.conf'.format(get_configs_dir(), 'prometheus-client')
-    rels = hookenv.relations_of_type('prometheus-client')
+    config_path = "{}/{}.conf".format(get_configs_dir(), "prometheus-client")
+    rels = hookenv.relations_of_type("prometheus-client")
     if not rels and os.path.exists(config_path):
-        hookenv.log("Deleting {} plugin config file".format('prometheus-client'))
+        hookenv.log("Deleting {} plugin config file".format("prometheus-client"))
         os.unlink(config_path)
-        clear_flag('plugins.prometheus-client.configured')
-        set_flag('telegraf.needs_reload')
-    clear_flag('prometheus-client.configured')
+        clear_flag("plugins.prometheus-client.configured")
+        set_flag("telegraf.needs_reload")
+    clear_flag("prometheus-client.configured")
 
 
-@when('prometheus-client.configured',
-      'endpoint.dashboards.joined',
-      'leadership.is_leader')
-@when_not('grafana.configured')
+@when(
+    "prometheus-client.configured", "endpoint.dashboards.joined", "leadership.is_leader"
+)
+@when_not("grafana.configured")
 def register_grafana_dashboard():
-    grafana = endpoint_from_flag('endpoint.dashboards.joined')
-    hookenv.log('Loading grafana dashboard', level=hookenv.DEBUG)
+    grafana = endpoint_from_flag("endpoint.dashboards.joined")
+    hookenv.log("Loading grafana dashboard", level=hookenv.DEBUG)
     dashboard = _load_grafana_dashboard()
     dashboard_dict = json.loads(dashboard)
-    hookenv.log('Rendered dashboard dict:\n{}'.format(dashboard_dict), level=hookenv.DEBUG)
+    hookenv.log(
+        "Rendered dashboard dict:\n{}".format(dashboard_dict), level=hookenv.DEBUG
+    )
     grafana.register_dashboard(name=GRAFANA_DASHBOARD_NAME, dashboard=dashboard_dict)
     hookenv.log('Grafana dashboard "{}" registered.'.format(GRAFANA_DASHBOARD_NAME))
-    set_flag('grafana.configured')
+    set_flag("grafana.configured")
 
 
 def _load_grafana_dashboard():
     prometheus_datasource = "{} - Juju generated source".format(
-        hookenv.config().get('prometheus_datasource', 'prometheus'))
+        hookenv.config().get("prometheus_datasource", "prometheus")
+    )
     dashboard_context = dict(datasource=prometheus_datasource)
     # TODO: Figure out if metrics exist and then set bools accordingly.
     # For now, setting bools to true.
-    dashboard_context['bonds_enabled'] = True
-    dashboard_context['bcache_enabled'] = True
-    dashboard_context['conntrack_enabled'] = True
-    return render_custom(source=GRAFANA_DASHBOARD_TELEGRAF_FILE_NAME,
-                         render_context=dashboard_context,
-                         variable_start_string="<<",
-                         variable_end_string=">>")
+    dashboard_context["bonds_enabled"] = True
+    dashboard_context["bcache_enabled"] = True
+    dashboard_context["conntrack_enabled"] = True
+    return render_custom(
+        source=GRAFANA_DASHBOARD_TELEGRAF_FILE_NAME,
+        render_context=dashboard_context,
+        variable_start_string="<<",
+        variable_end_string=">>",
+    )
 
 
 # This isn't exposed in charmhelpers: https://github.com/juju/charm-helpers/issues/367
@@ -1167,51 +1257,63 @@ def render_custom(source, render_context, **parameters):
 
     returns the rendered template content
     """
-    template_folder = os.path.join(hookenv.charm_dir(), 'templates/dashboards/grafana')
+    template_folder = os.path.join(hookenv.charm_dir(), "templates/dashboards/grafana")
     environment = Environment(loader=FileSystemLoader(template_folder), **parameters)
     try:
         template = environment.get_template(source)
     except exceptions.TemplateNotFound as e:
-        hookenv.log('Could not load template {} from {}'.format(source, template_folder))
+        hookenv.log(
+            "Could not load template {} from {}".format(source, template_folder)
+        )
         raise e
     return template.render(render_context)
 
 
-@when('endpoint.dashboards.departed',
-      'grafana.configured')
+@when("endpoint.dashboards.departed", "grafana.configured")
 def unregister_grafana_dashboard():
-    clear_flag('grafana.configured')
+    clear_flag("grafana.configured")
 
 
-@when('endpoint.dashboards.failed',
-      'leadership.is_leader')
+@when("endpoint.dashboards.failed", "leadership.is_leader")
 def grafana_dashboard_import_failed():
-    grafana = endpoint_from_flag('endpoint.dashboards.failed')
+    grafana = endpoint_from_flag("endpoint.dashboards.failed")
     for failed_import in grafana.failed_imports:
         hookenv.log(
             message='Grafana dashboard "{}" import failed with: {}'.format(
-                failed_import.name, failed_import.reason),
-            level=hookenv.ERROR
+                failed_import.name, failed_import.reason
+            ),
+            level=hookenv.ERROR,
         )
-    clear_flag('grafana.configured')
+    clear_flag("grafana.configured")
 
 
-@when('telegraf.needs_reload')
+@when("telegraf.needs_reload")
 def start_or_restart():
-    states = sorted([k for k in get_states().keys()
-                     if k.startswith('plugins') or k.startswith('extra_plugins')])
+    states = sorted(
+        [
+            k
+            for k in get_states().keys()
+            if k.startswith("plugins") or k.startswith("extra_plugins")
+        ]
+    )
 
     service = get_service()
     config_files_changed = helpers.any_file_changed(list_config_files())
-    active_plugins_changed = helpers.data_changed('active_plugins', states or '')
-    if not host.service_running(service) \
-            or config_files_changed or active_plugins_changed:
+    active_plugins_changed = helpers.data_changed("active_plugins", states or "")
+    if (
+        not host.service_running(service)
+        or config_files_changed
+        or active_plugins_changed
+    ):
         hookenv.log("Restarting telegraf")
         host.service_restart(service)
     else:
-        hookenv.log("Not restarting: active_plugins_changed={} | "
-                    "config_files_changed={}".format(active_plugins_changed,
-                                                     config_files_changed))
+        hookenv.log(
+            "Not restarting: active_plugins_changed={} | "
+            "config_files_changed={}".format(
+                active_plugins_changed, config_files_changed
+            )
+        )
 
     # Give telegraf time to restart.
     timeout = time.time() + 15
@@ -1219,12 +1321,10 @@ def start_or_restart():
         time.sleep(0.1)
 
     if host.service_running(service):
-        hookenv.status_set('active',
-                           'Monitoring {}'.format(get_remote_unit_name()))
-        clear_flag('telegraf.needs_reload')
+        hookenv.status_set("active", "Monitoring {}".format(get_remote_unit_name()))
+        clear_flag("telegraf.needs_reload")
     else:
-        hookenv.status_set('blocked',
-                           'Telegraf failed to start. Check config.')
+        hookenv.status_set("blocked", "Telegraf failed to start. Check config.")
 
 
 def is_bcache():
@@ -1232,25 +1332,24 @@ def is_bcache():
     return true if bcache is present, and this is not a container
     """
     container = is_container()
-    return (os.path.exists("/sys/fs/bcache") and not container)
+    return os.path.exists("/sys/fs/bcache") and not container
 
 
-@hook('update-status')
+@hook("update-status")
 def update_status():
     changed = charms.reactive.helpers.is_data_changed(
-        'detect_changes',
-        get_base_inputs(),
-        hash_type='sha256')
+        "detect_changes", get_base_inputs(), hash_type="sha256"
+    )
     if changed:
-        clear_flag('telegraf.configured')
-        clear_flag('telegraf.apt.configured')
-        clear_flag('telegraf.snap.configured')
+        clear_flag("telegraf.configured")
+        clear_flag("telegraf.apt.configured")
+        clear_flag("telegraf.snap.configured")
 
 
-@when('nrpe-external-master.available')
-@when('telegraf.installed')
-@when('telegraf.configured')
-@when_not('telegraf.nagios-setup.complete')
+@when("nrpe-external-master.available")
+@when("telegraf.installed")
+@when("telegraf.configured")
+@when_not("telegraf.nagios-setup.complete")
 def configure_nagios(nagios):
     """Configure nagios process check.
     the flag 'telegraf.nagios-setup.complete' is reset at the moment config is
@@ -1262,9 +1361,9 @@ def configure_nagios(nagios):
 
     # use charmhelpers to create a process check
     nrpe_setup.add_check(
-        'telegraf_http',
-        'Telegraf HTTP check',
-        'check_http -I 127.0.0.1 -p {} -u /metrics'.format(get_prometheus_port())
+        "telegraf_http",
+        "Telegraf HTTP check",
+        "check_http -I 127.0.0.1 -p {} -u /metrics".format(get_prometheus_port()),
     )
     nrpe_setup.write()
-    set_flag('telegraf.nagios-setup.complete')
+    set_flag("telegraf.nagios-setup.complete")
diff --git a/src/tests/functional/tests/test_telegraf.py b/src/tests/functional/tests/test_telegraf.py
index e9341e7..1b80661 100644
--- a/src/tests/functional/tests/test_telegraf.py
+++ b/src/tests/functional/tests/test_telegraf.py
@@ -48,26 +48,30 @@ class BaseTelegrafTest(unittest.TestCase):
 
 
 class TestTelegraf(BaseTelegrafTest):
-
     def check_re_pattern(self, re_pattern, text):
-        logging.info('checking metrics %s', re_pattern)
+        logging.info("checking metrics %s", re_pattern)
         # findall returns a list, [] when no match
         self.assertTrue(re.findall(re_pattern, text, flags=re.M))
 
     def test_01_service(self):
-        principal_units = (model.get_units(app)
-                           for app in juju.get_principle_applications(self.application_name))
+        principal_units = (
+            model.get_units(app)
+            for app in juju.get_principle_applications(self.application_name)
+        )
         for unit in it.chain.from_iterable(principal_units):
             if not unit.public_address:
                 continue
-            url = "http://{}:{}/metrics".format(unit.public_address, DEFAULT_TELEGRAF_EXPORTER_PORT)
+            url = "http://{}:{}/metrics".format(
+                unit.public_address, DEFAULT_TELEGRAF_EXPORTER_PORT
+            )
             for retry in range(DEFAULT_RETRIES):
                 resp = requests.get(url, timeout=DEFAULT_HTTPGET_TIMEOUT)
                 self.assertEqual(resp.status_code, 200)
 
-                if ((unit.name.startswith("postgresql/") and
-                     "postgresql_blks_hit" not in resp.text) or
-                        "cpu_usage_idle" not in resp.text):
+                if (
+                    unit.name.startswith("postgresql/")
+                    and "postgresql_blks_hit" not in resp.text
+                ) or "cpu_usage_idle" not in resp.text:
                     time.sleep(DEFAULT_RETRIES_TIMEOUT)
                     continue
 
@@ -79,12 +83,12 @@ class TestTelegraf(BaseTelegrafTest):
 
                 # check metrics are available
                 re_patterns = [
-                    r'^sockstat_',
-                    r'^sockstat6_',
-                    r'^softnet_stat',
-                    r'^buddyinfo_',
-                    r'^zoneinfo_',
-                    r'^processes_',
+                    r"^sockstat_",
+                    r"^sockstat6_",
+                    r"^softnet_stat",
+                    r"^buddyinfo_",
+                    r"^zoneinfo_",
+                    r"^processes_",
                 ]
                 for re_pattern in re_patterns:
                     self.check_re_pattern(re_pattern, text)
@@ -97,34 +101,52 @@ class TestTelegraf(BaseTelegrafTest):
 
     def test_02_telegraf_logfile(self):
         """Check logfile parameter exists in ${BASE_DIR}/telegraf.conf."""
-        install_method = model.get_application_config('telegraf')['install_method']['value']
-        if install_method == 'deb':
+        install_method = model.get_application_config("telegraf")["install_method"][
+            "value"
+        ]
+        if install_method == "deb":
             telegraf_conf = DEB_TELEGRAF_CONF
         else:
             telegraf_conf = SNAP_TELEGRAF_CONF
         cmd = "cat {}".format(telegraf_conf)
         response = model.run_on_unit(self.lead_unit_name, cmd)
         if response["Code"] != "0":
-            self.fail("test_02_telegraf_logfile: could not read file {}".format(telegraf_conf))
+            self.fail(
+                "test_02_telegraf_logfile: could not read file {}".format(telegraf_conf)
+            )
 
         for line in response["Stdout"].splitlines():
             if line.strip() == 'logfile = "/var/log/telegraf/telegraf.log"':
                 logging.info("test_02_telegraf_logfile: logfile config parameter found")
                 return
 
-        self.fail("test_02_telegraf_logfile: logfile parameter not found in {}".format(telegraf_conf))
+        self.fail(
+            "test_02_telegraf_logfile: logfile parameter not found in {}".format(
+                telegraf_conf
+            )
+        )
 
     def test_03_system_service(self):
         """Check that the right service is running, e.g. either the deb's or the snap's."""
-        install_method = model.get_application_config('telegraf')['install_method']['value']
-        services = {'deb': 'telegraf', 'snap': 'snap.telegraf.telegraf'}
+        install_method = model.get_application_config("telegraf")["install_method"][
+            "value"
+        ]
+        services = {"deb": "telegraf", "snap": "snap.telegraf.telegraf"}
         for method in services.keys():
             service = services[method]
             cmd = "service {} status".format(service)
             response = model.run_on_unit(self.lead_unit_name, cmd)
             if install_method == method and response["Code"] != "0":
-                self.fail("test_03_system_service: service {} should be running on {} but is not. "
-                          "install_method is {}.".format(service, self.lead_unit_name, install_method))
+                self.fail(
+                    "test_03_system_service: service {} should be running on {} but is not. "
+                    "install_method is {}.".format(
+                        service, self.lead_unit_name, install_method
+                    )
+                )
             elif install_method != method and response["Code"] == "0":
-                self.fail("test_03_system_service: service {}  is running on {} but shouldn't. "
-                          "install_method is {}.".format(service, self.lead_unit_name, install_method))
+                self.fail(
+                    "test_03_system_service: service {}  is running on {} but shouldn't. "
+                    "install_method is {}.".format(
+                        service, self.lead_unit_name, install_method
+                    )
+                )
diff --git a/src/tests/unit/__init__.py b/src/tests/unit/__init__.py
index 03acc40..28e9795 100644
--- a/src/tests/unit/__init__.py
+++ b/src/tests/unit/__init__.py
@@ -1,2 +1,3 @@
 import sys
-sys.path.append('.')
+
+sys.path.append(".")
diff --git a/src/tests/unit/test_mysql.py b/src/tests/unit/test_mysql.py
index 242fc37..27f206d 100644
--- a/src/tests/unit/test_mysql.py
+++ b/src/tests/unit/test_mysql.py
@@ -21,27 +21,26 @@ from unittest.mock import ANY, MagicMock, patch, sentinel
 
 # Mock layer modules
 import charms
+
 promreg = MagicMock()
 charms.promreg = promreg
-sys.modules['charms.promreg'] = promreg
+sys.modules["charms.promreg"] = promreg
 import reactive
 
 
 class TestMySQL(unittest.TestCase):
-    @patch('reactive.telegraf.render_mysql_tmpl')
-    @patch('reactive.telegraf.toggle_flag')
-    @patch('charmhelpers.core.hookenv.unit_private_ip')
-    @patch('charmhelpers.context.Relations')
-    def test_mysql_input(self, relations, unit_private_ip, toggle_flag,
-                         render):
+    @patch("reactive.telegraf.render_mysql_tmpl")
+    @patch("reactive.telegraf.toggle_flag")
+    @patch("charmhelpers.core.hookenv.unit_private_ip")
+    @patch("charmhelpers.context.Relations")
+    def test_mysql_input(self, relations, unit_private_ip, toggle_flag, render):
         mysql = MagicMock()
-        mysql.relation_name = 'dbrel'
+        mysql.relation_name = "dbrel"
         relation = MagicMock()
-        relations()[mysql.relation_name].items.return_value = [('dbrel:1',
-                                                                relation)]
-        relation.items.return_value = [('mysql/0',
-                                        {'private-address': sentinel.priv_ip,
-                                         'slave': 'standalone'})]
+        relations()[mysql.relation_name].items.return_value = [("dbrel:1", relation)]
+        relation.items.return_value = [
+            ("mysql/0", {"private-address": sentinel.priv_ip, "slave": "standalone"})
+        ]
 
         unit_private_ip.return_value = sentinel.priv_ip
 
@@ -49,51 +48,57 @@ class TestMySQL(unittest.TestCase):
 
         reactive.telegraf.mysql_input(mysql)
 
-        render.assert_called_once_with([{'host': mysql.host(),
-                                         'port': mysql.port(),
-                                         'user': mysql.user(),
-                                         'pass': mysql.password(),
-                                         'is_secure': 'false',
-                                         'slave': 'standalone'
-                                         }])
-        toggle_flag.assert_called_once_with('plugins.mysql.configured', True)
+        render.assert_called_once_with(
+            [
+                {
+                    "host": mysql.host(),
+                    "port": mysql.port(),
+                    "user": mysql.user(),
+                    "pass": mysql.password(),
+                    "is_secure": "false",
+                    "slave": "standalone",
+                }
+            ]
+        )
+        toggle_flag.assert_called_once_with("plugins.mysql.configured", True)
 
-    @patch('reactive.telegraf.render_extra_options')
-    @patch('charmhelpers.core.host.write_file')
-    @patch('reactive.telegraf.get_templates_dir')
-    @patch('reactive.telegraf.get_base_dir')
-    def test_render_mysql_tmpl(self, get_base_dir, get_templates_dir, write_file,
-                               extra_options):
-        get_base_dir.return_value = '/etc/telegraf'
+    @patch("reactive.telegraf.render_extra_options")
+    @patch("charmhelpers.core.host.write_file")
+    @patch("reactive.telegraf.get_templates_dir")
+    @patch("reactive.telegraf.get_base_dir")
+    def test_render_mysql_tmpl(
+        self, get_base_dir, get_templates_dir, write_file, extra_options
+    ):
+        get_base_dir.return_value = "/etc/telegraf"
         get_templates_dir.return_value = os.path.join(
-            os.path.dirname(__file__), '../..', 'templates')
-        extra_options.return_value = ''
-
-        reactive.telegraf.render_mysql_tmpl([{'host': 'localhost',
-                                              'port': '3306',
-                                              'user': 'test',
-                                              'pass': 'tester',
-                                              'is_secure': 'false',
-                                              'slave': 'standalone'
-                                              }])
+            os.path.dirname(__file__), "../..", "templates"
+        )
+        extra_options.return_value = ""
 
-        write_file.assert_called_once_with(
-            '/etc/telegraf/telegraf.d/mysql.conf', ANY
+        reactive.telegraf.render_mysql_tmpl(
+            [
+                {
+                    "host": "localhost",
+                    "port": "3306",
+                    "user": "test",
+                    "pass": "tester",
+                    "is_secure": "false",
+                    "slave": "standalone",
+                }
+            ]
         )
 
-    @patch('os.unlink')
-    @patch('os.path.exists')
-    @patch('reactive.telegraf.get_base_dir')
+        write_file.assert_called_once_with("/etc/telegraf/telegraf.d/mysql.conf", ANY)
+
+    @patch("os.unlink")
+    @patch("os.path.exists")
+    @patch("reactive.telegraf.get_base_dir")
     def test_render_mysql_tmpl_no_context(self, get_base_dir, exists, unlink):
         exists.return_value = False
-        get_base_dir.return_value = '/etc/telegraf'
+        get_base_dir.return_value = "/etc/telegraf"
         reactive.telegraf.render_mysql_tmpl([])
-        exists.assert_called_once_with(
-            '/etc/telegraf/telegraf.d/mysql.conf'
-        )
+        exists.assert_called_once_with("/etc/telegraf/telegraf.d/mysql.conf")
         self.assertFalse(unlink.called)
         exists.return_value = True
         reactive.telegraf.render_mysql_tmpl([])
-        unlink.assert_called_once_with(
-            '/etc/telegraf/telegraf.d/mysql.conf'
-        )
+        unlink.assert_called_once_with("/etc/telegraf/telegraf.d/mysql.conf")
diff --git a/src/tests/unit/test_postgresql.py b/src/tests/unit/test_postgresql.py
index d831ef9..9192ea4 100644
--- a/src/tests/unit/test_postgresql.py
+++ b/src/tests/unit/test_postgresql.py
@@ -21,56 +21,69 @@ from unittest.mock import ANY, call, MagicMock, patch, sentinel
 
 # Mock layer modules
 import charms
+
 apt = MagicMock()
 layer = MagicMock()
 promreg = MagicMock()
 charms.apt = apt
 charms.layer = layer
 charms.promreg = promreg
-sys.modules['charms.apt'] = apt
-sys.modules['charms.layer'] = layer
-sys.modules['charms.promreg'] = promreg
+sys.modules["charms.apt"] = apt
+sys.modules["charms.layer"] = layer
+sys.modules["charms.promreg"] = promreg
 
 import reactive
 from reactive import telegraf
 
 
 class TestPostgreSQL(unittest.TestCase):
-    @patch('reactive.telegraf.endpoint_from_flag')
+    @patch("reactive.telegraf.endpoint_from_flag")
     def test_choose_postgresql_database(self, endpoint_from_flag):
         telegraf.choose_postgresql_database()
-        endpoint_from_flag.assert_called_once_with('postgresql.database.connected')
-        endpoint_from_flag().set_database.assert_called_once_with('postgres')
+        endpoint_from_flag.assert_called_once_with("postgresql.database.connected")
+        endpoint_from_flag().set_database.assert_called_once_with("postgres")
 
-    @patch('reactive.telegraf.hookenv.principal_unit')
-    @patch('reactive.telegraf.hookenv.expected_related_units')
-    @patch('reactive.telegraf.endpoint_from_flag')
-    @patch('reactive.telegraf.get_extra_options')
+    @patch("reactive.telegraf.hookenv.principal_unit")
+    @patch("reactive.telegraf.hookenv.expected_related_units")
+    @patch("reactive.telegraf.endpoint_from_flag")
+    @patch("reactive.telegraf.get_extra_options")
     def test_postgresql_input_principal_not_postgresql(
-            self, get_extra_options, endpoint_from_flag, expected_related_units, principal_unit):
+        self,
+        get_extra_options,
+        endpoint_from_flag,
+        expected_related_units,
+        principal_unit,
+    ):
         """Skip execution when the principal unit is not of type postgresql-charm."""
         principal_unit.return_value = sentinel.principal_unit
         expected_related_units.return_value = []
         reactive.telegraf.postgresql_input()
         endpoint_from_flag.assert_not_called()
 
-    @patch('reactive.telegraf.set_flag')
-    @patch('reactive.telegraf.hookenv.principal_unit')
-    @patch('reactive.telegraf.hookenv.expected_related_units')
-    @patch('reactive.telegraf.endpoint_from_flag')
-    @patch('reactive.telegraf.get_extra_options')
-    @patch('reactive.telegraf.render_postgresql_tmpl')
-    def test_postgresql_input(self, render, get_extra_options, endpoint_from_flag, expected_related_units,
-                              principal_unit, set_flag):
+    @patch("reactive.telegraf.set_flag")
+    @patch("reactive.telegraf.hookenv.principal_unit")
+    @patch("reactive.telegraf.hookenv.expected_related_units")
+    @patch("reactive.telegraf.endpoint_from_flag")
+    @patch("reactive.telegraf.get_extra_options")
+    @patch("reactive.telegraf.render_postgresql_tmpl")
+    def test_postgresql_input(
+        self,
+        render,
+        get_extra_options,
+        endpoint_from_flag,
+        expected_related_units,
+        principal_unit,
+        set_flag,
+    ):
         principal_unit.return_value = sentinel.principal_unit
         expected_related_units.return_value = [principal_unit.return_value]
 
-        cs = MagicMock()   # ConnectionString from interface:pgsql
-        cs.__str__.return_value = 'libpq connection string'
+        cs = MagicMock()  # ConnectionString from interface:pgsql
+        cs.__str__.return_value = "libpq connection string"
         cs.host = sentinel.host
 
         css = MagicMock()  # ConnectionStrings from interface:pgsql
-        css.version = '10'
+        css.version = "10"
         css.get.return_value = cs
         css.master = cs
 
@@ -78,64 +91,76 @@ class TestPostgreSQL(unittest.TestCase):
         pgsql.__iter__.return_value = [css]
         endpoint_from_flag.return_value = pgsql
 
-        get_extra_options.return_value = {'inputs': {}}
+        get_extra_options.return_value = {"inputs": {}}
 
         reactive.telegraf.postgresql_input()
 
-        endpoint_from_flag.assert_called_once_with('postgresql.database.available')
+        endpoint_from_flag.assert_called_once_with("postgresql.database.available")
         css.get.assert_called_once_with(sentinel.principal_unit)
-        render.assert_called_once_with([{'replica': 'master',
-                                         'conn_str': 'libpq connection string',
-                                         'server': sentinel.host,
-                                         'extra_options': None,
-                                         'version': '10',
-                                         'pg10': True}])
-        set_flag.assert_has_calls([call('plugins.postgresql.configured'), call('telegraf.needs_reload')])
-
-    @patch('charmhelpers.core.host.write_file')
-    @patch('reactive.telegraf.get_templates_dir')
-    @patch('reactive.telegraf.get_base_dir')
+        render.assert_called_once_with(
+            [
+                {
+                    "replica": "master",
+                    "conn_str": "libpq connection string",
+                    "server": sentinel.host,
+                    "extra_options": None,
+                    "version": "10",
+                    "pg10": True,
+                }
+            ]
+        )
+        set_flag.assert_has_calls(
+            [call("plugins.postgresql.configured"), call("telegraf.needs_reload")]
+        )
+
+    @patch("charmhelpers.core.host.write_file")
+    @patch("reactive.telegraf.get_templates_dir")
+    @patch("reactive.telegraf.get_base_dir")
     def test_render_postgresql_tmpl(self, get_base_dir, get_templates_dir, write_file):
         get_templates_dir.return_value = os.path.join(
-            os.path.dirname(__file__), '../..', 'templates')
-        get_base_dir.return_value = '/etc/telegraf'
+            os.path.dirname(__file__), "../..", "templates"
+        )
+        get_base_dir.return_value = "/etc/telegraf"
 
-        reactive.telegraf.render_postgresql_tmpl([
-            {'replica': 'master',
-             'conn_str': 'my_conn_str',
-             'server': 'my_server'},
-        ])
+        reactive.telegraf.render_postgresql_tmpl(
+            [{"replica": "master", "conn_str": "my_conn_str", "server": "my_server"},]
+        )
 
         write_file.assert_called_once_with(
-            '/etc/telegraf/telegraf.d/postgresql.conf', ANY
+            "/etc/telegraf/telegraf.d/postgresql.conf", ANY
         )
 
-    @patch('charmhelpers.core.host.write_file')
-    @patch('reactive.telegraf.get_templates_dir')
-    @patch('reactive.telegraf.get_base_dir')
-    def test_render_postgresql_tmpl_extra_options(self, get_base_dir, get_templates_dir,
-                                                  write_file):
+    @patch("charmhelpers.core.host.write_file")
+    @patch("reactive.telegraf.get_templates_dir")
+    @patch("reactive.telegraf.get_base_dir")
+    def test_render_postgresql_tmpl_extra_options(
+        self, get_base_dir, get_templates_dir, write_file
+    ):
         get_templates_dir.return_value = os.path.join(
-            os.path.dirname(__file__), '../..', 'templates')
-        get_base_dir.return_value = '/etc/telegraf'
+            os.path.dirname(__file__), "../..", "templates"
+        )
+        get_base_dir.return_value = "/etc/telegraf"
 
         pg_extra_opts = {
             "tagexclude": ["server"],
             "tagdrop": {"db": ["template*", "postgres", "telegraf"]},
         }
 
-        context = {'replica': 'master',
-                   'conn_str': 'my_conn_str',
-                   'server': 'my_server',
-                   'extra_options': pg_extra_opts}
+        context = {
+            "replica": "master",
+            "conn_str": "my_conn_str",
+            "server": "my_server",
+            "extra_options": pg_extra_opts,
+        }
         reactive.telegraf.render_postgresql_tmpl([context])
 
-        with open(os.path.join(telegraf.get_templates_dir(), 'postgresql.tmpl'),
-                  'r') as fd:
+        with open(
+            os.path.join(telegraf.get_templates_dir(), "postgresql.tmpl"), "r"
+        ) as fd:
             rendered = telegraf.render_template(fd.read(), context)
 
         write_file.assert_called_once_with(
-            '/etc/telegraf/telegraf.d/postgresql.conf', rendered.encode('UTF-8')
+            "/etc/telegraf/telegraf.d/postgresql.conf", rendered.encode("UTF-8")
         )
         # now check if what's there is the thing we actually expect
         expected = """[[inputs.postgresql_extensible]]
@@ -150,21 +175,17 @@ class TestPostgreSQL(unittest.TestCase):
     replica = "master"
 
 [[inputs.postgresql_extensible.query]]"""
-        self.assertEqual(rendered.split('\n')[3:15], expected.split('\n'))
+        self.assertEqual(rendered.split("\n")[3:15], expected.split("\n"))
 
-    @patch('os.unlink')
-    @patch('os.path.exists')
-    @patch('reactive.telegraf.get_base_dir')
+    @patch("os.unlink")
+    @patch("os.path.exists")
+    @patch("reactive.telegraf.get_base_dir")
     def test_render_postgresql_tmpl_no_context(self, get_base_dir, exists, unlink):
         exists.return_value = False
-        get_base_dir.return_value = '/etc/telegraf'
+        get_base_dir.return_value = "/etc/telegraf"
         reactive.telegraf.render_postgresql_tmpl([])
-        exists.assert_called_once_with(
-            '/etc/telegraf/telegraf.d/postgresql.conf'
-        )
+        exists.assert_called_once_with("/etc/telegraf/telegraf.d/postgresql.conf")
         self.assertFalse(unlink.called)
         exists.return_value = True
         reactive.telegraf.render_postgresql_tmpl([])
-        unlink.assert_called_once_with(
-            '/etc/telegraf/telegraf.d/postgresql.conf'
-        )
+        unlink.assert_called_once_with("/etc/telegraf/telegraf.d/postgresql.conf")
diff --git a/src/tests/unit/test_telegraf.py b/src/tests/unit/test_telegraf.py
index c21b4c2..1825fa6 100644
--- a/src/tests/unit/test_telegraf.py
+++ b/src/tests/unit/test_telegraf.py
@@ -37,29 +37,30 @@ from charmhelpers.core.templating import render
 
 # Mock layer modules
 import charms
+
 promreg = MagicMock()
 charms.promreg = promreg
-sys.modules['charms.promreg'] = promreg
+sys.modules["charms.promreg"] = promreg
 
 import reactive
 from reactive import telegraf
 
 UNIT_TESTS_DIR = os.path.dirname(os.path.abspath(__file__))
-UNIT_TESTS_DATA_DIR = os.path.join(UNIT_TESTS_DIR, 'data')
+UNIT_TESTS_DATA_DIR = os.path.join(UNIT_TESTS_DIR, "data")
 
 
 @pytest.fixture(autouse=True)
 def setup(monkeypatch, tmpdir):
-    monkeypatch.setitem(os.environ, 'JUJU_UNIT_NAME', 'telegraf/0')
-    monkeypatch.setitem(os.environ, 'JUJU_MODEL_NAME', 'telegraf-test-model')
-    monkeypatch.setattr(telegraf, 'get_remote_unit_name', lambda: 'remote-unit/0')
+    monkeypatch.setitem(os.environ, "JUJU_UNIT_NAME", "telegraf/0")
+    monkeypatch.setitem(os.environ, "JUJU_MODEL_NAME", "telegraf-test-model")
+    monkeypatch.setattr(telegraf, "get_remote_unit_name", lambda: "remote-unit/0")
     # mock this to avoid permission errors
-    monkeypatch.setattr(telegraf, 'update_sysstat_config_with_sdac_xall', lambda: True)
-    monkeypatch.setattr(telegraf.hookenv, 'status_set', lambda status, msg: None)
-    monkeypatch.setattr(telegraf.hookenv, 'log', lambda msg, **kw: None)
-    monkeypatch.setattr(telegraf.host, 'service_resume', lambda svc: None)
-    monkeypatch.setattr(telegraf.host, 'service_reload', lambda svc: None)
-    monkeypatch.setattr(telegraf.host, 'service_pause', lambda svc: None)
+    monkeypatch.setattr(telegraf, "update_sysstat_config_with_sdac_xall", lambda: True)
+    monkeypatch.setattr(telegraf.hookenv, "status_set", lambda status, msg: None)
+    monkeypatch.setattr(telegraf.hookenv, "log", lambda msg, **kw: None)
+    monkeypatch.setattr(telegraf.host, "service_resume", lambda svc: None)
+    monkeypatch.setattr(telegraf.host, "service_reload", lambda svc: None)
+    monkeypatch.setattr(telegraf.host, "service_pause", lambda svc: None)
 
     # patch host.write for non-root
     user = getpass.getuser()
@@ -71,16 +72,17 @@ def setup(monkeypatch, tmpdir):
         # owner/group as positional arguments like
         # charmhelpers.core.templating.render
         if len(a) > 2:
-            if a[2] == 'root' and a[3] == 'root':
+            if a[2] == "root" and a[3] == "root":
                 # make all files writable by owner, as we need don't run as root
                 a = (a[0], a[1], user, group, 0o744)
         else:
-            kw['owner'] = user
-            kw['group'] = group
+            kw["owner"] = user
+            kw["group"] = group
             # make all files writable by owner, as we need don't run as root
-            kw['perms'] = 0o744
+            kw["perms"] = 0o744
         return orig_write_file(*a, **kw)
-    monkeypatch.setattr(telegraf.host, 'write_file', intercept_write_file)
+
+    monkeypatch.setattr(telegraf.host, "write_file", intercept_write_file)
 
 
 @pytest.fixture(autouse=True)
@@ -88,46 +90,50 @@ def cleanup(request):
     def unit_state_cleanup():
         # cleanup unitdata
         from charmhelpers.core import unitdata
+
         unitdata._KV = None
         # rm unit-state.db file
-        unit_state_db = os.path.join(telegraf.hookenv.charm_dir(), '.unit-state.db')
+        unit_state_db = os.path.join(telegraf.hookenv.charm_dir(), ".unit-state.db")
         if os.path.exists(unit_state_db):
             os.unlink(unit_state_db)
+
     request.addfinalizer(unit_state_cleanup)
 
 
 @pytest.fixture()
 def temp_charm_dir(monkeypatch, tmpdir):
     charm_dir = tmpdir.mkdir("charm_dir")
-    os.environ['CHARM_DIR'] = charm_dir.strpath
+    os.environ["CHARM_DIR"] = charm_dir.strpath
     # also monkeypatch get_templates_dir to fix the path
     real_charm_dir = os.path.join(os.path.dirname(reactive.__file__), "../")
-    monkeypatch.setattr(telegraf, 'get_templates_dir',
-                        lambda: os.path.join(real_charm_dir, 'templates'))
-    monkeypatch.setattr(telegraf, 'get_files_dir',
-                        lambda: os.path.join(real_charm_dir, 'files'))
+    monkeypatch.setattr(
+        telegraf, "get_templates_dir", lambda: os.path.join(real_charm_dir, "templates")
+    )
+    monkeypatch.setattr(
+        telegraf, "get_files_dir", lambda: os.path.join(real_charm_dir, "files")
+    )
     # fix hookenv.metadata
-    with open(os.path.join(real_charm_dir, 'metadata.yaml')) as md:
+    with open(os.path.join(real_charm_dir, "metadata.yaml")) as md:
         metadata = yaml.full_load(md)
-    monkeypatch.setattr(telegraf.hookenv, 'metadata', lambda: metadata)
+    monkeypatch.setattr(telegraf.hookenv, "metadata", lambda: metadata)
 
 
 @pytest.fixture(autouse=True)
 def temp_config_dir(monkeypatch, tmpdir):
     base_dir = tmpdir.mkdir("etc_telegraf")
     base_dir.mkdir(telegraf.CONFIG_DIR)
-    monkeypatch.setattr(telegraf, 'DEB_BASE_DIR', base_dir.strpath)
+    monkeypatch.setattr(telegraf, "DEB_BASE_DIR", base_dir.strpath)
 
     sudoers_dir = tmpdir.mkdir("etc_sudoers")
-    monkeypatch.setattr(telegraf, 'SUDOERS_DIR', sudoers_dir.strpath)
+    monkeypatch.setattr(telegraf, "SUDOERS_DIR", sudoers_dir.strpath)
 
 
 @pytest.fixture(autouse=True)
 def config(monkeypatch, temp_charm_dir):
-    raw_config = yaml.full_load(open('config.yaml', 'r'))
-    data = dict((k, v['default']) for k, v in raw_config['options'].items())
+    raw_config = yaml.full_load(open("config.yaml", "r"))
+    data = dict((k, v["default"]) for k, v in raw_config["options"].items())
     config = Config(data)
-    monkeypatch.setattr(telegraf.hookenv, 'config', lambda: config)
+    monkeypatch.setattr(telegraf.hookenv, "config", lambda: config)
     return config
 
 
@@ -142,15 +148,19 @@ def configs_dir():
 
 def persist_state():
     """Fake persistent state by calling helpers that modify unitdata.kv"""
-    states = [k for k in bus.get_states().keys()
-              if k.startswith('plugins') or k.startswith('extra_plugins')]
+    states = [
+        k
+        for k in bus.get_states().keys()
+        if k.startswith("plugins") or k.startswith("extra_plugins")
+    ]
     helpers.any_file_changed(telegraf.list_config_files())
     if states:
-        helpers.data_changed('active_plugins', states)
+        helpers.data_changed("active_plugins", states)
 
 
 # Tests
 
+
 def check_sysstat_config(original, expected):
     original = original.strip()
     expected = expected.strip()
@@ -160,331 +170,372 @@ def check_sysstat_config(original, expected):
 
 def test_sadc_options_correct(monkeypatch):
     """If SADC_OPTIONS is already correct, should return None"""
-    original = dedent("""
+    original = dedent(
+        """
         # some comment
         COMPRESSAFTER=10
         SADC_OPTIONS="-S XALL"
         # another comment
         UMASK=0022
-    """)
+    """
+    )
     assert telegraf.get_sysstat_config_with_sadc_xall(original) is None
 
 
 def test_sadc_options_correct_included(monkeypatch):
     """If SADC_OPTIONS already includes `-S XALL`, should return None"""
-    original = dedent("""
+    original = dedent(
+        """
         # some comment
         COMPRESSAFTER=10
         SADC_OPTIONS="-B before -S XALL -A after"
         # another comment
         UMASK=0022
-    """)
+    """
+    )
     assert telegraf.get_sysstat_config_with_sadc_xall(original) is None
 
 
 def test_sadc_options_non_exist(monkeypatch):
     """If SADC_OPTIONS doesn't exist, should just append"""
-    original = dedent("""
+    original = dedent(
+        """
         # some comment
         COMPRESSAFTER=10
-    """)
+    """
+    )
 
-    expected = dedent("""
+    expected = dedent(
+        """
         # some comment
         COMPRESSAFTER=10
         SADC_OPTIONS="-S XALL"
-    """)
+    """
+    )
 
     check_sysstat_config(original, expected)
 
 
 def test_sadc_options_commented(monkeypatch):
     """If SADC_OPTIONS exists but commented, should ignore and append"""
-    original = dedent("""
+    original = dedent(
+        """
         # some comment
         COMPRESSAFTER=10
         #SADC_OPTIONS="-S XALL"
         # another comment
         UMASK=0022
-    """)
+    """
+    )
 
-    expected = dedent("""
+    expected = dedent(
+        """
         # some comment
         COMPRESSAFTER=10
         #SADC_OPTIONS="-S XALL"
         # another comment
         UMASK=0022
         SADC_OPTIONS="-S XALL"
-    """)
+    """
+    )
 
     check_sysstat_config(original, expected)
 
 
 def test_sadc_options_incorrect(monkeypatch):
     """If SADC_OPTIONS exists but not XALL, should replace"""
-    original = dedent("""
+    original = dedent(
+        """
         # some comment
         COMPRESSAFTER=10
         SADC_OPTIONS="-S DISK"
         # another comment
         UMASK=0022
-    """)
+    """
+    )
 
-    expected = dedent("""
+    expected = dedent(
+        """
         # some comment
         COMPRESSAFTER=10
         SADC_OPTIONS="-S XALL"
         # another comment
         UMASK=0022
-    """)
+    """
+    )
     check_sysstat_config(original, expected)
 
 
 def test_sadc_options_incorrect_included(monkeypatch):
     """If SADC_OPTIONS exists but not XALL, should replace"""
-    original = dedent("""
+    original = dedent(
+        """
         # some comment
         COMPRESSAFTER=10
         SADC_OPTIONS="-B before -S DISK -A after"
         # another comment
         UMASK=0022
-    """)
+    """
+    )
 
-    expected = dedent("""
+    expected = dedent(
+        """
         # some comment
         COMPRESSAFTER=10
         SADC_OPTIONS="-B before -S XALL -A after"
         # another comment
         UMASK=0022
-    """)
+    """
+    )
     check_sysstat_config(original, expected)
 
 
 def test_sadc_options_commented_line_not_touched(monkeypatch):
     """If SADC_OPTIONS exists but has no -S, should append"""
-    original = dedent("""
+    original = dedent(
+        """
         # some comment
         COMPRESSAFTER=10
         #SADC_OPTIONS="-C a-comment -D -V --arg1 --arg2"
         SADC_OPTIONS="-C a-comment -D -V"
         # another comment
         UMASK=0022
-    """)
+    """
+    )
 
-    expected = dedent("""
+    expected = dedent(
+        """
         # some comment
         COMPRESSAFTER=10
         #SADC_OPTIONS="-C a-comment -D -V --arg1 --arg2"
         SADC_OPTIONS="-C a-comment -D -V -S XALL"
         # another comment
         UMASK=0022
-    """)
+    """
+    )
 
     check_sysstat_config(original, expected)
 
 
 def test_sadc_options_s_missing(monkeypatch):
     """If SADC_OPTIONS exists but has no -S, should append"""
-    original = dedent("""
+    original = dedent(
+        """
         # some comment
         COMPRESSAFTER=10
         SADC_OPTIONS="-C a-comment -D -V"
         # another comment
         UMASK=0022
-    """)
+    """
+    )
 
-    expected = dedent("""
+    expected = dedent(
+        """
         # some comment
         COMPRESSAFTER=10
         SADC_OPTIONS="-C a-comment -D -V -S XALL"
         # another comment
         UMASK=0022
-    """)
+    """
+    )
 
     check_sysstat_config(original, expected)
 
 
 def test_telegraf_exec_metrics(monkeypatch, temp_config_dir):
-
     def run_telegraf_exec_metrics(*args):
-        script = os.path.join(telegraf.get_files_dir(), 'telegraf_exec_metrics.py')
+        script = os.path.join(telegraf.get_files_dir(), "telegraf_exec_metrics.py")
         cmd = [script] + list(args)
         assert 0 == subprocess.call(cmd)
 
-    metrics = set(['sockstat', 'sockstat6', 'softnet_stat', 'buddyinfo', 'zoneinfo', 'netns'])
+    metrics = set(
+        ["sockstat", "sockstat6", "softnet_stat", "buddyinfo", "zoneinfo", "netns"]
+    )
     for metric in metrics:
-        run_telegraf_exec_metrics('--metric', metric)
+        run_telegraf_exec_metrics("--metric", metric)
 
     # another test for netns, read cmd output from file
-    run_telegraf_exec_metrics('--metric', 'netns', '--input-file', os.path.join(UNIT_TESTS_DATA_DIR, 'netns.txt'))
+    run_telegraf_exec_metrics(
+        "--metric",
+        "netns",
+        "--input-file",
+        os.path.join(UNIT_TESTS_DATA_DIR, "netns.txt"),
+    )
     # parse output form `sudo ovs-appctl dpctl/show -s`
-    run_telegraf_exec_metrics('--metric', 'ovs_dpctl', '--input-file', os.path.join(UNIT_TESTS_DATA_DIR, 'ovs_dpctl.txt'))
+    run_telegraf_exec_metrics(
+        "--metric",
+        "ovs_dpctl",
+        "--input-file",
+        os.path.join(UNIT_TESTS_DATA_DIR, "ovs_dpctl.txt"),
+    )
 
     # ensure config files exists after render
     run_telegraf_exec_metrics(
-        '--render-config-files',
-        '--configs-dir', configs_dir(),
+        "--render-config-files", "--configs-dir", configs_dir(),
     )
     for metric in metrics:
-        assert os.path.isfile(os.path.join(configs_dir(), '{}.conf'.format(metric)))
+        assert os.path.isfile(os.path.join(configs_dir(), "{}.conf".format(metric)))
 
     # ensure --disabled-metrics option is working
-    disabled_metrics = set(['sockstat', 'zoneinfo'])
+    disabled_metrics = set(["sockstat", "zoneinfo"])
     run_telegraf_exec_metrics(
-        '--render-config-files',
-        '--configs-dir', configs_dir(),
-        '--disabled-metrics', ':'.join(disabled_metrics),
+        "--render-config-files",
+        "--configs-dir",
+        configs_dir(),
+        "--disabled-metrics",
+        ":".join(disabled_metrics),
     )
     # config files for disabled metrics should be removed.
     for metric in disabled_metrics:
-        assert not os.path.isfile(os.path.join(configs_dir(), '{}.conf'.format(metric)))
+        assert not os.path.isfile(os.path.join(configs_dir(), "{}.conf".format(metric)))
     # config files for other metrics should still be there
-    for metric in (metrics - disabled_metrics):
-        assert os.path.isfile(os.path.join(configs_dir(), '{}.conf'.format(metric)))
+    for metric in metrics - disabled_metrics:
+        assert os.path.isfile(os.path.join(configs_dir(), "{}.conf".format(metric)))
 
 
 def test_get_remote_unit_name_juju2(monkeypatch):
     monkeypatch.undo()
-    monkeypatch.setitem(os.environ, 'JUJU_PRINCIPAL_UNIT', 'remote/0')
-    assert telegraf.get_remote_unit_name() == 'remote/0'
+    monkeypatch.setitem(os.environ, "JUJU_PRINCIPAL_UNIT", "remote/0")
+    assert telegraf.get_remote_unit_name() == "remote/0"
 
 
 def test_get_remote_unit_name_juju1(monkeypatch):
     monkeypatch.undo()
-    monkeypatch.setattr(telegraf.netifaces,
-                        'interfaces',
-                        lambda: ['lo', 'eth0'])
-
-    ifaddresses = {17: [{'addr': 'AA:BB:CC:DD:EE:FF',
-                         'broadcast': 'ff:ff:ff:ff:ff:ff'}],
-                   2: [{'addr': '1.2.3.4',
-                        'netmask': '255.255.255.0',
-                        'broadcast': '1.2.3.1'}],
-                   10: [{'addr': '2620:0:862:ed1a::1',
-                         'netmask': 'ffff:ffff:ffff:ffff::'}]}
-    monkeypatch.setattr(telegraf.netifaces,
-                        'ifaddresses',
-                        lambda n: ifaddresses if n == 'eth0' else {})
-
-    md = {'name': 'telegraf',
-          'requires': {'mysql': {'interface': 'mysql-root'},
-                       'postgresql': {'interface': 'pgsql'},
-                       'mongodb': {'interface': 'mongodb',
-                                   'scope': 'container'},
-                       'memcached': {'interface': 'memcache',
-                                     'scope': 'container'},
-                       'elasticsearch': {'interface':
-                                         'elasticsearch',
-                                         'scope': 'container'},
-                       'haproxy': {'interface': 'statistics',
-                                   'scope': 'container'},
-                       'apache': {'interface': 'apache-website',
-                                  'scope': 'container'},
-                       'influxdb-api': {'interface':
-                                        'influxdb-api'},
-                       'juju-info': {'interface': 'juju-info',
-                                     'scope': 'container'},
-                       'exec': {'interface': 'telegraf-exec',
-                                'scope': 'container'}},
-          'provides': {'prometheus-client': {'interface': 'http'},
-                       'prometheus-rules': {'interface': 'prometheus-rules'}}}
-    monkeypatch.setattr(telegraf.hookenv, 'metadata', lambda: md)
+    monkeypatch.setattr(telegraf.netifaces, "interfaces", lambda: ["lo", "eth0"])
+
+    ifaddresses = {
+        17: [{"addr": "AA:BB:CC:DD:EE:FF", "broadcast": "ff:ff:ff:ff:ff:ff"}],
+        2: [{"addr": "1.2.3.4", "netmask": "255.255.255.0", "broadcast": "1.2.3.1"}],
+        10: [{"addr": "2620:0:862:ed1a::1", "netmask": "ffff:ffff:ffff:ffff::"}],
+    }
+    monkeypatch.setattr(
+        telegraf.netifaces, "ifaddresses", lambda n: ifaddresses if n == "eth0" else {}
+    )
+
+    md = {
+        "name": "telegraf",
+        "requires": {
+            "mysql": {"interface": "mysql-root"},
+            "postgresql": {"interface": "pgsql"},
+            "mongodb": {"interface": "mongodb", "scope": "container"},
+            "memcached": {"interface": "memcache", "scope": "container"},
+            "elasticsearch": {"interface": "elasticsearch", "scope": "container"},
+            "haproxy": {"interface": "statistics", "scope": "container"},
+            "apache": {"interface": "apache-website", "scope": "container"},
+            "influxdb-api": {"interface": "influxdb-api"},
+            "juju-info": {"interface": "juju-info", "scope": "container"},
+            "exec": {"interface": "telegraf-exec", "scope": "container"},
+        },
+        "provides": {
+            "prometheus-client": {"interface": "http"},
+            "prometheus-rules": {"interface": "prometheus-rules"},
+        },
+    }
+    monkeypatch.setattr(telegraf.hookenv, "metadata", lambda: md)
 
     def relation_ids(reltype):
-        if reltype == 'juju-info':
-            return ['juju-info:0']
+        if reltype == "juju-info":
+            return ["juju-info:0"]
         else:
             return []
-    monkeypatch.setattr(telegraf.hookenv,
-                        'relation_ids',
-                        relation_ids)
+
+    monkeypatch.setattr(telegraf.hookenv, "relation_ids", relation_ids)
 
     def related_units(relid):
-        if relid == 'juju-info:0':
-            return ['remote/0']
+        if relid == "juju-info:0":
+            return ["remote/0"]
         else:
             return []
-    monkeypatch.setattr(telegraf.hookenv,
-                        'related_units',
-                        related_units)
+
+    monkeypatch.setattr(telegraf.hookenv, "related_units", related_units)
 
     relations = []
-    monkeypatch.setattr(telegraf.hookenv,
-                        'relations_of_type',
-                        lambda n: relations)
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: relations)
     assert telegraf.get_remote_unit_name() is None
 
-    relations = [{'private-address': '1.2.3.4', '__unit__': 'remote/0'}]
-    monkeypatch.setattr(telegraf.hookenv,
-                        'relations_of_type',
-                        lambda n: relations)
-    assert telegraf.get_remote_unit_name() == 'remote/0'
+    relations = [{"private-address": "1.2.3.4", "__unit__": "remote/0"}]
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: relations)
+    assert telegraf.get_remote_unit_name() == "remote/0"
 
 
 def test_inputs_config_set(monkeypatch, config):
-    config['inputs_config'] = """
+    config[
+        "inputs_config"
+    ] = """
     [[inputs.cpu]]
         percpu = true
 """
 
     def check(*a, **kw):
-        assert kw['context']['inputs'] == config['inputs_config']
-    monkeypatch.setattr(telegraf, 'check_prometheus_port', lambda a, b: None)
-    monkeypatch.setattr(telegraf, 'render', check)
+        assert kw["context"]["inputs"] == config["inputs_config"]
+
+    monkeypatch.setattr(telegraf, "check_prometheus_port", lambda a, b: None)
+    monkeypatch.setattr(telegraf, "render", check)
     telegraf.configure_telegraf()
 
 
 def test_old_base64_inputs_and_outputs(monkeypatch, config):
-    config['inputs_config'] = base64.b64encode(b"""
+    config["inputs_config"] = base64.b64encode(
+        b"""
     [[inputs.cpu]]
         percpu = true
-""").decode('utf-8')
-    config['outputs_config'] = base64.b64encode(b"""
+"""
+    ).decode("utf-8")
+    config["outputs_config"] = base64.b64encode(
+        b"""
     [[outputs.fake]]
         foo = true
-""").decode('utf-8')
-    monkeypatch.setattr(telegraf, 'check_prometheus_port', lambda a, b: None)
+"""
+    ).decode("utf-8")
+    monkeypatch.setattr(telegraf, "check_prometheus_port", lambda a, b: None)
 
     def check(*a, **kw):
-        expected = base64.b64decode(config['inputs_config']).decode('utf-8')
-        assert kw['context']['inputs'] == expected
-        expected = base64.b64decode(config['outputs_config']).decode('utf-8')
-        assert kw['context']['outputs'] == expected
-    monkeypatch.setattr(telegraf, 'render', check)
+        expected = base64.b64decode(config["inputs_config"]).decode("utf-8")
+        assert kw["context"]["inputs"] == expected
+        expected = base64.b64decode(config["outputs_config"]).decode("utf-8")
+        assert kw["context"]["outputs"] == expected
+
+    monkeypatch.setattr(telegraf, "render", check)
     telegraf.configure_telegraf()
 
 
 def test_inputs_config_not_set(monkeypatch, config):
-    monkeypatch.setattr(telegraf, 'check_prometheus_port', lambda a, b: None)
-    config['inputs_config'] = ""
+    monkeypatch.setattr(telegraf, "check_prometheus_port", lambda a, b: None)
+    config["inputs_config"] = ""
 
     def check(*a, **kw):
-        assert kw['context']['inputs'] == telegraf.render_base_inputs()
-    monkeypatch.setattr(telegraf, 'render', check)
+        assert kw["context"]["inputs"] == telegraf.render_base_inputs()
+
+    monkeypatch.setattr(telegraf, "render", check)
     telegraf.configure_telegraf()
 
 
 def test_outputs_config(monkeypatch, config):
-    monkeypatch.setattr(telegraf, 'check_prometheus_port', lambda a, b: None)
-    config['outputs_config'] = """
+    monkeypatch.setattr(telegraf, "check_prometheus_port", lambda a, b: None)
+    config[
+        "outputs_config"
+    ] = """
     [[outputs.foo]]
         server = "http://localhost:42"
 """
 
     def check(*a, **kw):
-        assert kw['context']['outputs'] == config['outputs_config']
-    monkeypatch.setattr(telegraf, 'render', check)
+        assert kw["context"]["outputs"] == config["outputs_config"]
+
+    monkeypatch.setattr(telegraf, "render", check)
     telegraf.configure_telegraf()
 
 
 def test_extra_plugins(config):
-    config['extra_plugins'] = """[[inputs.foo]]
+    config[
+        "extra_plugins"
+    ] = """[[inputs.foo]]
     some_option = "http://foo.bar.com"
 [[outputs.baz]]
     option = "enabled"
     """
     telegraf.configure_extra_plugins()
-    assert configs_dir().join('extra_plugins.conf').read() == config['extra_plugins']
+    assert configs_dir().join("extra_plugins.conf").read() == config["extra_plugins"]
 
 
 def test_render_extra_options(config):
@@ -495,8 +546,8 @@ def test_render_extra_options(config):
             string: 10s
             list: ["a", "b"]
 """
-    config['extra_options'] = extra_options
-    content = telegraf.render_extra_options('inputs', 'test')
+    config["extra_options"] = extra_options
+    content = telegraf.render_extra_options("inputs", "test")
     expected = """  boolean = true\n  list = ["a", "b"]\n  string = "10s"\n"""
     assert sorted(content.split()) == sorted(expected.split())
 
@@ -511,7 +562,7 @@ def test_get_extra_options(config):
             tagdrop:
                 tag: ["foo", "bar"]
 """
-    config['extra_options'] = extra_options
+    config["extra_options"] = extra_options
     extra_opts = telegraf.get_extra_options()
     expected = {
         "inputs": {
@@ -519,12 +570,10 @@ def test_get_extra_options(config):
                 "boolean": "true",
                 "string": '"somestring"',
                 "list": '["a", "b"]',
-                "tagdrop": {
-                    "tag": '["foo", "bar"]'
-                }
+                "tagdrop": {"tag": '["foo", "bar"]'},
             }
         },
-        "outputs": {}
+        "outputs": {},
     }
     assert extra_opts == expected
 
@@ -537,10 +586,10 @@ def test_render_extra_options_override(config):
             string: 10s
             list: ["a", "b"]
 """
-    config['extra_options'] = extra_options
+    config["extra_options"] = extra_options
     # clone extra_options and use a modified version
-    options = {'inputs': {'test': {'string': json.dumps("20s")}}}
-    content = telegraf.render_extra_options('inputs', 'test', extra_options=options)
+    options = {"inputs": {"test": {"string": json.dumps("20s")}}}
+    content = telegraf.render_extra_options("inputs", "test", extra_options=options)
     expected = """  string = "20s"\n"""
     assert sorted(content.split()) == sorted(expected.split())
 
@@ -555,7 +604,7 @@ inputs:
         tagpass:
             cpu: ["cpu0"]
 """
-    config['extra_options'] = base_inputs_opts
+    config["extra_options"] = base_inputs_opts
     content = telegraf.render_base_inputs()
     expected = """
 # Read metrics about cpu usage
@@ -566,76 +615,71 @@ inputs:
   [inputs.cpu.tagpass]
     cpu = ["cpu0"]
 """
-    assert content[:len(expected)] == expected
+    assert content[: len(expected)] == expected
 
 
 def test_base_inputs_disabled_plugins(config):
     """Check disabled_plugins option is working for builtin inputs"""
-    config['disabled_plugins'] = 'cpu:disk'
+    config["disabled_plugins"] = "cpu:disk"
     content = telegraf.render_base_inputs()
 
     # disabled, should not exist
-    assert '[[inputs.cpu]]' not in content
-    assert '[[inputs.disk]]' not in content
+    assert "[[inputs.cpu]]" not in content
+    assert "[[inputs.disk]]" not in content
 
     # not disabled, should exist
-    assert '[[inputs.mem]]' in content
+    assert "[[inputs.mem]]" in content
 
 
 def test_check_prometheus_port(monkeypatch):
     open_ports = set()
-    monkeypatch.setattr(telegraf.hookenv, 'open_port',
-                        lambda p: open_ports.add(p))
-    telegraf.check_prometheus_port('test_check_port', 10042)
+    monkeypatch.setattr(telegraf.hookenv, "open_port", lambda p: open_ports.add(p))
+    telegraf.check_prometheus_port("test_check_port", 10042)
     assert 10042 in open_ports
 
 
 def test_check_prometheus_port_replace_old_port(monkeypatch):
     open_ports = set()
-    monkeypatch.setattr(telegraf.hookenv, 'open_port',
-                        lambda p: open_ports.add(p))
-    monkeypatch.setattr(telegraf.hookenv, 'close_port',
-                        lambda p: open_ports.remove(p))
-    telegraf.check_prometheus_port('test_check_port', 10042)
+    monkeypatch.setattr(telegraf.hookenv, "open_port", lambda p: open_ports.add(p))
+    monkeypatch.setattr(telegraf.hookenv, "close_port", lambda p: open_ports.remove(p))
+    telegraf.check_prometheus_port("test_check_port", 10042)
     assert 10042 in open_ports
-    telegraf.check_prometheus_port('test_check_port', 10043)
+    telegraf.check_prometheus_port("test_check_port", 10043)
     assert 10043 in open_ports
     assert 10042 not in open_ports
 
 
 def test_get_prometheus_port(monkeypatch, config):
-    config['prometheus_output_port'] = ''
+    config["prometheus_output_port"] = ""
     assert telegraf.get_prometheus_port() is False
-    config['prometheus_output_port'] = 'default'
+    config["prometheus_output_port"] = "default"
     assert telegraf.get_prometheus_port() == 9103
-    config['prometheus_output_port'] = '9126'
+    config["prometheus_output_port"] = "9126"
     assert telegraf.get_prometheus_port() == 9126
 
 
 def test_prometheus_global(monkeypatch, config):
     open_ports = set()
-    monkeypatch.setattr(telegraf.hookenv, 'open_port',
-                        lambda p: open_ports.add(p))
-    monkeypatch.setattr(telegraf.hookenv, 'close_port',
-                        lambda p: open_ports.remove(p))
-    config['prometheus_output_port'] = 'default'
+    monkeypatch.setattr(telegraf.hookenv, "open_port", lambda p: open_ports.add(p))
+    monkeypatch.setattr(telegraf.hookenv, "close_port", lambda p: open_ports.remove(p))
+    config["prometheus_output_port"] = "default"
     telegraf.configure_telegraf()
     expected = """
 [[outputs.prometheus_client]]
   listen = ":9103"
 """
-    config_file = base_dir().join('telegraf.conf')
+    config_file = base_dir().join("telegraf.conf")
     assert expected in config_file.read()
 
 
 def test_prometheus_global_with_extra_options(monkeypatch, config):
     open_ports = set()
-    monkeypatch.setattr(telegraf.hookenv, 'open_port',
-                        lambda p: open_ports.add(p))
-    monkeypatch.setattr(telegraf.hookenv, 'close_port',
-                        lambda p: open_ports.remove(p))
-    config['prometheus_output_port'] = 'default'
-    config['extra_options'] = """
+    monkeypatch.setattr(telegraf.hookenv, "open_port", lambda p: open_ports.add(p))
+    monkeypatch.setattr(telegraf.hookenv, "close_port", lambda p: open_ports.remove(p))
+    config["prometheus_output_port"] = "default"
+    config[
+        "extra_options"
+    ] = """
 outputs:
   prometheus_client:
     namedrop: ["aerospike*"]
@@ -651,15 +695,13 @@ outputs:
   [outputs.prometheus_client.tagpass]
     cpu = ["cpu0"]
 """
-    config_file = base_dir().join('telegraf.conf')
+    config_file = base_dir().join("telegraf.conf")
     assert expected in config_file.read()
 
 
 def test_default_tags(monkeypatch, config):
-    monkeypatch.setattr(telegraf.hookenv, 'principal_unit',
-                        lambda: 'principal-unit')
-    monkeypatch.setattr(telegraf.hookenv, 'open_port',
-                        lambda p: None)
+    monkeypatch.setattr(telegraf.hookenv, "principal_unit", lambda: "principal-unit")
+    monkeypatch.setattr(telegraf.hookenv, "open_port", lambda p: None)
     telegraf.configure_telegraf()
     expected = """
 [tags]
@@ -673,122 +715,133 @@ def test_default_tags(monkeypatch, config):
   juju_model = "telegraf-test-model"
 
 """
-    config_file = base_dir().join('telegraf.conf')
+    config_file = base_dir().join("telegraf.conf")
     assert expected in config_file.read()
 
+
 # Plugin tests
 
 
 def test_elasticsearch_input(monkeypatch, config):
-    relations = [{'host': '1.2.3.4', 'port': 1234}]
-    monkeypatch.setattr(telegraf.hookenv, 'relations_of_type', lambda n: relations)
+    relations = [{"host": "1.2.3.4", "port": 1234}]
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: relations)
 
-    telegraf.elasticsearch_input('test')
+    telegraf.elasticsearch_input("test")
     expected = """
 [[inputs.elasticsearch]]
   servers = ["http://1.2.3.4:1234"]
 """
-    assert configs_dir().join('elasticsearch.conf').read().strip() == expected.strip()
+    assert configs_dir().join("elasticsearch.conf").read().strip() == expected.strip()
 
 
 def test_elasticsearch_input_no_relations(monkeypatch):
-    monkeypatch.setattr(telegraf.hookenv, 'relations_of_type', lambda n: [])
-    telegraf.elasticsearch_input('test')
-    assert not configs_dir().join('elasticsearch.conf').exists()
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: [])
+    telegraf.elasticsearch_input("test")
+    assert not configs_dir().join("elasticsearch.conf").exists()
 
 
 def test_memcached_input(monkeypatch, config):
-    relations = [{'host': '1.2.3.4', 'port': 1234}]
-    monkeypatch.setattr(telegraf.hookenv, 'relations_of_type', lambda n: relations)
-    telegraf.memcached_input('test')
+    relations = [{"host": "1.2.3.4", "port": 1234}]
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: relations)
+    telegraf.memcached_input("test")
     expected = """
 [[inputs.memcached]]
   servers = ["1.2.3.4:1234"]
 """
-    assert configs_dir().join('memcached.conf').read().strip() == expected.strip()
+    assert configs_dir().join("memcached.conf").read().strip() == expected.strip()
 
 
 def test_memcached_input_no_relations(monkeypatch):
-    monkeypatch.setattr(telegraf.hookenv, 'relations_of_type', lambda n: [])
-    telegraf.memcached_input('test')
-    assert not configs_dir().join('memcached.conf').exists()
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: [])
+    telegraf.memcached_input("test")
+    assert not configs_dir().join("memcached.conf").exists()
 
 
 def test_mongodb_input(monkeypatch, config):
-    relations = [{'private-address': '1.2.3.4', 'port': 1234}]
-    monkeypatch.setattr(telegraf.hookenv, 'relations_of_type', lambda n: relations)
-    telegraf.mongodb_input('test')
+    relations = [{"private-address": "1.2.3.4", "port": 1234}]
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: relations)
+    telegraf.mongodb_input("test")
     expected = """
 [[inputs.mongodb]]
   servers = ["1.2.3.4:1234"]
 """
-    assert configs_dir().join('mongodb.conf').read().strip() == expected.strip()
+    assert configs_dir().join("mongodb.conf").read().strip() == expected.strip()
 
 
 def test_mongodb_input_no_relations(monkeypatch):
-    monkeypatch.setattr(telegraf.hookenv, 'relations_of_type', lambda n: [])
-    telegraf.mongodb_input('test')
-    assert not configs_dir().join('mongodb.conf').exists()
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: [])
+    telegraf.mongodb_input("test")
+    assert not configs_dir().join("mongodb.conf").exists()
 
 
 def test_haproxy_input(monkeypatch, config):
-    relations = [{'private-address': '1.2.3.4',
-                  'port': 1234,
-                  'user': 'foo',
-                  'password': 'bar',
-                  'enabled': 'True'}]
-    monkeypatch.setattr(telegraf.hookenv, 'relations_of_type', lambda n: relations)
-    monkeypatch.setattr(telegraf.hookenv, 'unit_private_ip', lambda: '1.2.3.4')
-    telegraf.haproxy_input('test')
+    relations = [
+        {
+            "private-address": "1.2.3.4",
+            "port": 1234,
+            "user": "foo",
+            "password": "bar",
+            "enabled": "True",
+        }
+    ]
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: relations)
+    monkeypatch.setattr(telegraf.hookenv, "unit_private_ip", lambda: "1.2.3.4")
+    telegraf.haproxy_input("test")
     expected = """
 [[inputs.haproxy]]
   servers = ["http://foo:bar@localhost:1234"]
 """
-    assert configs_dir().join('haproxy.conf').read().strip() == expected.strip()
+    assert configs_dir().join("haproxy.conf").read().strip() == expected.strip()
 
 
 def test_haproxy_input_no_relations(monkeypatch):
-    monkeypatch.setattr(telegraf.hookenv, 'relations_of_type', lambda n: [])
-    telegraf.haproxy_input('test')
-    assert not configs_dir().join('haproxy.conf').exists()
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: [])
+    telegraf.haproxy_input("test")
+    assert not configs_dir().join("haproxy.conf").exists()
 
 
 def test_haproxy_input_not_enabled(monkeypatch):
-    relations = [{'private-address': '1.2.3.4',
-                  'port': 1234,
-                  'user': 'foo',
-                  'password': 'bar',
-                  'enabled': 'False'}]
-    monkeypatch.setattr(telegraf.hookenv, 'relations_of_type', lambda n: relations)
-    telegraf.haproxy_input('test')
-    assert not configs_dir().join('haproxy.conf').exists()
+    relations = [
+        {
+            "private-address": "1.2.3.4",
+            "port": 1234,
+            "user": "foo",
+            "password": "bar",
+            "enabled": "False",
+        }
+    ]
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: relations)
+    telegraf.haproxy_input("test")
+    assert not configs_dir().join("haproxy.conf").exists()
 
 
 def test_apache_input(monkeypatch, config):
-    relations = [{'__relid__': 'apache:0', 'private-address': '1.2.3.4'}]
-    monkeypatch.setattr(telegraf.hookenv, 'relations_of_type', lambda n: relations)
-    monkeypatch.setattr(telegraf.hookenv, 'relation_set', lambda *a, **kw: None)
-    telegraf.apache_input('test')
+    relations = [{"__relid__": "apache:0", "private-address": "1.2.3.4"}]
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: relations)
+    monkeypatch.setattr(telegraf.hookenv, "relation_set", lambda *a, **kw: None)
+    telegraf.apache_input("test")
     expected = """
 [[inputs.apache]]
   urls = ["http://1.2.3.4:8080/server-status?auto"]
 """
-    assert configs_dir().join('apache.conf').read().strip() == expected.strip()
+    assert configs_dir().join("apache.conf").read().strip() == expected.strip()
 
 
 def test_apache_input_no_relations(monkeypatch):
-    monkeypatch.setattr(telegraf.hookenv, 'relations_of_type', lambda n: [])
-    telegraf.apache_input('test')
-    assert not configs_dir().join('apache.conf').exists()
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: [])
+    telegraf.apache_input("test")
+    assert not configs_dir().join("apache.conf").exists()
 
 
 def test_exec_input(mocker, monkeypatch):
     interface = mocker.Mock(spec=RelationBase)
     interface.commands = mocker.Mock()
-    command = {'commands': ['/srv/bin/test.sh', '/bin/true'],
-               'data_format': 'json',
-               'timeout': '5s',
-               'run_on_this_unit': True}
+    command = {
+        "commands": ["/srv/bin/test.sh", "/bin/true"],
+        "data_format": "json",
+        "timeout": "5s",
+        "run_on_this_unit": True,
+    }
     interface.commands.return_value = [command.copy()]
     telegraf.exec_input(interface)
     expected = """
@@ -797,22 +850,26 @@ def test_exec_input(mocker, monkeypatch):
   data_format = "json"
   timeout = "5s"
 """
-    assert configs_dir().join('exec.conf').read().strip() == expected.strip()
+    assert configs_dir().join("exec.conf").read().strip() == expected.strip()
     # add a second relation/command set
     interface.commands.return_value = [command.copy(), command.copy()]
     telegraf.exec_input(interface)
     expected = expected + expected
-    assert configs_dir().join('exec.conf').read().strip() == expected.strip()
+    assert configs_dir().join("exec.conf").read().strip() == expected.strip()
 
 
 def test_exec_input_with_tags(mocker, monkeypatch):
     interface = mocker.Mock(spec=RelationBase)
     interface.commands = mocker.Mock()
-    commands = [{'commands': ['/srv/bin/test.sh', '/bin/true'],
-                 'data_format': 'json',
-                 'timeout': '5s',
-                 'run_on_this_unit': True,
-                 'tags': {'test': 'test'}}]
+    commands = [
+        {
+            "commands": ["/srv/bin/test.sh", "/bin/true"],
+            "data_format": "json",
+            "timeout": "5s",
+            "run_on_this_unit": True,
+            "tags": {"test": "test"},
+        }
+    ]
     interface.commands.return_value = commands
     telegraf.exec_input(interface)
     expected = """
@@ -823,28 +880,36 @@ def test_exec_input_with_tags(mocker, monkeypatch):
   [inputs.exec.tags]
     test = "test"
 """
-    assert configs_dir().join('exec.conf').read().strip() == expected.strip()
+    assert configs_dir().join("exec.conf").read().strip() == expected.strip()
 
 
 def test_exec_input_no_leader(mocker, monkeypatch):
     interface = mocker.Mock(spec=RelationBase)
     interface.commands = mocker.Mock()
-    commands = [{'commands': ['/srv/bin/test.sh', '/bin/true'],
-                 'data_format': 'json',
-                 'timeout': '5s',
-                 'run_on_this_unit': False}]
+    commands = [
+        {
+            "commands": ["/srv/bin/test.sh", "/bin/true"],
+            "data_format": "json",
+            "timeout": "5s",
+            "run_on_this_unit": False,
+        }
+    ]
     interface.commands.return_value = commands
     telegraf.exec_input(interface)
-    assert not configs_dir().join('exec.conf').exists()
+    assert not configs_dir().join("exec.conf").exists()
 
 
 def test_exec_input_all_units(mocker, monkeypatch):
     interface = mocker.Mock(spec=RelationBase)
     interface.commands = mocker.Mock()
-    commands = [{"commands": ["/srv/bin/test.sh", "/bin/true"],
-                 'data_format': 'json',
-                 'timeout': '5s',
-                 'run_on_this_unit': True}]
+    commands = [
+        {
+            "commands": ["/srv/bin/test.sh", "/bin/true"],
+            "data_format": "json",
+            "timeout": "5s",
+            "run_on_this_unit": True,
+        }
+    ]
     interface.commands.return_value = commands
     telegraf.exec_input(interface)
     expected = """
@@ -853,16 +918,18 @@ def test_exec_input_all_units(mocker, monkeypatch):
   data_format = "json"
   timeout = "5s"
 """
-    assert configs_dir().join('exec.conf').read().strip() == expected.strip()
+    assert configs_dir().join("exec.conf").read().strip() == expected.strip()
 
 
 def test_exec_input_leader_no_more(mocker, monkeypatch):
     interface = mocker.Mock(spec=RelationBase)
     interface.commands = mocker.Mock()
-    command = {'commands': ['/srv/bin/test.sh', '/bin/true'],
-               'data_format': 'json',
-               'timeout': '5s',
-               'run_on_this_unit': True}
+    command = {
+        "commands": ["/srv/bin/test.sh", "/bin/true"],
+        "data_format": "json",
+        "timeout": "5s",
+        "run_on_this_unit": True,
+    }
     interface.commands.return_value = [command.copy()]
     telegraf.exec_input(interface)
     expected = """
@@ -871,57 +938,59 @@ def test_exec_input_leader_no_more(mocker, monkeypatch):
   data_format = "json"
   timeout = "5s"
 """
-    assert configs_dir().join('exec.conf').read().strip() == expected.strip()
+    assert configs_dir().join("exec.conf").read().strip() == expected.strip()
     # add a second relation/command set
     new_command = command.copy()
-    new_command['run_on_this_unit'] = False
+    new_command["run_on_this_unit"] = False
     interface.commands.return_value = [new_command.copy()]
     telegraf.exec_input(interface)
-    assert not configs_dir().join('exec.conf').exists()
+    assert not configs_dir().join("exec.conf").exists()
 
 
 def test_exec_input_departed(mocker, monkeypatch):
-    configs_dir().join('exec.conf').write('empty')
+    configs_dir().join("exec.conf").write("empty")
     relations = [1]
-    monkeypatch.setattr(telegraf.hookenv, 'relations_of_type', lambda n: relations)
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: relations)
     telegraf.exec_input_departed()
-    assert configs_dir().join('exec.conf').exists()
+    assert configs_dir().join("exec.conf").exists()
     relations.pop()
     telegraf.exec_input_departed()
-    assert not configs_dir().join('exec.conf').exists()
+    assert not configs_dir().join("exec.conf").exists()
 
 
 def test_influxdb_api_output(monkeypatch, config):
-    relations = [{'hostname': '1.2.3.4',
-                  'port': 1234,
-                  'user': 'foo',
-                  'password': 'bar'}]
-    monkeypatch.setattr(telegraf.hookenv, 'relations_of_type', lambda n: relations)
-    telegraf.influxdb_api_output('test')
-    expected = render(source='influxdb-api.conf.tmpl', target=None,
-                      templates_dir=telegraf.get_templates_dir(),
-                      context={'username': 'foo',
-                               'password': 'bar',
-                               'urls': '["http://1.2.3.4:1234"]'})
-    assert configs_dir().join('influxdb-api.conf').read().strip() == expected.strip()
+    relations = [
+        {"hostname": "1.2.3.4", "port": 1234, "user": "foo", "password": "bar"}
+    ]
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: relations)
+    telegraf.influxdb_api_output("test")
+    expected = render(
+        source="influxdb-api.conf.tmpl",
+        target=None,
+        templates_dir=telegraf.get_templates_dir(),
+        context={
+            "username": "foo",
+            "password": "bar",
+            "urls": '["http://1.2.3.4:1234"]',
+        },
+    )
+    assert configs_dir().join("influxdb-api.conf").read().strip() == expected.strip()
 
 
 def test_prometheus_client_output(mocker, monkeypatch, config):
-    config['prometheus_output_port'] = ''  # Not enabled globally
-    monkeypatch.setattr(telegraf.hookenv, 'open_port',
-                        lambda p: None)
+    config["prometheus_output_port"] = ""  # Not enabled globally
+    monkeypatch.setattr(telegraf.hookenv, "open_port", lambda p: None)
 
-    relation_ids = ['prometheus-client:0']
-    monkeypatch.setattr(telegraf.hookenv,
-                        'relation_ids',
-                        lambda r: relation_ids)
+    relation_ids = ["prometheus-client:0"]
+    monkeypatch.setattr(telegraf.hookenv, "relation_ids", lambda r: relation_ids)
 
     network_get_primary_address = mocker.patch.object(
-        telegraf.hookenv, 'network_get_primary_address', return_value="foo")
+        telegraf.hookenv, "network_get_primary_address", return_value="foo"
+    )
 
     mocker.patch.object(
-        telegraf.hookenv, 'network_get',
-        return_value={"ingress_addresses": ["1.2.3.4"]})
+        telegraf.hookenv, "network_get", return_value={"ingress_addresses": ["1.2.3.4"]}
+    )
 
     interface = mocker.Mock(spec=RelationBase)
     interface.configure = mocker.Mock()
@@ -930,236 +999,233 @@ def test_prometheus_client_output(mocker, monkeypatch, config):
     [[outputs.prometheus_client]]
   listen = ":9126"
 """
-    assert configs_dir().join('prometheus-client.conf').read().strip() == expected.strip()
-    network_get_primary_address.assert_called_once_with('prometheus-client')
-    interface.configure.assert_called_once_with(9126,
-                                                hostname='foo',
-                                                private_address='foo')
+    assert (
+        configs_dir().join("prometheus-client.conf").read().strip() == expected.strip()
+    )
+    network_get_primary_address.assert_called_once_with("prometheus-client")
+    interface.configure.assert_called_once_with(
+        9126, hostname="foo", private_address="foo"
+    )
 
 
 def test_prometheus_client_output_departed(mocker, monkeypatch, config):
-    configs_dir().join('prometheus-client.conf').write('empty')
+    configs_dir().join("prometheus-client.conf").write("empty")
     relations = [1]
-    monkeypatch.setattr(telegraf.hookenv, 'relations_of_type', lambda n: relations)
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: relations)
     telegraf.prometheus_client_departed()
-    assert configs_dir().join('prometheus-client.conf').exists()
+    assert configs_dir().join("prometheus-client.conf").exists()
     relations.pop()
     telegraf.prometheus_client_departed()
-    assert not configs_dir().join('prometheus-client.conf').exists()
+    assert not configs_dir().join("prometheus-client.conf").exists()
 
 
 # Integration tests (kind of)
 def test_basic_config(mocker, monkeypatch, config):
-    service_restart = mocker.patch('reactive.telegraf.host.service_restart')
-    monkeypatch.setattr(telegraf.host, 'service_running',
-                        lambda n: True)
-    check_prometheus_port = mocker.patch('reactive.telegraf.check_prometheus_port')
-    set_flag('apt.installed.telegraf')
-    assert not base_dir().join('telegraf.conf').exists()
+    service_restart = mocker.patch("reactive.telegraf.host.service_restart")
+    monkeypatch.setattr(telegraf.host, "service_running", lambda n: True)
+    check_prometheus_port = mocker.patch("reactive.telegraf.check_prometheus_port")
+    set_flag("apt.installed.telegraf")
+    assert not base_dir().join("telegraf.conf").exists()
     bus.dispatch()
-    assert 'telegraf.configured' in bus.get_states().keys()
-    assert base_dir().join('telegraf.conf').exists()
+    assert "telegraf.configured" in bus.get_states().keys()
+    assert base_dir().join("telegraf.conf").exists()
     service_restart.assert_called_once_with(telegraf.DEB_SERVICE)
-    check_prometheus_port.assert_called_once_with('prometheus_output', 9103)
+    check_prometheus_port.assert_called_once_with("prometheus_output", 9103)
 
 
 def test_config_no_prometheus(mocker, monkeypatch, config):
-    service_restart = mocker.patch('reactive.telegraf.host.service_restart')
-    monkeypatch.setattr(telegraf.host, 'service_running',
-                        lambda n: True)
-    check_prometheus_port = mocker.patch('reactive.telegraf.check_prometheus_port')
-    config['prometheus_output_port'] = ''
-    set_flag('apt.installed.telegraf')
-    assert not base_dir().join('telegraf.conf').exists()
+    service_restart = mocker.patch("reactive.telegraf.host.service_restart")
+    monkeypatch.setattr(telegraf.host, "service_running", lambda n: True)
+    check_prometheus_port = mocker.patch("reactive.telegraf.check_prometheus_port")
+    config["prometheus_output_port"] = ""
+    set_flag("apt.installed.telegraf")
+    assert not base_dir().join("telegraf.conf").exists()
     bus.dispatch()
-    assert 'telegraf.configured' in bus.get_states().keys()
-    assert base_dir().join('telegraf.conf').exists()
+    assert "telegraf.configured" in bus.get_states().keys()
+    assert base_dir().join("telegraf.conf").exists()
     service_restart.assert_called_once_with(telegraf.DEB_SERVICE)
     assert not check_prometheus_port.called
 
 
 def test_config_changed_apt(mocker, monkeypatch, config):
-    service_restart = mocker.patch('reactive.telegraf.host.service_restart')
-    monkeypatch.setattr(telegraf.host, 'service_running',
-                        lambda n: True)
-    mocker.patch('reactive.telegraf.check_prometheus_port')
-    set_flag('apt.installed.telegraf')
-    set_flag('config.changed')
+    service_restart = mocker.patch("reactive.telegraf.host.service_restart")
+    monkeypatch.setattr(telegraf.host, "service_running", lambda n: True)
+    mocker.patch("reactive.telegraf.check_prometheus_port")
+    set_flag("apt.installed.telegraf")
+    set_flag("config.changed")
     bus.dispatch()
     service_restart.assert_called_once_with(telegraf.DEB_SERVICE)
 
 
 def test_config_changed_extra_options(mocker, monkeypatch, config):
-    service_restart = mocker.patch('reactive.telegraf.host.service_restart')
-    monkeypatch.setattr(telegraf.host, 'service_running',
-                        lambda n: True)
-    mocker.patch('reactive.telegraf.check_prometheus_port')
-    set_flag('apt.telegraf.installed')
-    set_flag('plugins.haproxy.configured')
+    service_restart = mocker.patch("reactive.telegraf.host.service_restart")
+    monkeypatch.setattr(telegraf.host, "service_running", lambda n: True)
+    mocker.patch("reactive.telegraf.check_prometheus_port")
+    set_flag("apt.telegraf.installed")
+    set_flag("plugins.haproxy.configured")
     config.save()
     config.load_previous()
-    config['extra_options'] = yaml.dump({'inputs': {'haproxy': {'timeout': 10}}})
-    set_flag('apt.installed.telegraf')
-    set_flag('config.changed')
+    config["extra_options"] = yaml.dump({"inputs": {"haproxy": {"timeout": 10}}})
+    set_flag("apt.installed.telegraf")
+    set_flag("config.changed")
     bus.dispatch()
-    assert 'plugins.haproxy.configured' not in bus.get_states().keys()
+    assert "plugins.haproxy.configured" not in bus.get_states().keys()
     service_restart.assert_called_once_with(telegraf.DEB_SERVICE)
 
 
 def test_config_changed_extra_plugins(mocker, monkeypatch, config):
-    service_restart = mocker.patch('reactive.telegraf.host.service_restart')
-    monkeypatch.setattr(telegraf.host, 'service_running',
-                        lambda n: True)
-    mocker.patch('reactive.telegraf.check_prometheus_port')
-    set_flag('apt.telegraf.installed')
-    assert not configs_dir().join('extra_plugins.conf').exists()
+    service_restart = mocker.patch("reactive.telegraf.host.service_restart")
+    monkeypatch.setattr(telegraf.host, "service_running", lambda n: True)
+    mocker.patch("reactive.telegraf.check_prometheus_port")
+    set_flag("apt.telegraf.installed")
+    assert not configs_dir().join("extra_plugins.conf").exists()
     config.save()
     config.load_previous()
     # once the config is saved, change it. This will also trigger a service
     # restart
-    config['extra_plugins'] = """[[inputs.foo]]
+    config[
+        "extra_plugins"
+    ] = """[[inputs.foo]]
     some_option = "http://foo.bar.com"
 [[outputs.baz]]
     option = "enabled"
     """
-    set_flag('apt.installed.telegraf')
-    set_flag('config.changed')
+    set_flag("apt.installed.telegraf")
+    set_flag("config.changed")
     bus.dispatch()
-    assert configs_dir().join('extra_plugins.conf').exists()
-    assert configs_dir().join('extra_plugins.conf').read() == config['extra_plugins']
+    assert configs_dir().join("extra_plugins.conf").exists()
+    assert configs_dir().join("extra_plugins.conf").read() == config["extra_plugins"]
     service_restart.assert_called_with(telegraf.DEB_SERVICE)
 
 
 def test_restart_on_output_plugin_relation_departed(mocker, monkeypatch, config):
-    service_restart = mocker.patch('reactive.telegraf.host.service_restart')
-    monkeypatch.setattr(telegraf.host, 'service_running',
-                        lambda n: True)
-    monkeypatch.setattr(telegraf.hookenv, 'relations_of_type', lambda n: [])
-    monkeypatch.setattr(telegraf.hookenv, 'open_port',
-                        lambda p: None)
-    relation_ids = ['prometheus-client:0']
-    monkeypatch.setattr(telegraf.hookenv,
-                        'relation_ids',
-                        lambda r: relation_ids)
+    service_restart = mocker.patch("reactive.telegraf.host.service_restart")
+    monkeypatch.setattr(telegraf.host, "service_running", lambda n: True)
+    monkeypatch.setattr(telegraf.hookenv, "relations_of_type", lambda n: [])
+    monkeypatch.setattr(telegraf.hookenv, "open_port", lambda p: None)
+    relation_ids = ["prometheus-client:0"]
+    monkeypatch.setattr(telegraf.hookenv, "relation_ids", lambda r: relation_ids)
     mocker.patch.object(
-        telegraf.hookenv, 'network_get',
-        return_value={"ingress_addresses": ["1.2.3.4"]})
-    config['prometheus_output_port'] = ''
+        telegraf.hookenv, "network_get", return_value={"ingress_addresses": ["1.2.3.4"]}
+    )
+    config["prometheus_output_port"] = ""
     bus.discover()
-    set_flag('snap.telegraf.installed')
-    set_flag('telegraf.configured')
+    set_flag("snap.telegraf.installed")
+    set_flag("telegraf.configured")
     interface = mocker.Mock(spec=RelationBase)
     interface.configure = mocker.Mock()
     telegraf.prometheus_client(interface)
-    assert configs_dir().join('prometheus-client.conf').exists()
+    assert configs_dir().join("prometheus-client.conf").exists()
     # dispatch, file should be gone and telegraf restarted.
     bus.dispatch()
-    assert not configs_dir().join('prometheus-client.conf').exists()
+    assert not configs_dir().join("prometheus-client.conf").exists()
     service_restart.assert_called_with(telegraf.DEB_SERVICE)
 
 
 def test_upgrade_charm(mocker):
-    list_plugins = mocker.patch('reactive.telegraf.list_supported_plugins')
-    clear_flag = mocker.patch('reactive.telegraf.clear_flag')
-    list_plugins.return_value = ['foo', 'bar']
+    list_plugins = mocker.patch("reactive.telegraf.list_supported_plugins")
+    clear_flag = mocker.patch("reactive.telegraf.clear_flag")
+    list_plugins.return_value = ["foo", "bar"]
     telegraf.upgrade_charm()
-    clear_flag.assert_any_call('telegraf.configured')
-    clear_flag.assert_any_call('telegraf.apt.configured')
-    clear_flag.assert_any_call('telegraf.snap.configured')
-    clear_flag.assert_any_call('plugins.foo.configured')
-    clear_flag.assert_any_call('plugins.bar.configured')
-    clear_flag.assert_any_call('extra_plugins.configured')
-    clear_flag.assert_any_call('grafana.configured')
+    clear_flag.assert_any_call("telegraf.configured")
+    clear_flag.assert_any_call("telegraf.apt.configured")
+    clear_flag.assert_any_call("telegraf.snap.configured")
+    clear_flag.assert_any_call("plugins.foo.configured")
+    clear_flag.assert_any_call("plugins.bar.configured")
+    clear_flag.assert_any_call("extra_plugins.configured")
+    clear_flag.assert_any_call("grafana.configured")
     assert clear_flag.call_count == 7
 
 
 def test_get_socket_listener_port(monkeypatch, config):
-    config['socket_listener_port'] = ''
+    config["socket_listener_port"] = ""
     assert telegraf.get_socket_listener_port() == 8094
-    config['socket_listener_port'] = '9090'
+    config["socket_listener_port"] = "9090"
     assert telegraf.get_socket_listener_port() == 9090
 
 
 def test_socket_listener_config(monkeypatch, config):
     open_ports = set()
-    monkeypatch.setattr(telegraf.hookenv, 'open_port',
-                        lambda p: open_ports.add(p))
-    monkeypatch.setattr(telegraf.hookenv, 'close_port',
-                        lambda p: open_ports.remove(p))
-    config['prometheus_output_port'] = 'default'
+    monkeypatch.setattr(telegraf.hookenv, "open_port", lambda p: open_ports.add(p))
+    monkeypatch.setattr(telegraf.hookenv, "close_port", lambda p: open_ports.remove(p))
+    config["prometheus_output_port"] = "default"
     telegraf.configure_telegraf()
     expected = 'service_address = "tcp://127.0.0.1:8094"'
-    config_file = base_dir().join('telegraf.d', 'socket_listener.conf')
+    config_file = base_dir().join("telegraf.d", "socket_listener.conf")
     assert expected in config_file.read()
 
 
 class TestGetHostnameLabel(unittest.TestCase):
-    @patch('reactive.telegraf.get_remote_unit_name')
-    @patch('charmhelpers.core.hookenv.config')
+    @patch("reactive.telegraf.get_remote_unit_name")
+    @patch("charmhelpers.core.hookenv.config")
     def test_legacy(self, config, get_remote_unit_name):
-        config.return_value = dict(hostname='UNIT_NAME')
-        get_remote_unit_name.return_value = 'remote/10'
-        self.assertEqual(telegraf.get_hostname_label(),
-                         'remote-10')
+        config.return_value = dict(hostname="UNIT_NAME")
+        get_remote_unit_name.return_value = "remote/10"
+        self.assertEqual(telegraf.get_hostname_label(), "remote-10")
 
-    @patch('reactive.telegraf.get_remote_unit_name')
-    @patch('charmhelpers.core.hookenv.config')
+    @patch("reactive.telegraf.get_remote_unit_name")
+    @patch("charmhelpers.core.hookenv.config")
     def test_juju1(self, config, get_remote_unit_name):
-        get_remote_unit_name.return_value = 'remote/10'
-        env = dict(JUJU_ENV_NAME='env_name',
-                   JUJU_ENV_UUID='env_uuid')
-        config.return_value = dict(hostname='{uuid}:{model}:{unit}')
+        get_remote_unit_name.return_value = "remote/10"
+        env = dict(JUJU_ENV_NAME="env_name", JUJU_ENV_UUID="env_uuid")
+        config.return_value = dict(hostname="{uuid}:{model}:{unit}")
         with patch.dict(os.environ, env):
-            self.assertEqual(telegraf.get_hostname_label(),
-                             'env_uuid:env_name:remote-10')
+            self.assertEqual(
+                telegraf.get_hostname_label(), "env_uuid:env_name:remote-10"
+            )
 
-    @patch('reactive.telegraf.get_remote_unit_name')
-    @patch('charmhelpers.core.hookenv.config')
+    @patch("reactive.telegraf.get_remote_unit_name")
+    @patch("charmhelpers.core.hookenv.config")
     def test_juju2(self, config, get_remote_unit_name):
-        get_remote_unit_name.return_value = 'remote/10'
-        env = dict(JUJU_MODEL_NAME='model_name',
-                   JUJU_MODEL_UUID='model_uuid')
-        config.return_value = dict(hostname='{uuid}:{model}:{unit}')
+        get_remote_unit_name.return_value = "remote/10"
+        env = dict(JUJU_MODEL_NAME="model_name", JUJU_MODEL_UUID="model_uuid")
+        config.return_value = dict(hostname="{uuid}:{model}:{unit}")
         with patch.dict(os.environ, env):
-            self.assertEqual(telegraf.get_hostname_label(),
-                             'model_uuid:model_name:remote-10')
+            self.assertEqual(
+                telegraf.get_hostname_label(), "model_uuid:model_name:remote-10"
+            )
 
 
 class TestTelegrafNagios(unittest.TestCase):
-    @mock.patch('charmhelpers.contrib.charmsupport.nrpe.NRPE')
-    @mock.patch('charmhelpers.contrib.charmsupport.nrpe.get_nagios_hostname')
-    def test_update_nrpe_config(self,
-                                mock_get_nagios_hostname,
-                                mock_nrpe,
-                                *args):
-        mock_get_nagios_hostname.return_value = 'testunit'
+    @mock.patch("charmhelpers.contrib.charmsupport.nrpe.NRPE")
+    @mock.patch("charmhelpers.contrib.charmsupport.nrpe.get_nagios_hostname")
+    def test_update_nrpe_config(self, mock_get_nagios_hostname, mock_nrpe, *args):
+        mock_get_nagios_hostname.return_value = "testunit"
         svc = object()
         telegraf.configure_nagios(svc)
         calls = [
-            call(hostname='testunit', primary=False),
-            call().add_check('telegraf_http',
-                             'Telegraf HTTP check',
-                             'check_http -I 127.0.0.1 -p 9103 -u '
-                             '/metrics'),
-            call().write()]
+            call(hostname="testunit", primary=False),
+            call().add_check(
+                "telegraf_http",
+                "Telegraf HTTP check",
+                "check_http -I 127.0.0.1 -p 9103 -u " "/metrics",
+            ),
+            call().write(),
+        ]
         mock_nrpe.assert_has_calls(calls)
 
 
 class TestGrafanaDashboard(unittest.TestCase):
-    @patch('reactive.telegraf.render_custom')
-    @patch('reactive.telegraf.endpoint_from_flag')
-    @patch('reactive.telegraf.hookenv')
-    @patch('reactive.telegraf.set_flag')
-    @patch('reactive.telegraf.json')
-    def test_register_grafana_dashboard(self, mock_json, mock_set_flag, mock_hookenv,
-                                        mock_endpoint_from_flag, mock_render):
-        expected_datasource = 'my_prometheus'
+    @patch("reactive.telegraf.render_custom")
+    @patch("reactive.telegraf.endpoint_from_flag")
+    @patch("reactive.telegraf.hookenv")
+    @patch("reactive.telegraf.set_flag")
+    @patch("reactive.telegraf.json")
+    def test_register_grafana_dashboard(
+        self,
+        mock_json,
+        mock_set_flag,
+        mock_hookenv,
+        mock_endpoint_from_flag,
+        mock_render,
+    ):
+        expected_datasource = "my_prometheus"
         fake_config = dict(prometheus_datasource=expected_datasource)
         expected_dashboard_context = dict(
-            datasource='{} - Juju generated source'.format(expected_datasource),
+            datasource="{} - Juju generated source".format(expected_datasource),
             bonds_enabled=True,
             bcache_enabled=True,
-            conntrack_enabled=True
+            conntrack_enabled=True,
         )
 
         mock_grafana = MagicMock()
@@ -1180,22 +1246,25 @@ class TestGrafanaDashboard(unittest.TestCase):
             variable_end_string=">>",
         )
         mock_grafana.register_dashboard.assert_called_once_with(
-            name=telegraf.GRAFANA_DASHBOARD_NAME,
-            dashboard=mock_dashboard_dict,
+            name=telegraf.GRAFANA_DASHBOARD_NAME, dashboard=mock_dashboard_dict,
         )
-        mock_set_flag.assert_called_once_with('grafana.configured')
+        mock_set_flag.assert_called_once_with("grafana.configured")
 
-    @patch('reactive.telegraf.clear_flag')
+    @patch("reactive.telegraf.clear_flag")
     def test_unregister_grafana_dashboard(self, mock_clear_flag):
         telegraf.unregister_grafana_dashboard()
-        mock_clear_flag.assert_called_with('grafana.configured')
-
-    @patch('reactive.telegraf.endpoint_from_flag')
-    @patch('reactive.telegraf.clear_flag')
-    @patch('reactive.telegraf.hookenv')
-    def test_grafana_dashboard_import_failed(self, mock_hookenv, mock_clear_flag, mock_endpoint_from_flag):
-        test_failed_imports = [MagicMock(name='import1', reason='some_reason1'),
-                               MagicMock(name='import2', reason='some_reason2')]
+        mock_clear_flag.assert_called_with("grafana.configured")
+
+    @patch("reactive.telegraf.endpoint_from_flag")
+    @patch("reactive.telegraf.clear_flag")
+    @patch("reactive.telegraf.hookenv")
+    def test_grafana_dashboard_import_failed(
+        self, mock_hookenv, mock_clear_flag, mock_endpoint_from_flag
+    ):
+        test_failed_imports = [
+            MagicMock(name="import1", reason="some_reason1"),
+            MagicMock(name="import2", reason="some_reason2"),
+        ]
 
         mock_grafana = MagicMock()
         mock_grafana.failed_imports = test_failed_imports
@@ -1204,4 +1273,4 @@ class TestGrafanaDashboard(unittest.TestCase):
         telegraf.grafana_dashboard_import_failed()
 
         assert mock_hookenv.log.call_count == 2
-        mock_clear_flag.assert_called_once_with('grafana.configured')
+        mock_clear_flag.assert_called_once_with("grafana.configured")
diff --git a/src/tox.ini b/src/tox.ini
index 163018d..40c62d6 100644
--- a/src/tox.ini
+++ b/src/tox.ini
@@ -25,7 +25,7 @@ passenv =
 [testenv:lint]
 commands =
     flake8
-# TODO    black --check --exclude "/(\.eggs|\.git|\.tox|\.venv|\.build|dist|charmhelpers|mod)/" .
+    black --check --exclude "/(\.eggs|\.git|\.tox|\.venv|\.build|dist|charmhelpers|mod)/" .
 deps =
     black
     flake8
@@ -42,7 +42,7 @@ exclude =
     charmhelpers,
     mod,
     .build
-ignore = I100, D101, D102, D103, I201, D205, W504, D400, D401, D403, D209, D100, E403, I101, E501, N803, E226, E128, D200, E741, D202, E261, E402, D104  # TODO
+ignore = I100, D101, D102, D103, I201, D205, W504, D400, D401, D403, D209, D100, E403, I101, E501, N803, E226, E128, D200, E741, D202, E261, E402, D104, W503, E231  # TODO
 
 max-line-length = 88
 max-complexity = 10