Merge ~ballot/content-cache-charm/+git/content-cache-charm:add_lua into content-cache-charm:master

[Benjamin Allot]

Add nginx metrics for cache hits

A new option `enable_prometheus_metrics` can be set to True to expose nginx metrics about cache hits and HTTP requests in prometheus format.
This metrics are available on port 9145.

Update tests

All the tests have been adapted with the new bits of configuration and
new tests have been developed for the new feature.

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

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

[Joel Sing (jsing)]

review: Needs Fixing

[Benjamin Allot (ballot)]

Ah damn, I was rereading yesterday night but I missed quite a lot of consistency/debug stnzas. My bad.

About the separated tests:
I had done so in my previous configuration. However, it had his share of probem:
* a lot lot of files needed to be modified without adding any value (listen, backend haproxy ones notably)
* I had introduced a specific clause based on the name of the key to inject the enable_prometheus_metrics boolean to True. I found that error prone
After weighting the pros and cons, I ended up doing a separate file to test only the part relevant to the metrics exposure.

About the noqa, I had an issue using the form
```
patcher = mock.patch.multiple(....
patcher.start()
.
.
patcher.stop()
```

For some reason, the patcher.stop() was not removing the patch and I was ending with others tests failing.
I spent time trying to figure out why but could not find out so I use the context manager since it was "working".
I'm still looking for a more elegant solution to handle this but I figured it should not block the progress.

[Joel Sing (jsing)]

LGTM - per previous comment, before landing please rename config_test_nginx_metrics_config.txt (and site_with_nginx_metrics).

review: Approve (+1)

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

Change successfully merged at revision 3fa2dbc5cd782969d2b2bd3011f50275f4871dae

diff --git a/config.yaml b/config.yaml
index 7f6d083..cdc2408 100644
--- a/config.yaml
+++ b/config.yaml
@@ -40,3 +40,9 @@ options:
             origin-headers:
               X-Origin-Key: my-origin-secret-key
             signed-url-hmac-key: my-signed-url-secret-key
+  enable_prometheus_metrics:
+    default: true
+    type: boolean
+    description: |
+      Export metrics for the number of requests and the number of cache hits.
+      Prometheus metrics are exposed at /metrics on port 9145.
diff --git a/lib/nginx.py b/lib/nginx.py
index 055acc8..48ef4a9 100644
--- a/lib/nginx.py
+++ b/lib/nginx.py
@@ -6,8 +6,10 @@ import jinja2
 from lib import utils
 
 
-NGINX_BASE_PATH = '/etc/nginx'
 INDENT = ' ' * 4
+METRICS_PORT = 9145
+METRICS_SITE = 'nginx_metrics'
+NGINX_BASE_PATH = '/etc/nginx'
 # Subset of http://nginx.org/en/docs/http/ngx_http_proxy_module.html
 PROXY_CACHE_DEFAULTS = {
     'background-update': 'on',
@@ -23,8 +25,17 @@ class NginxConf:
     def __init__(self, conf_path=None):
         if not conf_path:
             conf_path = NGINX_BASE_PATH
-        self._conf_path = os.path.join(conf_path, 'conf.d')
-        self._sites_path = os.path.join(conf_path, 'sites-available')
+        self._base_path = conf_path
+        self._conf_path = os.path.join(self.base_path, 'conf.d')
+        self._sites_path = os.path.join(self.base_path, 'sites-available')
+        script_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+        self.jinja_env = jinja2.Environment(loader=jinja2.FileSystemLoader(script_dir))
+
+    # Expose base_path as a property to allow mocking in indirect calls to
+    # this class.
+    @property
+    def base_path(self):
+        return self._base_path
 
     # Expose conf_path as a property to allow mocking in indirect calls to
     # this class.
@@ -103,13 +114,71 @@ class NginxConf:
         data = {
             'address': conf['listen_address'],
             'cache_max_size': conf['cache_max_size'],
+            'enable_prometheus_metrics': conf['enable_prometheus_metrics'],
             'cache_path': conf['cache_path'],
             'locations': self._process_locations(conf['locations']),
             'name': self._generate_name(conf['site']),
             'port': conf['listen_port'],
             'site': conf['site'],
         }
-        base = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
-        env = jinja2.Environment(loader=jinja2.FileSystemLoader(base))
-        template = env.get_template('templates/nginx_cfg.tmpl')
+        template = self.jinja_env.get_template('templates/nginx_cfg.tmpl')
         return template.render(data)
+
+    def _remove_metrics_site(self, available, enabled):
+        """Remove the configuration exposing metrics.
+
+        :param str available: Path of the "available" site exposing the metrics
+        :param str enabled: Path of the "enabled" symlink to the "available" configuration
+        :returns: True if any change was made, False otherwise
+        :rtype: bool
+        """
+        changed = False
+        try:
+            os.remove(available)
+            changed = True
+        except FileNotFoundError:
+            pass
+        try:
+            os.remove(enabled)
+            changed = True
+        except FileNotFoundError:
+            pass
+
+        return changed
+
+    def toggle_metrics_site(self, enable_prometheus_metrics):
+        """Create/delete the metrics site configuration and links.
+
+        :param bool enable_prometheus_metrics: True if metrics are exposed to prometheus
+        :returns: True if any change was made, False otherwise
+        :rtype: bool
+        """
+        changed = False
+        metrics_site_conf = '{0}.conf'.format(METRICS_SITE)
+        available = os.path.join(self.sites_path, metrics_site_conf)
+        enabled = os.path.join(self.base_path, 'sites-enabled', metrics_site_conf)
+        # If no cache metrics, remove the site
+        if not enable_prometheus_metrics:
+            return self._remove_metrics_site(available, enabled)
+        template = self.jinja_env.get_template('templates/nginx_metrics_cfg.tmpl')
+        content = template.render({'nginx_conf_path': self.conf_path, 'port': METRICS_PORT})
+        # Check if contents changed
+        try:
+            with open(available, 'r', encoding='utf-8') as f:
+                current = f.read()
+        except FileNotFoundError:
+            current = ''
+        if content != current:
+            with open(available, 'w', encoding='utf-8') as f:
+                f.write(content)
+            changed = True
+            os.listdir(self.sites_path)
+        if not os.path.exists(enabled):
+            os.symlink(available, enabled)
+            changed = True
+        if os.path.realpath(available) != os.path.realpath(enabled):
+            os.remove(enabled)
+            os.symlink(available, enabled)
+            changed = True
+
+        return changed
diff --git a/nginx_config_rendered_test_output-nginx_metrics.txt b/nginx_config_rendered_test_output-nginx_metrics.txt
 new file mode 100644
index 0000000..a58a258
--- /dev/null
+++ b/nginx_config_rendered_test_output-nginx_metrics.txt
@@ -0,0 +1,32 @@
+proxy_cache_path /var/lib/nginx/proxy/nginx_metrics use_temp_path=off levels=1:2 keys_zone=nginx_metrics-cache:10m max_size=1g;
+
+server {
+    server_name nginx_metrics;
+    listen 127.0.0.1:6080;
+
+    port_in_redirect off;
+    absolute_redirect off;
+
+    location / {
+        proxy_pass http://localhost:8080;
+        proxy_set_header Host "nginx_metrics";
+        proxy_cache nginx_metrics-cache;
+        proxy_cache_background_update on;
+        proxy_cache_lock on;
+        proxy_cache_min_uses 1;
+        proxy_cache_revalidate on;
+        proxy_cache_use_stale error timeout updating http_500 http_502 http_503 http_504;
+        proxy_cache_valid 200 1d;
+
+        log_by_lua_block {
+          http_request_total:inc(1, {ngx.var.server_name, ngx.var.status})
+          if ngx.var.upstream_cache_status == "HIT" then
+              cache_request_hit_total:inc(1, {ngx.var.server_name})
+          end
+        }
+    }
+
+
+    access_log /var/log/nginx/nginx_metrics-access.log content_cache;
+    error_log /var/log/nginx/nginx_metrics-error.log;
+}
diff --git a/reactive/content_cache.py b/reactive/content_cache.py
index 03cd7bf..ae90822 100644
--- a/reactive/content_cache.py
+++ b/reactive/content_cache.py
@@ -65,6 +65,32 @@ def service_start_or_restart(name):
         host.service_start(name)
 
 
+def configure_nginx_metrics(ngx_conf, enable_prometheus_metrics):
+    """Configure nginx to expose metrics.
+
+    Create the dedicated server exposing the metrics and add the logging of the cache hits for the other sites.
+
+    :param bool enable_prometheus_metrics: True is the metrics should be exposed, False otherwise
+    :returns: True if any change was made, False otherwise
+    :rtype: bool
+    """
+    changed = False
+    if copy_file('files/prometheus.lua', os.path.join(ngx_conf.conf_path, 'prometheus.lua')):
+        changed = True
+    if ngx_conf.toggle_metrics_site(enable_prometheus_metrics):
+        changed = True
+    old_ports = [int(port.split('/')[0]) for port in hookenv.opened_ports()]
+    hookenv.log("Current opened ports: {}".format(old_ports))
+    if enable_prometheus_metrics and nginx.METRICS_PORT not in old_ports:
+        hookenv.log("Opening port {0}".format(nginx.METRICS_PORT))
+        hookenv.open_port(nginx.METRICS_PORT, 'TCP')
+    elif not enable_prometheus_metrics and nginx.METRICS_PORT in old_ports:
+        hookenv.log("Closing port {0}".format(nginx.METRICS_PORT))
+        hookenv.close_port(nginx.METRICS_PORT, 'TCP')
+
+    return changed
+
+
 @reactive.when_not('content_cache.nginx.configured')
 def configure_nginx(conf_path=None):
     status.maintenance('setting up Nginx as caching layer')
@@ -76,6 +102,8 @@ def configure_nginx(conf_path=None):
         status.blocked('requires list of sites to configure')
         return
 
+    enable_prometheus_metrics = config.get('enable_prometheus_metrics', False)
+
     ngx_conf = nginx.NginxConf(conf_path)
     sites_secrets = secrets_from_config(config.get('sites_secrets'))
     sites = sites_from_config(config.get('sites'), sites_secrets)
@@ -95,11 +123,19 @@ def configure_nginx(conf_path=None):
         conf['site'] = site_conf.get('site-name') or site
         conf['listen_port'] = site_conf['cache_port']
         conf['locations'] = site_conf.get('locations', {})
+        conf['enable_prometheus_metrics'] = enable_prometheus_metrics
 
         if ngx_conf.write_site(site, ngx_conf.render(conf)):
             hookenv.log('Wrote out new configs for site: {}'.format(site))
             changed = True
 
+    if configure_nginx_metrics(ngx_conf, enable_prometheus_metrics):
+        hookenv.log('nginx metrics exposed to prometheus')
+        changed = True
+
+    # Include the site exposing metrics if needed
+    if enable_prometheus_metrics:
+        sites[nginx.METRICS_SITE] = None
     if ngx_conf.sync_sites(sites.keys()):
         hookenv.log('Enabled sites: {}'.format(' '.join(sites.keys())))
         changed = True
diff --git a/templates/nginx_cfg.tmpl b/templates/nginx_cfg.tmpl
index 18d5488..031b3e0 100644
--- a/templates/nginx_cfg.tmpl
+++ b/templates/nginx_cfg.tmpl
@@ -100,7 +100,15 @@ server {
             args["token"] = nil
             ngx.req.set_uri_args(args)
         }
+{%- endif %}
+{%- if enable_prometheus_metrics %}
 
+        log_by_lua_block {
+          http_request_total:inc(1, {ngx.var.server_name, ngx.var.status})
+          if ngx.var.upstream_cache_status == "HIT" then
+              cache_request_hit_total:inc(1, {ngx.var.server_name})
+          end
+        }
 {%- endif %}
     }
 {% endfor %}
diff --git a/templates/nginx_metrics_cfg.tmpl b/templates/nginx_metrics_cfg.tmpl
 new file mode 100644
index 0000000..e048ffc
--- /dev/null
+++ b/templates/nginx_metrics_cfg.tmpl
@@ -0,0 +1,23 @@
+lua_shared_dict prometheus_metrics 10M;
+lua_package_path "{{ nginx_conf_path }}/?.lua";
+init_by_lua_block {
+  prometheus = require("prometheus").init("prometheus_metrics")
+  http_request_total = prometheus:counter(
+    "nginx_http_request_total", "Number of HTTP requests per site", {"host", "status"})
+  cache_request_hit_total = prometheus:counter(
+    "nginx_cache_request_hit_total", "Number of cache hits per site", {"host"})
+}
+
+server {
+  listen {{ port }};
+  allow all;
+  location /metrics {
+    content_by_lua_block {
+      prometheus:collect()
+    }
+  }
+
+  access_log /var/log/nginx/nginx_metrics-access.log;
+  error_log /var/log/nginx/nginx_metrics-error.log;
+}
+
diff --git a/tests/unit/files/config_test_basic_config.txt b/tests/unit/files/config_test_basic_config.txt
 new file mode 100644
index 0000000..6707563
--- /dev/null
+++ b/tests/unit/files/config_test_basic_config.txt
@@ -0,0 +1,6 @@
+basic_site:
+  port: 80
+  locations:
+    /:
+      backends:
+        - 127.0.1.10:80
diff --git a/tests/unit/files/nginx_config_rendered_test_output-basic_site.txt b/tests/unit/files/nginx_config_rendered_test_output-basic_site.txt
 new file mode 100644
index 0000000..90693e5
--- /dev/null
+++ b/tests/unit/files/nginx_config_rendered_test_output-basic_site.txt
@@ -0,0 +1,32 @@
+proxy_cache_path /var/lib/nginx/proxy/basic_site use_temp_path=off levels=1:2 keys_zone=basic_site-cache:10m max_size=1g;
+
+server {
+    server_name basic_site;
+    listen 127.0.0.1:6080;
+
+    port_in_redirect off;
+    absolute_redirect off;
+
+    location / {
+        proxy_pass http://localhost:8080;
+        proxy_set_header Host "basic_site";
+        proxy_cache basic_site-cache;
+        proxy_cache_background_update on;
+        proxy_cache_lock on;
+        proxy_cache_min_uses 1;
+        proxy_cache_revalidate on;
+        proxy_cache_use_stale error timeout updating http_500 http_502 http_503 http_504;
+        proxy_cache_valid 200 1d;
+
+        log_by_lua_block {
+          http_request_total:inc(1, {ngx.var.server_name, ngx.var.status})
+          if ngx.var.upstream_cache_status == "HIT" then
+              cache_request_hit_total:inc(1, {ngx.var.server_name})
+          end
+        }
+    }
+
+
+    access_log /var/log/nginx/basic_site-access.log content_cache;
+    error_log /var/log/nginx/basic_site-error.log;
+}
diff --git a/tests/unit/test_content_cache.py b/tests/unit/test_content_cache.py
index 3ac3749..c071022 100644
--- a/tests/unit/test_content_cache.py
+++ b/tests/unit/test_content_cache.py
@@ -6,6 +6,7 @@ import unittest
 from unittest import mock
 
 import freezegun
+import jinja2
 
 # We also need to mock up charms.layer so we can run unit tests without having
 # to build the charm and pull in layers such as layer-status.
@@ -16,6 +17,7 @@ from charms.layer import status  # NOQA: E402
 # Add path to where our reactive layer lives and import.
 sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))))
 from reactive import content_cache  # NOQA: E402
+from lib import nginx  # NOQA: E402
 
 
 class TestCharm(unittest.TestCase):
@@ -131,14 +133,17 @@ class TestCharm(unittest.TestCase):
         self.assertFalse(status.blocked.assert_called())
         self.assertFalse(clear_flag.assert_called_once_with('content_cache.active'))
 
+    @mock.patch('charmhelpers.core.hookenv.close_port')
+    @mock.patch('charmhelpers.core.hookenv.opened_ports')
     @mock.patch('reactive.content_cache.service_start_or_restart')
-    def test_configure_nginx_sites(self, service_start_or_restart):
+    def test_configure_nginx_sites(self, service_start_or_restart, opened_ports, close_port):
         '''Test configuration of Nginx sites'''
         with open('tests/unit/files/config_test_config.txt', 'r', encoding='utf-8') as f:
             ngx_config = f.read()
         self.mock_config.return_value = {
             'cache_max_size': '1g',
             'cache_path': '/var/lib/nginx/proxy',
+            'enable_prometheus_metrics': False,
             'sites': ngx_config,
         }
 
@@ -149,13 +154,18 @@ class TestCharm(unittest.TestCase):
             os.mkdir(os.path.join(self.tmpdir, 'conf.d'))
             os.mkdir(os.path.join(self.tmpdir, 'sites-available'))
             os.mkdir(os.path.join(self.tmpdir, 'sites-enabled'))
+            opened_ports.return_value = ['80/tcp', '{0}/tcp'.format(nginx.METRICS_PORT)]
             content_cache.configure_nginx(self.tmpdir)
             self.assertFalse(service_start_or_restart.assert_called_once_with('nginx'))
+            close_port.assert_called_once_with(nginx.METRICS_PORT, 'TCP')
 
             # Re-run with same set of sites, no change so shouldn't need to restart Nginx
             service_start_or_restart.reset_mock()
+            close_port.reset_mock()
+            opened_ports.return_value = ['80/tcp']
             content_cache.configure_nginx(self.tmpdir)
             self.assertFalse(service_start_or_restart.assert_not_called())
+            close_port.assert_not_called()
 
             for site in [
                 'site1.local',
@@ -165,6 +175,7 @@ class TestCharm(unittest.TestCase):
                 'site5',
                 'site6.local',
                 'site7.local',
+                'site8.local',
             ]:
                 with open(
                     'tests/unit/files/nginx_config_rendered_test_output-{}.txt'.format(site), 'r', encoding='utf-8'
@@ -183,8 +194,10 @@ class TestCharm(unittest.TestCase):
             got = f.read()
         self.assertEqual(got, want)
 
+    @mock.patch('charmhelpers.core.hookenv.close_port')
+    @mock.patch('charmhelpers.core.hookenv.opened_ports')
     @mock.patch('reactive.content_cache.service_start_or_restart')
-    def test_configure_nginx_sites_secrets(self, service_start_or_restart):
+    def test_configure_nginx_sites_secrets(self, service_start_or_restart, opened_ports, close_port):
         with open('tests/unit/files/config_test_secrets.txt', 'r', encoding='utf-8') as f:
             secrets = f.read()
         config = '''
@@ -227,9 +240,11 @@ site1.local:
                     got = f.read()
                 self.assertEqual(got, want)
 
+    @mock.patch('charmhelpers.core.hookenv.close_port')
+    @mock.patch('charmhelpers.core.hookenv.opened_ports')
     @mock.patch('shutil.disk_usage')
     @mock.patch('reactive.content_cache.service_start_or_restart')
-    def test_configure_nginx_cache_config(self, service_start_or_restart, disk_usage):
+    def test_configure_nginx_cache_config(self, service_start_or_restart, disk_usage, opened_ports, close_port):
         config = '''
 site1.local:
   locations:
@@ -671,3 +686,72 @@ site1.local:
                 content='test content\n', group='somegroup', owner='somedude', path=dest, perms=444
             )
         )
+
+    @mock.patch('charmhelpers.core.hookenv.open_port')
+    @mock.patch('charmhelpers.core.hookenv.opened_ports')
+    @mock.patch('reactive.content_cache.service_start_or_restart')
+    def test_configure_nginx_metrics_sites(self, service_start_or_restart, opened_ports, open_port):
+        """Test configuration of Nginx sites with enable_prometheus_metrics activated."""
+        with open('tests/unit/files/config_test_basic_config.txt', 'r', encoding='utf-8') as f:
+            ngx_config = f.read()
+        self.mock_config.return_value = {
+            'cache_max_size': '1g',
+            'enable_prometheus_metrics': True,
+            'cache_path': '/var/lib/nginx/proxy',
+            'sites': ngx_config,
+        }
+
+        with mock.patch.multiple(
+            'lib.nginx.NginxConf',
+            sites_path=os.path.join(self.tmpdir, 'sites-available'),
+            base_path=self.tmpdir,
+        ) as nginxconf_mock:  # noqa: F841
+            # conf.d, sites-available, and sites-enabled won't exist in our
+            # temporary directory.
+            os.mkdir(os.path.join(self.tmpdir, 'conf.d'))
+            os.mkdir(os.path.join(self.tmpdir, 'sites-available'))
+            os.mkdir(os.path.join(self.tmpdir, 'sites-enabled'))
+            opened_ports.return_value = ['80/tcp', '443/tcp']
+            content_cache.configure_nginx(self.tmpdir)
+            self.assertFalse(service_start_or_restart.assert_called_once_with('nginx'))
+            open_port.assert_called_once_with(nginx.METRICS_PORT, 'TCP')
+
+            # Re-run with same set of sites, no change so shouldn't need to restart Nginx
+            service_start_or_restart.reset_mock()
+            open_port.reset_mock()
+            opened_ports.return_value = ['80/tcp', '443/tcp', '{0}/tcp'.format(nginx.METRICS_PORT)]
+            content_cache.configure_nginx(self.tmpdir)
+            self.assertFalse(service_start_or_restart.assert_not_called())
+            open_port.assert_not_called()
+
+            # Test the site with cache HIT logging
+            site = 'basic_site'
+            test_file = 'tests/unit/files/nginx_config_rendered_test_output-{0}.txt'.format(site)
+            with open(test_file, 'r', encoding='utf-8') as f:
+                want = f.read()
+
+            test_file = os.path.join(self.tmpdir, 'sites-available/{0}.conf'.format(site))
+            with open(test_file, 'r', encoding='utf-8') as f:
+                got = f.read()
+            self.assertEqual(got, want)
+
+            # Test the site exposing the metrics
+            site = 'nginx_metrics'
+            script_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', '..')
+            jinja_env = jinja2.Environment(loader=jinja2.FileSystemLoader(script_dir))
+            template = jinja_env.get_template('templates/nginx_metrics_cfg.tmpl')
+            content = template.render({
+                'nginx_conf_path': os.path.join(self.tmpdir, 'conf.d'),
+                'port': nginx.METRICS_PORT})
+            want = content
+            test_file = os.path.join(self.tmpdir, 'sites-available/{0}.conf'.format(nginx.METRICS_SITE))
+            with open(test_file, 'r', encoding='utf-8') as f:
+                got = f.read()
+            self.assertEqual(got, want)
+
+        # Prometheus.lua library
+        with open('files/prometheus.lua', 'r') as f:
+            want = f.read()
+        with open(os.path.join(self.tmpdir, 'conf.d', 'prometheus.lua'), 'r') as f:
+            got = f.read()
+        self.assertEqual(got, want)
diff --git a/tests/unit/test_nginx.py b/tests/unit/test_nginx.py
index e9ec2f1..7097f7e 100644
--- a/tests/unit/test_nginx.py
+++ b/tests/unit/test_nginx.py
@@ -5,6 +5,8 @@ import tempfile
 import unittest
 import yaml
 
+import jinja2
+
 sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))))
 from lib import nginx  # NOQA: E402
 
@@ -21,10 +23,13 @@ class TestLibNginx(unittest.TestCase):
 
     def test_nginx_config_conf_path(self):
         conf_path = '/etc/nginx/conf.d'
+        alternate_conf_path = '/var/lib/snap/nginx/etc'
         ngx_conf = nginx.NginxConf()
         self.assertEqual(ngx_conf.conf_path, conf_path)
         ngx_conf = nginx.NginxConf(None)
         self.assertEqual(ngx_conf.conf_path, conf_path)
+        ngx_conf = nginx.NginxConf(alternate_conf_path)
+        self.assertEqual(ngx_conf.base_path, alternate_conf_path)
 
     def test_nginx_config_sites_path(self):
         sites_path = '/etc/nginx/sites-available'
@@ -34,7 +39,7 @@ class TestLibNginx(unittest.TestCase):
         self.assertEqual(ngx_conf.sites_path, sites_path)
 
     def test_nginx_config_render(self):
-        '''Test parsing a YAML-formatted list of sites'''
+        """Test parsing a YAML-formatted list of sites."""
         ngx_conf = nginx.NginxConf()
 
         with open('tests/unit/files/config_test_config.txt', 'r', encoding='utf-8') as f:
@@ -42,6 +47,7 @@ class TestLibNginx(unittest.TestCase):
 
         conf = {}
         conf['cache_max_size'] = '1g'
+        conf['enable_prometheus_metrics'] = False
         conf['cache_path'] = '/var/lib/nginx/proxy'
         conf['listen_address'] = '127.0.0.1'
         # From the given YAML-formatted list of sites, check that each individual
@@ -66,7 +72,7 @@ class TestLibNginx(unittest.TestCase):
             self.assertEqual(ngx_conf.render(conf), output)
 
     def test_nginx_config_write_sites(self):
-        '''Test writing out sites to individual Nginx site config files'''
+        """Test writing out sites to individual Nginx site config files."""
         ngx_conf = nginx.NginxConf(self.tmpdir)
         os.mkdir(os.path.join(self.tmpdir, 'sites-available'))
         os.mkdir(os.path.join(self.tmpdir, 'sites-enabled'))
@@ -113,3 +119,78 @@ class TestLibNginx(unittest.TestCase):
 
         # Re-run, no change this time.
         self.assertFalse(ngx_conf.sync_sites(['site1.local', 'site2.local']))
+
+    def test_nginx_config_render_with_metrics(self):
+        """Test rendering with metrics exposed."""
+        ngx_conf = nginx.NginxConf()
+
+        with open('tests/unit/files/config_test_basic_config.txt', 'r', encoding='utf-8') as f:
+            sites = yaml.safe_load(f.read())
+
+        conf = {
+            'cache_max_size': '1g',
+            'cache_path': '/var/lib/nginx/proxy',
+            'listen_address': '127.0.0.1',
+            'enable_prometheus_metrics': True,
+        }
+        for site, site_conf in sites.items():
+            conf['site'] = site_conf.get('site-name') or site
+            conf['listen_port'] = BASE_LISTEN_PORT
+            conf['locations'] = site_conf.get('locations', {})
+
+            for location, loc_conf in conf['locations'].items():
+                if loc_conf.get('backends'):
+                    loc_conf['backend_port'] = BASE_BACKEND_PORT
+
+            output_file = 'tests/unit/files/nginx_config_rendered_test_output-{}.txt'.format(site)
+            with open(output_file, 'r', encoding='utf-8') as f:
+                output = f.read()
+
+            self.assertEqual(ngx_conf.render(conf), output)
+
+    def test_nginx_config_toggle_metrics_site(self):
+        """Test the metrics site.
+
+        Check that the activation fo the cache metrics activate the dedicated site for exposing prometheus metrics.
+        """
+        ngx_conf = nginx.NginxConf(self.tmpdir)
+        os.mkdir(os.path.join(self.tmpdir, 'sites-available'))
+        os.mkdir(os.path.join(self.tmpdir, 'sites-enabled'))
+
+        metrics_site_conf = '{0}.conf'.format(nginx.METRICS_SITE)
+
+        script_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', '..')
+        env = jinja2.Environment(loader=jinja2.FileSystemLoader(script_dir))
+        template = env.get_template('templates/nginx_metrics_cfg.tmpl')
+        content = template.render({
+            'nginx_conf_path': os.path.join(self.tmpdir, 'conf.d'),
+            'port': nginx.METRICS_PORT})
+        nginx_metrics_conf = content
+
+        metrics_site_available = os.path.join(self.tmpdir, 'sites-available', metrics_site_conf)
+        metrics_site_enabled = os.path.join(self.tmpdir, 'sites-enabled', metrics_site_conf)
+        self.assertTrue(ngx_conf.toggle_metrics_site(enable_prometheus_metrics=True))
+        # Write again with same contents, this time it should return 'False'
+        # as there's no change, thus no need to restart/reload Nginx.
+        self.assertFalse(ngx_conf.toggle_metrics_site(enable_prometheus_metrics=True))
+        self.assertTrue(os.path.exists(metrics_site_available))
+
+        # Compare what's been written out matches what's in tests/unit/files.
+        with open(metrics_site_available, 'r', encoding='utf-8') as f:
+            output = f.read()
+        self.assertEqual(nginx_metrics_conf, output)
+
+        # Check link existence
+        self.assertTrue(os.path.islink(metrics_site_enabled))
+
+        # Mess up with the target of the link and check that a toggle fixes it
+        os.remove(metrics_site_enabled)
+        os.symlink('/dev/null', metrics_site_enabled)
+        self.assertTrue(ngx_conf.toggle_metrics_site(enable_prometheus_metrics=True))
+        self.assertTrue(os.path.realpath(metrics_site_available) == os.path.realpath(metrics_site_enabled))
+
+        # Remove the site
+        self.assertTrue(ngx_conf.toggle_metrics_site(enable_prometheus_metrics=False))
+        self.assertFalse(ngx_conf.toggle_metrics_site(enable_prometheus_metrics=False))
+        self.assertFalse(os.path.exists(metrics_site_available))
+        self.assertFalse(os.path.exists(metrics_site_enabled))