bump 6.3.2

update types to correct transformLabels

.eslintrc

@@ -17,6 +17,7 @@
   "extends": "eslint:recommended",
 
   "rules": {
+    "indent": [1, 2],
     "array-bracket-spacing": [2, "never"],
     "block-scoped-var": 2,
     "brace-style": [2, "1tbs"],

.gitignore

@@ -1,3 +1,5 @@
 .npmrc
 node_modules
 coverage
+/.vscode
+

.npmignore

@@ -1,6 +0,0 @@
-advanced-example.js
-docker-compose.yml
-spec
-.travis.yml
-.eslintrc
-coverage

.travis.yml

@@ -1,5 +1,13 @@
 language: node_js
 node_js:
-    - "6"
-    - "5"
-    - "4"
+    - "10"
+    - "12"
+    - "14"
+notifications:
+    email: false
+before_install:
+    - npm install prom-client
+script:
+    - npm run lint
+    - npm test
+    - npm run dtslint-next

Makefile

@@ -4,6 +4,7 @@ test:
 	./node_modules/jasme/run.js
 lint:
 	node_modules/eslint/bin/eslint.js src
+	node_modules/.bin/dtslint types
 coverage:
 	node_modules/istanbul/lib/cli.js cover \
 		-i 'src/*' \

README.md

@@ -2,29 +2,27 @@
 
 # express prometheus bundle
 
-Express middleware with popular prometheus metrics in one bundle. It's also compatible with koa v1 (see below).
+Express middleware with popular prometheus metrics in one bundle. It's also compatible with koa v1 and v2 (see below).
 
-Internally it uses **prom-client**. See: https://github.com/siimon/prom-client
+Since version 5 it uses **prom-client** as a peer dependency. See: https://github.com/siimon/prom-client
 
 Included metrics:
 
 * `up`: normally is just 1
-* `http_request_duration_seconds`: http latency histogram labeled with `status_code`, `method` and `path`
-
-**Please note version 2.x is NOT backwards compatible with 1.x**
+* `http_request_duration_seconds`: http latency histogram/summary labeled with `status_code`, `method` and `path`
 
 ## Install
 
 ```
-npm install express-prom-bundle
+npm install prom-client express-prom-bundle
 ```
 
-## Usage
+## Sample Usage
 
 ```javascript
 const promBundle = require("express-prom-bundle");
-const metricsMiddleware = promBundle({/* options */ });
 const app = require("express")();
+const metricsMiddleware = promBundle({includeMethod: true});
 
 app.use(metricsMiddleware);
 app.use(/* your middleware */);
@@ -44,40 +42,100 @@ See the example below.
 
 ## Options
 
-* **buckets**: buckets used for `http_request_seconds` histogram
-* **includeMethod**: include HTTP method (GET, PUT, ...) as a label to `http_request_duration_seconds`
-* **includePath**: include URL path as a label (see below)
-* **normalizePath**: boolean or `function(req)` - path normalization for `includePath` option
+Which labels to include in `http_request_duration_seconds` metric:
+
+* **includeStatusCode**: HTTP status code (200, 400, 404 etc.), default: **true**
+* **includeMethod**: HTTP method (GET, PUT, ...), default: **false**
+* **includePath**: URL path (see important details below), default: **false**
+* **customLabels**: an object containing extra labels, e.g. ```{project_name: 'hello_world'}```.
+  Most useful together with **transformLabels** callback, otherwise it's better to use native Prometheus relabeling.
+* **includeUp**: include an auxiliary "up"-metric which always returns 1, default: **true**
+* **metricsPath**: replace the `/metrics` route with a **regex** or exact **string**. Note: it is highly recommended to just stick to the default
+* **metricType**: histogram/summary selection. See more details below
+* **bypass**: function taking express request as an argument and determines whether the given request should be excluded in the metrics, default: **() => false**
+
+### metricType option ###
+
+Two metric types are supported for `http_request_duration_seconds` metric:
+* [histogram](https://prometheus.io/docs/concepts/metric_types/#histogram) (default)
+* [summary](https://prometheus.io/docs/concepts/metric_types/#summary)
+
+Additional options for **histogram**:
+* **buckets**: buckets used for the `http_request_duration_seconds` histogram
+
+Additional options for **summary**:
+* **percentiles**: percentiles used for `http_request_duration_seconds` summary
+* **ageBuckets**: ageBuckets configures how many buckets we have in our sliding window for the summary
+* **maxAgeSeconds**: the maxAgeSeconds will tell how old a bucket can be before it is reset
+
+### Transformation callbacks ###
+
+* **normalizePath**: `function(req)`  or `Array`
+  * if function is provided, then it should generate path value from express `req`
+  * if array is provided, then it should be an array of tuples `[regex, replacement]`. The `regex` can be a string and is automatically converted into JS regex.
+  * ... see more details in the section below
+* **urlValueParser**: options passed when instantiating [url-value-parser](https://github.com/disjunction/url-value-parser).
+  This is the easiest way to customize which parts of the URL should be replaced with "#val".
+  See the [docs](https://github.com/disjunction/url-value-parser) of url-value-parser module for details.
+* **formatStatusCode**: `function(res)` producing final status code from express `res` object, e.g. you can combine `200`, `201` and `204` to just `2xx`.
+* **transformLabels**: `function(labels, req, res)` transforms the **labels** object, e.g. setting dynamic values to **customLabels**
+
+### Other options ###
+
 * **autoregister**: if `/metrics` endpoint should be registered. (Default: **true**)
-* **whitelist**, **blacklist**: array of strings or regexp specifying which metrics to include/exclude
-* **excludeRoutes**: (deprecated) array of strings or regexp specifying which routes should be skipped for `http_request_duration_seconds` metric. It uses `req.originalUrl` as subject when checking. You want normally use express or meddleware features instead of this options.
+* **promClient**: options for promClient startup, e.g. **collectDefaultMetrics**. This option was added
+  to keep `express-prom-bundle` runnable using confit (e.g. with kraken.js) without writing any JS code,
+  see [advanced example](https://github.com/jochen-schweizer/express-prom-bundle/blob/master/advanced-example.js)
+* **promRegistry**: Optional `promClient.Registry` instance to attach metrics to. Defaults to global `promClient.register`.
 
 ### More details on includePath option
 
-The goal is to have separate latency statistics by URL path, e.g. `/my-app/user/`, `/products/by-category` etc.
+Let's say you want to have  latency statistics by URL path,
+e.g. separate metrics for `/my-app/user/`, `/products/by-category` etc.
 
 Just taking `req.path` as a label value won't work as IDs are often part of the URL,
 like `/user/12352/profile`. So what we actually need is a path template.
 The module tries to figure out what parts of the path are values or IDs,
 and what is an actual path. The example mentioned before would be
 normalized to `/user/#val/profile` and that will become the value for the label.
+These conversions are handled by `normalizePath` function.
 
-You can override this magical behavior and define your own function by
-providing an optional callback using **normalizePath** option.
-You can also replace the default **normalizePath** function globally.
-This is handy if the rest of the middleware is done elsewhere
-e.g. via `kraken.js meddleware`.
+You can extend this magical behavior by providing
+additional RegExp rules to be performed,
+or override `normalizePath` with your own function.
+
+#### Example 1 (add custom RegExp):
+
+```javascript
+app.use(promBundle({
+  normalizePath: [
+    // collect paths like "/customer/johnbobson" as just one "/custom/#name"
+    ['^/customer/.*', '/customer/#name'],
+
+    // collect paths like "/bobjohnson/order-list" as just one "/#name/order-list"
+    ['^.*/order-list', '/#name/order-list']
+  ],
+  urlValueParser: {
+    minHexLength: 5,
+    extraMasks: [
+      'ORD[0-9]{5,}' // replace strings like ORD1243423, ORD673562 as #val
+    ]
+  }
+}));
+```
+
+#### Example 2 (override normalizePath function):
 
 ```javascript
 app.use(promBundle(/* options? */));
 
 // let's reuse the existing one and just add some
 // functionality on top
-const originalNormalize = promBunle.normalizePath;
-promBunle.normalizePath = (req, opts) => {
+const originalNormalize = promBundle.normalizePath;
+promBundle.normalizePath = (req, opts) => {
   const path = originalNormalize(req, opts);
-  // count all docs (no matter which file) as a single path
-  return path.match(/^\/docs/) ? '/docs/*' : path;
+  // count all docs as one path, but /docs/login as a separate one
+  return (path.match(/^\/docs/) && !path.match(/^\/login/)) ? '/docs/*' : path;
 };
 ```
 
@@ -86,7 +144,6 @@ For more details:
  * [normalizePath.js](https://github.com/jochen-schweizer/express-prom-bundle/blob/master/src/normalizePath.js) - source code for path processing
 
 
-
 ## express example
 
 setup std. metrics but exclude `up`-metric:
@@ -116,24 +173,62 @@ app.listen(3000);
 
 See an [advanced example on github](https://github.com/jochen-schweizer/express-prom-bundle/blob/master/advanced-example.js)
 
-## koa v1 example
+## koa v2 example
 
 ```javascript
 const promBundle = require("express-prom-bundle");
-const koa = require("koa");
+const Koa = require("koa");
 const c2k = require("koa-connect");
 const metricsMiddleware = promBundle({/* options */ });
 
-const app = koa();
+const app = new Koa();
 
 app.use(c2k(metricsMiddleware));
 app.use(/* your middleware */);
 app.listen(3000);
 ```
 
+## using with cluster
+
+You'll need to use an additional **clusterMetrics()** middleware.
+
+In the example below the master process will expose an API with a single endpoint `/metrics`
+which returns an aggregate of all metrics from all the workers.
+
+``` javascript
+const cluster = require('cluster');
+const promBundle = require('./src/index');
+const numCPUs = Math.max(2, require('os').cpus().length);
+const express = require('express');
+
+if (cluster.isMaster) {
+    for (let i = 1; i < numCPUs; i++) {
+        cluster.fork();
+    }
+
+    const metricsApp = express();
+    metricsApp.use('/metrics', promBundle.clusterMetrics());
+    metricsApp.listen(9999);
+
+    console.log('cluster metrics listening on 9999');
+    console.log('call localhost:9999/metrics for aggregated metrics');
+} else {
+    const app = express();
+    app.use(promBundle({
+        autoregister: false, // disable /metrics for single workers
+        includeMethod: true
+    }));
+    app.use((req, res) => res.send(`hello from pid ${process.pid}\n`));
+    app.listen(3000);
+    console.log(`worker ${process.pid} listening on 3000`);
+}
+```
+
 ## using with kraken.js
 
-Here is meddleware config sample, which can be used in a standard **kraken.js** application:
+Here is meddleware config sample, which can be used in a standard **kraken.js** application.
+In this case the stats for URI paths and HTTP methods are collected separately,
+while replacing all HEX values starting from 5 characters and all IP addresses in the path as #val.
 
 ```json
 {
@@ -146,7 +241,18 @@ Here is meddleware config sample, which can be used in a standard **kraken.js**
         "arguments": [
           {
             "includeMethod": true,
-            "buckets": [0.1, 1, 5]
+            "includePath": true,
+            "buckets": [0.1, 1, 5],
+            "promClient": {
+              "collectDefaultMetrics": {
+              }
+            },
+            "urlValueParser": {
+              "minHexLength": 5,
+              "extraMasks": [
+                "^[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+$"
+              ]
+            }
           }
         ]
       }
@@ -155,26 +261,6 @@ Here is meddleware config sample, which can be used in a standard **kraken.js**
 }
 ```
 
-## Changelog
-
- * **2.1.0**
-    * deprecate **excludeRoutes**, use **req.originalPath** instead of **req.path**
- * **2.0.0**
-    * the reason for the version lift were:
-      * compliance to official naming recommendation: https://prometheus.io/docs/practices/naming/
-      * stopping promotion of an anti-pattern - see https://groups.google.com/d/msg/prometheus-developers/XjlOnDCK9qc/ovKzV3AIBwAJ
-      * dealing with **prom-client** being a singleton with a built-in registry
-    * main histogram metric renamed from `http_request_seconds` to `http_request_duration_seconds`
-    * options removed: **prefix**, **keepDefaultMetrics**
-    * factory removed (as the only reason of it was adding the prefix)
-    * upgrade prom-client to 6.3.0
-    * code style changed to the one closer to express
-
-
- * **1.2.1**
-    * upgrade prom-client to 6.1.2
-    * add options: includeMethod, includePath, keepDefaultMetrics
-
 ## License
 
 MIT

advanced-example.js

@@ -2,24 +2,35 @@
 
 const express = require('express');
 const app = express();
+const promClient = require('prom-client');
 const promBundle = require('express-prom-bundle');
 
-// here we want to remove default metrics provided in prom-client
-// this must be done before initializing promBundle
-clearInterval(promBundle.promClient.defaultMetrics());
-promBundle.promClient.register.clear();
-
 const bundle = promBundle({
-  blacklist: [/up/],
   buckets: [0.1, 0.4, 0.7],
   includeMethod: true,
-  includePath: true
+  includePath: true,
+  customLabels: {year: null},
+  transformLabels: labels => Object.assign(labels, {year: new Date().getFullYear()}),
+  metricsPath: '/prometheus',
+  promClient: {
+    collectDefaultMetrics: {
+    }
+  },
+  urlValueParser: {
+    minHexLength: 5,
+    extraMasks: [
+      "^[0-9]+\\.[0-9]+\\.[0-9]+$" // replace dot-separated dates with #val
+    ]
+  },
+  normalizePath: [
+    ['^/foo', '/example'] // replace /foo with /example
+  ]
 });
 
 app.use(bundle);
 
 // native prom-client metric (no prefix)
-const c1 = new bundle.promClient.Counter('c1', 'c1 help');
+const c1 = new promClient.Counter({name: 'c1', help: 'c1 help'});
 c1.inc(10);
 
 app.get('/foo/:id', (req, res) => {
@@ -35,10 +46,13 @@ app.delete('/foo/:id', (req, res) => {
 app.get('/bar', (req, res) => res.send('bar response\n'));
 
 app.listen(3000, () => console.info(  // eslint-disable-line
-  'listening on 3000\n'
-  + 'test in shell console\n\n'
-  + 'curl localhost:3000/foo/1234\n'
-  + 'curl -X DELETE localhost:3000/foo/5432\n'
-  + 'curl localhost:3000/bar\n'
-  + 'curl localhost:3000/metrics\n'
+  `listening on 3000
+test in shell console:
+
+curl localhost:3000/foo/1234
+curl localhost:3000/foo/09.08.2018
+curl -X DELETE localhost:3000/foo/5432
+curl localhost:3000/bar
+curl localhost:3000/prometheus
+`
 ));

package.json

@@ -1,6 +1,6 @@
 {
   "name": "express-prom-bundle",
-  "version": "2.1.0",
+  "version": "6.3.2",
   "description": "express middleware with popular prometheus metrics in one bundle",
   "main": "src/index.js",
   "keywords": [
@@ -10,29 +10,47 @@
     "path",
     "method"
   ],
+  "files": [
+    "src",
+    "types/index.d.ts"
+  ],
+  "types": "types",
   "scripts": {
-    "test": "node_modules/jasme/run.js"
+    "test": "node_modules/jasme/run.js",
+    "lint": "eslint src",
+    "coverage": "make coverage",
+    "dtslint": "dtslint types",
+    "dtslint-next": "dtslint --onlyTestTsNext types"
   },
   "author": "Konstantin Pogorelov <or@pluseq.com>",
   "license": "MIT",
   "dependencies": {
     "on-finished": "^2.3.0",
-    "prom-client": "^6.3.0",
-    "url-value-parser": "^1.0.0"
+    "url-value-parser": "^2.0.0"
   },
   "devDependencies": {
-    "coveralls": "^2.11.15",
-    "eslint": "^3.11.1",
-    "express": "^4.14.0",
+    "@types/express": "^4.16.1",
+    "coveralls": "^3.0.2",
+    "dtslint": "^0.7.1",
+    "eslint": "^5.11.0",
+    "express": "^4.16.4",
     "istanbul": "^0.4.5",
-    "jasme": "^5.2.0",
-    "koa": "^1.2.4",
-    "koa-connect": "^1.0.0",
-    "supertest": "^2.0.1",
-    "supertest-koa-agent": "^0.3.0"
+    "jasme": "^6.0.0",
+    "koa": "^2.6.2",
+    "koa-connect": "^2.0.1",
+    "prom-client": "^13.0.0",
+    "supertest": "^3.3.0",
+    "supertest-koa-agent": "^0.3.0",
+    "typescript": "^3.4.5"
+  },
+  "peerDependencies": {
+    "prom-client": ">=12.0.0"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/jochen-schweizer/express-prom-bundle.git"
+  },
+  "engines": {
+    "node": ">=10"
   }
 }

spec/index.spec.js

@@ -4,10 +4,11 @@
 const express = require('express');
 const supertest = require('supertest');
 const bundle = require('../');
-const koa = require('koa');
+const Koa = require('koa');
 const c2k = require('koa-connect');
 const supertestKoa = require('supertest-koa-agent');
 const promClient = require('prom-client');
+const cluster = require('cluster');
 
 describe('index', () => {
   beforeEach(() => {
@@ -17,7 +18,7 @@ describe('index', () => {
   it('metrics returns up=1', done => {
     const app = express();
     const bundled = bundle({
-      whitelist: ['up']
+      excludeRoutes: ['/irrelevant', /at.all/]
     });
     app.use(bundled);
     app.use('/test', (req, res) => res.send('it worked'));
@@ -34,12 +35,83 @@ describe('index', () => {
     });
   });
 
-  it('metrics should be attached to /metrics by default', done => {
+  it('"up"-metric can be excluded', done => {
     const app = express();
     const bundled = bundle({
-      whitelist: ['up']
+      includeUp: false
     });
     app.use(bundled);
+    app.use('/test', (req, res) => res.send('it worked'));
+
+    const agent = supertest(app);
+    agent.get('/test').end(() => {
+      agent
+        .get('/metrics')
+        .end((err, res) => {
+          expect(res.status).toBe(200);
+          expect(res.text).not.toMatch(/up\s1/);
+          done();
+        });
+    });
+  });
+
+  it('metrics path can be defined with a regex', done => {
+    const app = express();
+    const bundled = bundle({
+      metricsPath: /^\/prometheus$/
+    });
+    app.use(bundled);
+    app.use('/test', (req, res) => res.send('it worked'));
+
+    const agent = supertest(app);
+    agent.get('/test').end(() => {
+      agent
+        .get('/prometheus')
+        .end((err, res) => {
+          expect(res.status).toBe(200);
+          expect(res.text).toMatch(/up\s1/);
+          done();
+        });
+    });
+  });
+
+  it('metrics path can be defined as regexp', done => {
+    const app = express();
+    const bundled = bundle();
+    app.use(bundled);
+    app.use('/test', (req, res) => res.send('it worked'));
+
+    const agent = supertest(app);
+    agent.get('/test').end(() => {
+      agent
+        .get('/metrics')
+        .end((err, res) => {
+          expect(res.status).toBe(200);
+          expect(res.text).toMatch(/up\s1/);
+          done();
+        });
+    });
+  });
+
+  it('httpDurationMetricName overrides histogram metric name', done => {
+    const app = express();
+    const bundled = bundle({
+      httpDurationMetricName: 'my_http_duration'
+    });
+    app.use(bundled);
+
+    const agent = supertest(app);
+    agent.get('/metrics')
+      .end((err, res) => {
+        expect(res.text).toMatch(/my_http_duration/m);
+        done();
+      });
+  });
+
+  it('metrics should be attached to /metrics by default', done => {
+    const app = express();
+    const bundled = bundle();
+    app.use(bundled);
 
     const agent = supertest(app);
     agent.get('/metrics')
@@ -67,27 +139,6 @@ describe('index', () => {
       });
   });
 
-  it('metrics can be filtered using exect match', () => {
-    const instance = bundle({blacklist: ['up']});
-    expect(instance.metrics.up).not.toBeDefined();
-    expect(instance.metrics.http_request_duration_seconds).toBeDefined();
-  });
-  it('metrics can be filtered using regex', () => {
-    const instance = bundle({blacklist: [/http/]});
-    expect(instance.metrics.up).toBeDefined();
-    expect(instance.metrics.http_request_duration_seconds).not.toBeDefined();
-  });
-  it('metrics can be whitelisted', () => {
-    const instance = bundle({whitelist: [/^up$/]});
-    expect(instance.metrics.up).toBeDefined();
-    expect(instance.metrics.nodejs_memory_heap_total_bytes).not.toBeDefined();
-    expect(instance.metrics.http_request_duration_seconds).not.toBeDefined();
-  });
-  it('throws on both white and blacklist', () => {
-    expect(() => {
-      bundle({whitelist: [/up/], blacklist: [/up/]});
-    }).toThrow();
-  });
   it('returns error 500 on incorrect middleware usage', done => {
     const app = express();
     app.use(bundle);
@@ -124,22 +175,67 @@ describe('index', () => {
   it('filters out the excludeRoutes', done => {
     const app = express();
     const instance = bundle({
-      excludeRoutes: ['/test']
+      excludeRoutes: ['/test', /bad.word/]
     });
     app.use(instance);
     app.use('/test', (req, res) => res.send('it worked'));
+    app.use('/some/bad-word', (req, res) => res.send('it worked too'));
     const agent = supertest(app);
     agent
       .get('/test')
       .end(() => {
-        const metricHashMap = instance.metrics.http_request_duration_seconds.hashMap;
-        expect(metricHashMap['status_code:200']).not.toBeDefined();
-
         agent
-          .get('/metrics')
-          .end((err, res) => {
-            expect(res.status).toBe(200);
-            done();
+          .get('/some/bad-word')
+          .end(() => {
+            const metricHashMap = instance.metrics.http_request_duration_seconds.hashMap;
+            expect(metricHashMap['status_code:200']).not.toBeDefined();
+
+            agent
+              .get('/metrics')
+              .end((err, res) => {
+                expect(res.status).toBe(200);
+                done();
+              });
+          });
+      });
+  });
+
+  it('bypass requests', done => {
+    const app = express();
+    const instance = bundle({
+      bypass: (req)=> {
+        // metrics added here to attempt skipping /metrics
+        // this should fail though, because serving /metrics preceeds bypassing
+        return !!req.url.match(/test|bad.word|metrics/)
+      }
+    });
+    app.use(instance);
+    app.use('/test', (req, res) => res.send('it worked'));
+    app.use('/some/bad-word', (req, res) => res.send('it worked too'));
+    app.use('/good-word', (req, res) => res.send('this will be counted'));
+    const agent = supertest(app);
+    agent
+      .get('/test')
+      .end(() => {
+        agent
+          .get('/some/bad-word')
+          .end(() => {
+            agent
+              .get('/good-word')
+              .end(() => {
+                const metricHashMap = instance.metrics.http_request_duration_seconds.hashMap;
+                expect(metricHashMap['status_code:200']).toBeDefined();
+
+                // only /good-word should be counted
+                expect(metricHashMap['status_code:200'].count).toBe(1);
+
+                agent
+                  .get('/metrics')
+                  .end((err, res) => {
+                    expect(res.status).toBe(200);
+                    done();
+                  });
+              });
           });
       });
   });
@@ -148,11 +244,12 @@ describe('index', () => {
     expect(() => bundle({prefix: 'hello'})).toThrow();
   });
 
-  it('tolerates includePath, includeMethod', done => {
+  it('tolerates includePath, includeMethod, includeCustomLabels', done => {
     const app = express();
     const instance = bundle({
       includePath: true,
-      includeMethod: true
+      includeMethod: true,
+      includeCustomLabels: {foo: 'bar'}
     });
     app.use(instance);
     app.use('/test', (req, res) => res.send('it worked'));
@@ -169,12 +266,111 @@ describe('index', () => {
       });
   });
 
-  it('normalizePath can be replaced', done => {
+  it('metric type histogram works', done => {
+    const app = express();
+    const bundled = bundle({
+      metricType: 'histogram',
+      buckets: [10, 100],
+    });
+    app.use(bundled);
+    app.use('/test', (req, res) => res.send('it worked'));
+
+    const agent = supertest(app);
+    agent.get('/test').end(() => {
+      agent
+        .get('/metrics')
+        .end((err, res) => {
+          expect(res.status).toBe(200);
+          expect(res.text).toMatch(/le="100"/);
+          done();
+        });
+    });
+  });
+
+  it('throws on unknown metricType ', () => {
+    expect(() => {
+      bundle({metricType: 'hello'});
+    }).toThrow();
+  });
+
+  describe('usage of normalizePath()', () => {
+
+    it('normalizePath can be replaced gloablly', done => {
+      const app = express();
+      const original = bundle.normalizePath;
+      bundle.normalizePath = () => 'dummy';
+      const instance = bundle({
+        includePath: true,
+      });
+      app.use(instance);
+      app.use('/test', (req, res) => res.send('it worked'));
+      const agent = supertest(app);
+      agent
+        .get('/test')
+        .end(() => {
+          agent
+            .get('/metrics')
+            .end((err, res) => {
+              expect(res.status).toBe(200);
+              expect(res.text).toMatch(/"dummy"/m);
+              bundle.normalizePath = original;
+              done();
+            });
+        });
+    });
+
+    it('normalizePath function can be overridden', done => {
+      const app = express();
+      const instance = bundle({
+        includePath: true,
+        normalizePath: req => req.originalUrl + '-suffixed'
+      });
+      app.use(instance);
+      app.use('/test', (req, res) => res.send('it worked'));
+      const agent = supertest(app);
+      agent
+        .get('/test')
+        .end(() => {
+          agent
+            .get('/metrics')
+            .end((err, res) => {
+              expect(res.status).toBe(200);
+              expect(res.text).toMatch(/"\/test-suffixed"/m);
+              done();
+            });
+        });
+    });
+
+    it('normalizePath can be passed as an array of [regex, replacement]', done => {
+      const app = express();
+      const instance = bundle({
+        includePath: true,
+        normalizePath: [
+          ['^/docs/whatever/.*$', '/docs'],
+          [/^\/docs$/, '/mocks']
+        ]
+      });
+      app.use(instance);
+      app.use('/docs/whatever/:andmore', (req, res) => res.send('it worked'));
+      const agent = supertest(app);
+      agent
+        .get('/docs/whatever/unimportant')
+        .end(() => {
+          agent
+            .get('/metrics')
+            .end((err, res) => {
+              expect(res.status).toBe(200);
+              expect(res.text).toMatch(/"\/mocks"/m);
+              done();
+            });
+        });
+    });
+  });
+
+  it('formatStatusCode can be overridden', done => {
     const app = express();
-    const original = bundle.normalizePath;
-    bundle.normalizePath = () => 'dummy';
     const instance = bundle({
-      includePath: true,
+      formatStatusCode: () => 555
     });
     app.use(instance);
     app.use('/test', (req, res) => res.send('it worked'));
@@ -186,25 +382,88 @@ describe('index', () => {
           .get('/metrics')
           .end((err, res) => {
             expect(res.status).toBe(200);
-            expect(res.text).toMatch(/"dummy"/m);
-            bundle.normalizePath = original;
+            expect(res.text).toMatch(/555/);
+            done();
+          });
+      });
+  });
+
+  it('includeStatusCode=false removes status_code label from metrics', done => {
+    const app = express();
+    const instance = bundle({
+      includeStatusCode: false
+    });
+    app.use(instance);
+    app.use('/test', (req, res) => res.send('it worked'));
+    const agent = supertest(app);
+    agent
+      .get('/test')
+      .end(() => {
+        agent
+          .get('/metrics')
+          .end((err, res) => {
+            expect(res.status).toBe(200);
+            expect(res.text).not.toMatch(/="200"/);
+            done();
+          });
+      });
+  });
+
+  it('customLabels={foo: "bar"} adds foo="bar" label to metrics', done => {
+    const app = express();
+    const instance = bundle({
+      customLabels: {foo: 'bar'}
+    });
+    app.use(instance);
+    app.use('/test', (req, res) => res.send('it worked'));
+    const agent = supertest(app);
+    agent
+      .get('/test')
+      .end(() => {
+        agent
+          .get('/metrics')
+          .end((err, res) => {
+            expect(res.status).toBe(200);
+            expect(res.text).toMatch(/foo="bar"/);
+            done();
+          });
+      });
+  });
+
+  it('tarnsformLabels can set label values', done => {
+    const app = express();
+    const instance = bundle({
+      includePath: true,
+      customLabels: {foo: 'bar'},
+      transformLabels: labels => {
+        labels.foo = 'baz';
+        labels.path += '/ok';
+      }
+    });
+    app.use(instance);
+    app.use('/test', (req, res) => res.send('it worked'));
+    const agent = supertest(app);
+    agent
+      .get('/test')
+      .end(() => {
+        agent
+          .get('/metrics')
+          .end((err, res) => {
+            expect(res.status).toBe(200);
+            expect(res.text).toMatch(/foo="baz"/);
+            expect(res.text).toMatch(/path="\/test\/ok"/);
             done();
           });
       });
   });
 
   it('Koa: metrics returns up=1', done => {
-    const app = koa();
-    const bundled = bundle({
-      whitelist: ['up']
-    });
+    const app = new Koa();
+    const bundled = bundle();
     app.use(c2k(bundled));
 
-    app.use(function*(next) {
-      if (this.path !== 'test') {
-        return yield next;
-      }
-      this.body = 'it worked';
+    app.use(function(ctx, next) {
+      return next().then(() => ctx.body = 'it worked');
     });
 
     const agent = supertestKoa(app);
@@ -218,4 +477,97 @@ describe('index', () => {
         });
     });
   });
+
+  it('calls promClient.collectDefaultMetrics', () => {
+    const spy = spyOn(promClient, 'collectDefaultMetrics');
+    bundle({
+      promClient: {
+        collectDefaultMetrics: {
+        }
+      }
+    });
+    expect(spy).toHaveBeenCalledWith({});
+  });
+
+  describe('usage of clusterMetrics()', () => {
+    it('clusterMetrics returns 200 even without a cluster', (done) => {
+        const app = express();
+
+        cluster.workers = [];
+
+        app.use('/cluster_metrics', bundle.clusterMetrics());
+        const agent = supertest(app);
+        agent
+          .get('/cluster_metrics')
+          .end((err, res) => {
+            expect(res.status).toBe(200);
+            done();
+          });
+    });
+
+    it('clusterMetrics returns 500 in case of an error', (done) => {
+      const app = express();
+      app.use('/cluster_metrics', bundle.clusterMetrics());
+      const agent = supertest(app);
+
+      // create a fake worker, which would not respond in time
+      cluster.workers = [{
+        isConnected: () => true,
+        send: () => {}
+      }];
+
+      const errorSpy = spyOn(console, 'error'); // mute console.error
+
+      agent
+        .get('/cluster_metrics')
+        .end((err, res) => {
+          expect(res.status).toBe(500);
+          expect(errorSpy).toHaveBeenCalled();
+          done();
+        });
+    }, 6000);
+  });
+
+  describe('metricType: summary', () => {
+    it('metric type summary works', done => {
+      const app = express();
+      const bundled = bundle({
+        metricType: 'summary'
+      });
+      app.use(bundled);
+      app.use('/test', (req, res) => res.send('it worked'));
+
+      const agent = supertest(app);
+      agent.get('/test').end(() => {
+        agent
+          .get('/metrics')
+          .end((err, res) => {
+            expect(res.status).toBe(200);
+            expect(res.text).toMatch(/quantile="0.98"/);
+            done();
+          });
+      });
+    });
+
+    it('custom pecentiles work', done => {
+      const app = express();
+      const bundled = bundle({
+        metricType: 'summary',
+        percentiles: [0.5, 0.85, 0.99],
+      });
+      app.use(bundled);
+      app.use('/test', (req, res) => res.send('it worked'));
+
+      const agent = supertest(app);
+      agent.get('/test').end(() => {
+        agent
+          .get('/metrics')
+          .end((err, res) => {
+            expect(res.status).toBe(200);
+            expect(res.text).toMatch(/quantile="0.85"/);
+            done();
+          });
+      });
+    });
+  });
 });

spec/normalizePath.spec.js

@@ -4,25 +4,28 @@
 const normalizePath = require('../src/normalizePath');
 
 describe('normalizePath', () => {
-  it('returns original if disabled in opts', () => {
-    expect(
-     normalizePath({originalUrl: '/a/12345'}, {normalizePath: false})
-    ).toBe('/a/12345');
-  });
-
-  it('returns run callback if configured', () => {
-    expect(
-      normalizePath(
-        {originalUrl: '/a/12345'},
-        {
-          normalizePath: req => req.originalUrl + '-ok'
-        }
-      )
-    ).toBe('/a/12345-ok');
-  });
-
   it('uses UrlValueParser by default', () => {
-    expect(normalizePath({originalUrl: '/a/12345'}))
+    expect(normalizePath({url: '/a/12345'}))
       .toBe('/a/#val');
   });
+
+  it('uses normalizePath option', () => {
+    const url = '/hello/world/i/am/finally/free!!!';
+    const result = normalizePath({url}, {
+      normalizePath: [
+        ['/hello','/goodbye'],
+        ['[^/]+$','happy'],
+      ]
+    });
+    expect(result).toBe('/goodbye/world/i/am/finally/happy');
+  });
+
+  it('throws error is bad tuples provided as normalizePath', () => {
+    const subject = () => normalizePath({url: '/test'}, {
+      normalizePath: [
+        ['/hello','/goodbye', 'test']
+      ]
+    });
+    expect(subject).toThrow();
+  });
 });

spec/normalizeStatusCode.spec.js

@@ -0,0 +1,12 @@
+'use strict';
+/* eslint-env jasmine */
+
+const normalizeStatusCode = require('../src/normalizeStatusCode');
+
+describe('normalizeStatusCode', () => {
+  it('returns run callback if configured', () => {
+    expect(
+      normalizeStatusCode({status_code: 500})
+    ).toBe(500);
+  });
+});

src/index.js

@@ -1,10 +1,10 @@
-'use strict';
 const onFinished = require('on-finished');
 const promClient = require('prom-client');
 const normalizePath = require('./normalizePath');
+const normalizeStatusCode = require('./normalizeStatusCode');
 
 function matchVsRegExps(element, regexps) {
-  for (let regexp of regexps) {
+  for (const regexp of regexps) {
     if (regexp instanceof RegExp) {
       if (element.match(regexp)) {
         return true;
@@ -16,29 +16,41 @@ function matchVsRegExps(element, regexps) {
   return false;
 }
 
-function filterArrayByRegExps(array, regexps) {
-  return array.filter(element => {
-    return matchVsRegExps(element, regexps);
-  });
-}
+function clusterMetrics() {
+  const aggregatorRegistry = new promClient.AggregatorRegistry();
 
-function prepareMetricNames(opts, metricTemplates) {
-  const names = Object.keys(metricTemplates);
-  if (opts.whitelist) {
-    if (opts.blacklist) {
-      throw new Error('you cannot have whitelist and blacklist at the same time');
+  const metricsMiddleware = function(req, res) {
+    function sendClusterMetrics(clusterMetrics) {
+      res.set('Content-Type', aggregatorRegistry.contentType);
+      res.send(clusterMetrics);
     }
-    return filterArrayByRegExps(names, opts.whitelist);
-  }
-  if (opts.blacklist) {
-    const blacklisted = filterArrayByRegExps(names, opts.blacklist);
-    return names.filter(name => blacklisted.indexOf(name) === -1);
-  }
-  return names;
+
+    function sendClusterMetricsError(err) {
+      console.error(err);
+      return res.sendStatus(500);
+    }
+
+    // since prom-client@13 clusterMetrics() method doesn't take cb param,
+    // but we provide it anyway, as at this stage it's unknown which version of prom-client is used
+    const response = aggregatorRegistry.clusterMetrics((err, clusterMetrics) => {
+      if (err) {
+        return sendClusterMetricsError(err);
+      }
+      sendClusterMetrics(clusterMetrics);
+    });
+
+    // if we find out that it was a promise and our cb was useless...
+    if (response && response.then) {
+      response
+        .then(result => sendClusterMetrics(result))
+        .catch(err => sendClusterMetricsError(err));
+    }
+  };
+
+  return metricsMiddleware;
 }
 
 function main(opts) {
-  opts = Object.assign({autoregister: true}, opts);
   if (arguments[2] && arguments[1] && arguments[1].send) {
     arguments[1].status(500)
       .send('<h1>500 Error</h1>\n'
@@ -48,95 +60,157 @@ function main(opts) {
     return;
   }
 
-  if (opts.prefix || opts.keepDefaultMetrics !== undefined) {
+  opts = Object.assign(
+    {
+      autoregister: true,
+      includeStatusCode: true,
+      normalizePath: main.normalizePath,
+      formatStatusCode: main.normalizeStatusCode,
+      metricType: 'histogram',
+      promClient: {},
+      promRegistry: promClient.register
+    }, opts
+  );
+
+  if (opts.prefix
+    || opts.keepDefaultMetrics !== undefined
+    || opts.whitelist !== undefined
+    || opts.blacklist !== undefined
+  ) {
     throw new Error(
-      'express-prom-bundle detected obsolete options:'
-      + 'prefix and/or keepDefaultMetrics. '
+      'express-prom-bundle detected one of the obsolete options: '
+      + 'prefix, keepDefaultMetrics, whitelist, blacklist. '
       + 'Please refer to oficial docs. '
-      + 'Most likely you upgraded the module without necessary code changes'
+      + 'Most likely you upgraded the module without the necessary code changes'
     );
   }
 
-  const httpMtricName = opts.httpDurationMetricName || 'http_request_duration_seconds';
-
-  const metricTemplates = {
-    'up': () => new promClient.Gauge(
-      'up',
-      '1 = up, 0 = not up'
-    ),
-    'http_request_duration_seconds': () => {
-      const labels = ['status_code'];
-      if (opts.includeMethod) {
-        labels.push('method');
-      }
-      if (opts.includePath) {
-        labels.push('path');
-      }
-      const metric = new promClient.Histogram(
-        httpMtricName,
-        'duration histogram of http responses labeled with: ' + labels.join(', '),
-        labels,
-        {
-          buckets: opts.buckets || [0.003, 0.03, 0.1, 0.3, 1.5, 10]
-        }
-      );
-      return metric;
-    }
-  };
-
-  const metrics = {};
-  const names = prepareMetricNames(opts, metricTemplates);
-
-  for (let name of names) {
-    metrics[name] = metricTemplates[name]();
+  if (opts.promClient.collectDefaultMetrics) {
+    promClient.collectDefaultMetrics(opts.promClient.collectDefaultMetrics);
   }
 
-  if (metrics.up) {
+  const httpMetricName = opts.httpDurationMetricName || 'http_request_duration_seconds';
+
+  function makeHttpMetric() {
+    const labels = ['status_code'];
+    if (opts.includeMethod) {
+      labels.push('method');
+    }
+    if (opts.includePath) {
+      labels.push('path');
+    }
+    if (opts.customLabels) {
+      labels.push.apply(labels, Object.keys(opts.customLabels));
+    }
+
+    if (opts.metricType === 'summary') {
+      return new promClient.Summary({
+        name: httpMetricName,
+        help: 'duration summary of http responses labeled with: ' + labels.join(', '),
+        labelNames: labels,
+        percentiles: opts.percentiles || [0.5, 0.75, 0.95, 0.98, 0.99, 0.999],
+        maxAgeSeconds:  opts.maxAgeSeconds,
+        ageBuckets: opts.ageBuckets,
+        registers: [opts.promRegistry]
+      });
+    } else if (opts.metricType === 'histogram' || !opts.metricType) {
+      return new promClient.Histogram({
+        name: httpMetricName,
+        help: 'duration histogram of http responses labeled with: ' + labels.join(', '),
+        labelNames: labels,
+        buckets: opts.buckets || [0.003, 0.03, 0.1, 0.3, 1.5, 10],
+        registers: [opts.promRegistry]
+      });
+    } else {
+      throw new Error('metricType option must be histogram or summary');
+    }
+  }
+
+  const metrics = {
+    [httpMetricName]: makeHttpMetric()
+  };
+
+  if (opts.includeUp !== false) {
+    metrics.up = new promClient.Gauge({
+      name: 'up',
+      help: '1 = up, 0 = not up',
+      registers: [opts.promRegistry]
+    });
     metrics.up.set(1);
   }
 
-  const metricsMiddleware = function(req, res) {
+  const metricsMiddleware = function(req, res, next) {
     res.writeHead(200, {'Content-Type': 'text/plain'});
-    res.end(promClient.register.metrics());
+
+    const metricsResponse = opts.promRegistry.metrics();
+    // starting from prom-client@13 .metrics() returns a Promise
+    if (metricsResponse.then) {
+      metricsResponse
+        .then(output => res.end(output))
+        .catch(err => next(err));
+    } else {
+      // compatibility fallback for previous versions of prom-client@<=12
+      res.end(metricsResponse);
+    }
   };
 
-  const middleware = function (req, res, next) {
-    const path = req.originalUrl;
-    let labels;
+  const metricsMatch = opts.metricsPath instanceof RegExp ? opts.metricsPath
+    : new RegExp('^' + (opts.metricsPath || '/metrics') + '/?$');
 
-    if (opts.autoregister && path.match(/^\/metrics\/?$/)) {
+  const middleware = function (req, res, next) {
+    const path = req.originalUrl || req.url; // originalUrl gets lost in koa-connect?
+
+    if (opts.autoregister && path.match(metricsMatch)) {
       return metricsMiddleware(req, res);
     }
 
+    // bypass() is checked only after /metrics was processed
+    // if you wish to disable /metrics use autoregister:false instead
+    if (opts.bypass && opts.bypass(req)) {
+      return next();
+    }
+
     if (opts.excludeRoutes && matchVsRegExps(path, opts.excludeRoutes)) {
       return next();
     }
 
-    if (metrics[httpMtricName]) {
-      labels = {'status_code': 0};
-      let timer = metrics[httpMtricName].startTimer(labels);
-      onFinished(res, () => {
-        labels.status_code = res.statusCode;
-        if (opts.includeMethod) {
-          labels.method = req.method;
-        }
-        if (opts.includePath) {
-          labels.path = main.normalizePath(req, opts);
-        }
-        timer();
-      });
-    }
+    const labels = {};
+    const timer = metrics[httpMetricName].startTimer(labels);
+
+    onFinished(res, () => {
+      if (opts.includeStatusCode) {
+        labels.status_code = opts.formatStatusCode(res, opts);
+      }
+      if (opts.includeMethod) {
+        labels.method = req.method;
+      }
+      if (opts.includePath) {
+        labels.path = opts.normalizePath instanceof Function
+          ? opts.normalizePath(req, opts)
+          : main.normalizePath(req, opts);
+      }
+      if (opts.customLabels) {
+        Object.assign(labels, opts.customLabels);
+      }
+      if (opts.transformLabels) {
+        opts.transformLabels(labels, req, res);
+      }
+      timer();
+    });
 
     next();
   };
 
-  middleware.metricTemplates = metricTemplates;
   middleware.metrics = metrics;
   middleware.promClient = promClient;
   middleware.metricsMiddleware = metricsMiddleware;
   return middleware;
 }
 
+// this is kept only for compatibility with the code relying on older version
 main.promClient = promClient;
+
 main.normalizePath = normalizePath;
+main.normalizeStatusCode = normalizeStatusCode;
+main.clusterMetrics = clusterMetrics;
 module.exports = main;

src/normalizePath.js

@@ -2,26 +2,29 @@
 
 const UrlValueParser = require('url-value-parser');
 const url = require('url');
+
+// ATTENTION! urlValueParser is a singleton!
 let urlValueParser;
 
 module.exports = function(req, opts) {
-  opts = opts || {};
-
   // originalUrl is taken, because url and path can be changed
   // by middlewares such as 'router'. Note: this function is called onFinish
   /// i.e. always in the tail of the middleware chain
-  const path = url.parse(req.originalUrl).pathname;
+  let path = url.parse(req.originalUrl || req.url).pathname;
 
-  if (opts.normalizePath !== undefined && !opts.normalizePath) {
-    return path;
-  }
-  if (typeof opts.normalizePath === 'function') {
-    return opts.normalizePath(req, opts);
+  const normalizePath = opts && opts.normalizePath;
+  if (Array.isArray(normalizePath)) {
+    for (const tuple of normalizePath) {
+      if (!Array.isArray(tuple) || tuple.length !== 2) {
+        throw new Error('Bad tuple provided in normalizePath option, expected: [regex, replacement]');
+      }
+      const regex = typeof tuple[0] === 'string' ? RegExp(tuple[0]) : tuple[0];
+      path = path.replace(regex, tuple[1]);
+    }
   }
 
   if (!urlValueParser) {
-    urlValueParser = new UrlValueParser();
+    urlValueParser = new UrlValueParser(opts && opts.urlValueParser);
   }
   return urlValueParser.replacePathValues(path);
 };
-

src/normalizeStatusCode.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function(res) {
+  return res.status_code || res.statusCode;
+};

types/index.d.ts

@@ -0,0 +1,66 @@
+// TypeScript Version: 2.8
+
+import { Request, RequestHandler, Response } from 'express';
+import { DefaultMetricsCollectorConfiguration, Registry } from 'prom-client';
+
+export {};
+
+export = express_prom_bundle;
+
+declare namespace express_prom_bundle {
+  interface Labels {
+    [key: string]: string | number;
+  }
+
+  type NormalizePathEntry = [string | RegExp, string];
+  type NormalizePathFn = (req: Request, opts: Opts) => string;
+  type NormalizeStatusCodeFn = (res: Response) => number | string;
+  type TransformLabelsFn = (labels: Labels, req: Request, res: Response) => void;
+
+  interface Opts {
+    autoregister?: boolean;
+    buckets?: number[];
+
+    customLabels?: { [key: string]: any };
+
+    includeStatusCode?: boolean;
+    includeMethod?: boolean;
+    includePath?: boolean;
+    includeUp?: boolean;
+
+    bypass?: (req: Request) => boolean;
+
+    metricType?: 'summary' | 'histogram';
+    metricsPath?: string;
+    httpDurationMetricName?: string;
+    promClient?: { collectDefaultMetrics?: DefaultMetricsCollectorConfiguration };
+    promRegistry?: Registry;
+    normalizePath?: NormalizePathEntry[] | NormalizePathFn;
+    formatStatusCode?: NormalizeStatusCodeFn;
+    transformLabels?: TransformLabelsFn;
+
+    // https://github.com/disjunction/url-value-parser#options
+    urlValueParser?: {
+      minHexLength?: number;
+      minBase64Length?: number;
+      replaceMasks?: string[];
+      extraMasks?: string[];
+    };
+  }
+
+  interface Middleware extends RequestHandler {
+    metricsMiddleware: RequestHandler;
+  }
+
+  const normalizePath: NormalizePathFn;
+  const normalizeStatusCode: NormalizeStatusCodeFn;
+
+  function clusterMetrics(): RequestHandler;
+}
+
+interface express_prom_bundle {
+  normalizePath: express_prom_bundle.NormalizePathFn;
+  normalizeStatusCode: express_prom_bundle.NormalizeStatusCodeFn;
+}
+
+declare function express_prom_bundle(opts: express_prom_bundle.Opts): express_prom_bundle.Middleware;

types/test.ts

@@ -0,0 +1,79 @@
+import { Request, RequestHandler, Response } from 'express';
+import * as promClient from 'prom-client';
+
+import * as promBundle from 'express-prom-bundle';
+
+// $ExpectType Middleware
+const middleware: RequestHandler = promBundle({ includeMethod: true });
+
+// $ExpectType: string
+middleware.name;
+
+promClient.register.clear();
+
+// $ExpectType Middleware
+promBundle({
+  normalizePath: [
+    // collect paths like "/customer/johnbobson" as just one "/custom/#name"
+    ['^/customer/.*', '/customer/#name'],
+
+    // collect paths like "/bobjohnson/order-list" as just one "/#name/order-list"
+    ['^.*/order-list', '/#name/order-list']
+  ],
+  urlValueParser: {
+    minHexLength: 5,
+    extraMasks: [
+      'ORD[0-9]{5,}' // replace strings like ORD1243423, ORD673562 as #val
+    ]
+  }
+});
+
+promClient.register.clear();
+
+// $ExpectType Middleware
+promBundle({
+  buckets: [0.1, 0.4, 0.7],
+  includeMethod: true,
+  includePath: true,
+  customLabels: { year: null },
+  transformLabels: (labels: promBundle.Labels) => ({
+    ...labels,
+    year: new Date().getFullYear()
+  }),
+  metricType: 'summary',
+  metricsPath: '/prometheus',
+  promClient: {
+    collectDefaultMetrics: {
+    }
+  },
+  promRegistry: new promClient.Registry(),
+  urlValueParser: {
+    minHexLength: 5,
+    extraMasks: [
+      '^[0-9]+\\.[0-9]+\\.[0-9]+$' // replace dot-separated dates with #val
+    ]
+  },
+  normalizePath: [
+    ['^/foo', '/example'] // replace /foo with /example
+  ],
+  formatStatusCode: (res: Response) => res.statusCode + 100
+});
+
+// TypeScript workaround to write a readonly field
+type Writable<T> = { -readonly [K in keyof T]: T[K] };
+const wPromBundle: Writable<promBundle> = promBundle;
+
+wPromBundle.normalizePath = (req: Request, opts: promBundle.Opts) => {
+  const path = promBundle.normalizePath(req, opts);
+
+  // count all docs as one path, but /docs/login as a separate one
+  return path.match(/^\/docs/) && !path.match(/^\/login/) ? '/docs/*' : path;
+};
+
+wPromBundle.normalizeStatusCode = (res: Response) => res.statusCode.toString();
+
+// $ExpectType RequestHandler
+promBundle.clusterMetrics();
+
+// Missing test
+// const stringReturn: string = promBundle.normalizePath({}, {});

types/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "lib": ["es6"],
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "baseUrl": ".",
+    "paths": { "express-prom-bundle": ["."] },
+    "noEmit": true,
+    "forceConsistentCasingInFileNames": true
+  }
+}

types/tslint.json

@@ -0,0 +1,3 @@
+{
+  "extends": "dtslint/dtslint.json"
+}