Require default values

* prom-client JSON to InfluxDB line protocol converter

* Converts a metric with separate names

* prom-client JSON to InfluxDB line protocol (version 2) converter

* Server has instance id

* Read the instance id from an environment variable

* More unit tests for instance-metadata

* Log instance id

* Push influx metrics

* INSTANCE_ID with dyno metadata

* Prepare influx metrics in one place

* Influx metrics endpoint should return metrics

* More readable tests

* Env added to instance metadata

* hostname as an instance label value

* HEROKU_DYNO_ID as an instance id for heroku

* Instance env can be set by env variable

* HEROKU_APP_NAME as an instance env

* Log instance metadata as a JSON

* Typo fix

* Code refactoring in tests

* wait-for-expect dev dependency added

* Test for pushing metrics

* Test for pushing metrics

* Use basic authentication for pushing metrics

* intervalSeconds=2 for development env

* Using existing methods

* TODOs removed

* Schema for influx credentials

* Influx config removed from config files

* Require username and password when influx metrics are enabled

* Unused args removed

* pushing component should log errors

* Speed up tests

* should log error responses

* InstanceMetadata class replaces by simple object

* Influx metrics can be configuredd by env variables

* Use application label name instead of service

* Unused code removed

* Integration test for prom-client and converter

* metrics.influx.enabled configuration option added

* Improved influx configuration schema

* instanceMetadata validation

* Typo fix

* Default value for env

* metrics.infux.hostnameAsAInstanceId added

* should add hostname as an instance label when hostnameAsAInstanceId is enabled

* Default values for influx configuration

* flatMap is not available in Node.js 9.4

* Env vars removed from Procfile

* Better instance metadata values in tests

* Typo fix

* lodash.groupby added to prod dependencies

* Allow other keys in private config

* Missing test - should allow other private keys when influx metrics are enabled

* Missing test - should require private metrics config when influx configuration is enabled

* log.error instead of console.log

* metrics.influx.uri -> metrics.influx.url

* Unused arguments removed

* async removed

* promisify sendMetrics

* Allow to disable prometheus metrics

* Create test server with custom config

* 'metrics-influx' resource removed

* 'metrics-influx' resource removed

* Private config schema flattened out

* Extra code removed in Prometheus tests

* promisify moved outside of the class

* Do not throw errors from got in a specific test

* hostnameAliases added

* instanceIdFrom added

* instanceIdEnvVarName added

* envLabel added to schema

* instanceMetadata is not used by InfluxMetrics

* Instance metadata removed

* hostnameAsAnInstanceId removed

* A comment added

* waitForExpect removed

* Unused code removed

.circleci/config.yml

@@ -4,12 +4,6 @@ main_steps: &main_steps
   steps:
     - checkout
 
-    - restore_cache:
-        keys:
-          - v2-dependencies-{{ checksum "package-lock.json" }}
-          # https://github.com/badges/shields/issues/1937
-          - v2-dependencies-
-
     - run:
         name: Install dependencies
         command: npm ci
@@ -18,11 +12,6 @@ main_steps: &main_steps
           # We don't need to install the Cypress binary in jobs that aren't actually running Cypress.
           CYPRESS_INSTALL_BINARY: 0
 
-    - save_cache:
-        paths:
-          - node_modules
-        key: v2-dependencies-{{ checksum "package-lock.json" }}
-
     - run:
         name: Linter
         when: always
@@ -56,12 +45,6 @@ integration_steps: &integration_steps
   steps:
     - checkout
 
-    - restore_cache:
-        keys:
-          - v2-dependencies-{{ checksum "package-lock.json" }}
-          # https://github.com/badges/shields/issues/1937
-          - v2-dependencies-
-
     - run:
         name: Install dependencies
         command: npm ci
@@ -83,12 +66,6 @@ services_steps: &services_steps
   steps:
     - checkout
 
-    - restore_cache:
-        keys:
-          - v2-dependencies-{{ checksum "package-lock.json" }}
-          # https://github.com/badges/shields/issues/1937
-          - v2-dependencies-
-
     - run:
         name: Install dependencies
         command: npm ci
@@ -125,12 +102,6 @@ package_steps: &package_steps
   steps:
     - checkout
 
-    - restore_cache:
-        keys:
-          - v2-dependencies-{{ checksum "package-lock.json" }}
-          # https://github.com/badges/shields/issues/1937
-          - v2-dependencies-
-
     - run:
         name: Install dependencies
         command: |
@@ -181,23 +152,12 @@ jobs:
     steps:
       - checkout
 
-      - restore_cache:
-          keys:
-            - v2-dependencies-{{ checksum "package-lock.json" }}
-            # fallback to using the latest cache if no exact match is found
-            - v2-dependencies-
-
       - run:
           name: Install dependencies
           command: npm ci
           environment:
             CYPRESS_INSTALL_BINARY: 0
 
-      - save_cache:
-          paths:
-            - node_modules
-          key: v2-dependencies-{{ checksum "package-lock.json" }}
-
   main:
     docker:
       - image: circleci/node:8
@@ -230,12 +190,6 @@ jobs:
     steps:
       - checkout
 
-      - restore_cache:
-          keys:
-            - v2-dependencies-{{ checksum "package-lock.json" }}
-            # https://github.com/badges/shields/issues/1937
-            - v2-dependencies-
-
       - run:
           name: Install dependencies
           command: npm ci
@@ -256,12 +210,6 @@ jobs:
     steps:
       - checkout
 
-      - restore_cache:
-          keys:
-            - v2-dependencies-{{ checksum "package-lock.json" }}
-            # https://github.com/badges/shields/issues/1937
-            - v2-dependencies-
-
       - run:
           name: Install dependencies
           command: npm ci
@@ -315,13 +263,6 @@ jobs:
     steps:
       - checkout
 
-      - restore_cache:
-          name: Restore node_modules
-          keys:
-            - v2-dependencies-{{ checksum "package-lock.json" }}
-            # https://github.com/badges/shields/issues/1937
-            - v2-dependencies-
-
       - restore_cache:
           name: Restore Cypress binary
           keys:

.dependabot/config.yml

@@ -4,6 +4,104 @@ update_configs:
   - package_manager: 'javascript'
     directory: '/'
     update_schedule: 'weekly'
+    automerged_updates:
+      - match:
+          dependency_name: 'chai*'
+          update_type: 'semver:minor'
+      - match:
+          dependency_name: 'cypress'
+          update_type: 'semver:minor'
+      - match:
+          dependency_name: 'eslint*'
+          update_type: 'semver:minor'
+      - match:
+          dependency_name: 'enzyme*'
+          update_type: 'semver:minor'
+      - match:
+          dependency_name: 'mocha*'
+          update_type: 'semver:minor'
+      - match:
+          dependency_name: 'sazerac'
+          update_type: 'semver:minor'
+      - match:
+          dependency_name: 'sinon*'
+          update_type: 'semver:minor'
+      - match:
+          dependency_name: 'snap-shot-it'
+          update_type: 'semver:minor'
+    ignored_updates:
+      - match:
+          dependency_name: babel-preset-gatsby
+          version_requirement: '>=0.3.0'
+      - match:
+          dependency_name: camelcase
+          version_requirement: '>=6.0.0'
+      - match:
+          dependency_name: chalk
+          version_requirement: '>=4.0.0'
+      - match:
+          dependency_name: cross-env
+          version_requirement: '>=7.0.0'
+      - match:
+          dependency_name: decamelize
+          version_requirement: '>=4.0.0'
+      - match:
+          dependency_name: escape-string-regexp
+          version_requirement: '>=3.0.0'
+      - match:
+          dependency_name: eslint-plugin-jsdoc
+          version_requirement: '>=21.0.0'
+      - match:
+          dependency_name: gatsby
+          version_requirement: '>=2.19.50'
+      - match:
+          dependency_name: gatsby-plugin-catch-links
+          version_requirement: '>=2.2.0'
+      - match:
+          dependency_name: gatsby-plugin-page-creator
+          version_requirement: '>=2.2.0'
+      - match:
+          dependency_name: gatsby-plugin-react-helmet
+          version_requirement: '>=3.2.0'
+      - match:
+          dependency_name: gatsby-plugin-remove-trailing-slashes
+          version_requirement: '>=2.2.0'
+      - match:
+          dependency_name: gatsby-plugin-styled-components
+          version_requirement: '>=3.2.0'
+      - match:
+          dependency_name: gatsby-plugin-typescript
+          version_requirement: '>=2.3.0'
+      - match:
+          dependency_name: got
+          version_requirement: '>=10.0.0'
+      - match:
+          dependency_name: '@hapi/joi'
+          version_requirement: '>=17.0.0'
+      - match:
+          dependency_name: husky
+          version_requirement: '>=4.0.0'
+      - match:
+          dependency_name: lint-staged
+          version_requirement: '>=10.0.0'
+      - match:
+          dependency_name: nock
+          version_requirement: '>=12.0.0'
+      - match:
+          dependency_name: prom-client
+          version_requirement: '>=12.0.0'
+      - match:
+          dependency_name: react-error-overlay
+          version_requirement: '>=3.0.0'
+      - match:
+          dependency_name: sinon
+          version_requirement: '>=9.0.0'
+      - match:
+          dependency_name: start-server-and-test
+          version_requirement: '>=1.10.8'
+      - match:
+          dependency_name: xmldom
+          version_requirement: '>=0.3.0'
 
   # gh-badges package dependencies
   - package_manager: 'javascript'

.eslintrc.yml

@@ -1,7 +1,8 @@
 extends:
-  - standard-jsx
+  - standard
   - standard-react
   - plugin:@typescript-eslint/recommended
+  - prettier
   - prettier/@typescript-eslint
   - prettier/standard
   - prettier/react
@@ -39,7 +40,6 @@ overrides:
       es6: true
     rules:
       no-console: 'off'
-      '@typescript-eslint/no-var-requires': off
 
   - files:
       - '**/*.@(ts|tsx)'
@@ -48,8 +48,13 @@ overrides:
     parser: '@typescript-eslint/parser'
     rules:
       # Argh.
-      '@typescript-eslint/explicit-function-return-type': 'off'
+      '@typescript-eslint/explicit-function-return-type':
+        ['error', { 'allowExpressions': true }]
+      '@typescript-eslint/no-empty-function': 'error'
+      '@typescript-eslint/no-var-requires': 'error'
       '@typescript-eslint/no-object-literal-type-assertion': 'off'
+      '@typescript-eslint/no-explicit-any': 'error'
+      '@typescript-eslint/ban-ts-ignore': 'off'
 
   - files:
       - core/**/*.ts
@@ -113,9 +118,9 @@ rules:
   # Allow unused parameters. In callbacks, removing them seems to obscure
   # what the functions are doing.
   '@typescript-eslint/no-unused-vars': ['error', { 'args': 'none' }]
-  no-unused-vars: off
+  no-unused-vars: 'off'
 
-  '@typescript-eslint/no-var-requires': error
+  '@typescript-eslint/no-var-requires': 'off'
 
   # These should be disabled by eslint-config-prettier, but are not.
   no-extra-semi: 'off'
@@ -163,6 +168,8 @@ rules:
 
   # Disable some from TypeScript.
   '@typescript-eslint/camelcase': off
+  '@typescript-eslint/explicit-function-return-type': 'off'
+  '@typescript-eslint/no-empty-function': 'off'
 
   react/jsx-sort-props: 'error'
   react-hooks/rules-of-hooks: 'error'

.github/workflows/auto-approve.yml

@@ -0,0 +1,10 @@
+name: Auto approve
+on: pull_request
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: chris48s/approve-bot@1.0.0
+        with:
+          github-token: '${{ secrets.GITHUB_TOKEN }}'

.gitignore

@@ -113,3 +113,6 @@ service-definitions.yml
 
 # Rendered API docs
 /api-docs/
+
+# Flamebearer
+flamegraph.html

CONTRIBUTING.md

@@ -104,12 +104,8 @@ There are three places to get help:
 
 ## Badge URLs
 
-- The format of new badges should be of the form
-  `/SERVICE/NOUN/PARAMETERS/QUALIFIERS`. For instance,
-  `/gitter/room/nwjs/nw.js`. The vendor is gitter, the
-  badge is for rooms, and the parameter is nwjs/nw.js.
-- Services which require a url/hostname parameter should use a query parameter to accept that value. For instance,
-  `/discourse/topics?server=https://meta.discourse.org`.
+- The format of new badges should be of the form `/SERVICE/NOUN/PARAMETERS`.
+- There is further documentation on this in [badge-urls](https://github.com/badges/shields/blob/master/doc/badge-urls.md)
 
 ## Coding guidelines
 

config/custom-environment-variables.yml

@@ -6,6 +6,15 @@ public:
   metrics:
     prometheus:
       enabled: 'METRICS_PROMETHEUS_ENABLED'
+      endpointEnabled: 'METRICS_PROMETHEUS_ENDPOINT_ENABLED'
+    influx:
+      enabled: 'METRICS_INFLUX_ENABLED'
+      url: 'METRICS_INFLUX_URL'
+      timeoutMilliseconds: 'METRICS_INFLUX_TIMEOUT_MILLISECONDS'
+      intervalSeconds: 'METRICS_INFLUX_INTERVAL_SECONDS'
+      instanceIdFrom: 'METRICS_INFLUX_INSTANCE_ID_FROM'
+      instanceIdEnvVarName: 'METRICS_INFLUX_INSTANCE_ID_ENV_VAR_NAME'
+      envLabel: 'METRICS_INFLUX_ENV_LABEL'
 
   ssl:
     isSecure: 'HTTPS'
@@ -25,27 +34,46 @@ public:
     dir: 'PERSISTENCE_DIR'
 
   services:
+    bitbucketServer:
+      authorizedOrigins: 'BITBUCKET_SERVER_ORIGINS'
+    drone:
+      authorizedOrigins: 'DRONE_ORIGINS'
     github:
       baseUri: 'GITHUB_URL'
       debug:
         enabled: 'GITHUB_DEBUG_ENABLED'
         intervalSeconds: 'GITHUB_DEBUG_INTERVAL_SECONDS'
+    jenkins:
+      authorizedOrigins: 'JENKINS_ORIGINS'
+    jira:
+      authorizedOrigins: 'JIRA_ORIGINS'
+    nexus:
+      authorizedOrigins: 'NEXUS_ORIGINS'
+    npm:
+      authorizedOrigins: 'NPM_ORIGINS'
+    sonar:
+      authorizedOrigins: 'SONAR_ORIGINS'
+    teamcity:
+      authorizedOrigins: 'TEAMCITY_ORIGINS'
     trace: 'TRACE_SERVICES'
 
-  profiling:
-    makeBadge: 'PROFILE_MAKE_BADGE'
-
   cacheHeaders:
     defaultCacheLengthSeconds: 'BADGE_MAX_AGE_SECONDS'
 
   rateLimit: 'RATE_LIMIT'
 
-  fetchLimit: 'FETCH_LIMIT'
+  integrations:
+    default:
+      fetchLimit: 'FETCH_LIMIT'
 
 private:
   azure_devops_token: 'AZURE_DEVOPS_TOKEN'
   bintray_user: 'BINTRAY_USER'
   bintray_apikey: 'BINTRAY_API_KEY'
+  bitbucket_username: 'BITBUCKET_USER'
+  bitbucket_password: 'BITBUCKET_PASS'
+  bitbucket_server_username: 'BITBUCKET_SERVER_USER'
+  bitbucket_server_password: 'BITBUCKET_SERVER_PASS'
   drone_token: 'DRONE_TOKEN'
   gh_client_id: 'GH_CLIENT_ID'
   gh_client_secret: 'GH_CLIENT_SECRET'
@@ -63,6 +91,10 @@ private:
   sl_insight_userUuid: 'SL_INSIGHT_USER_UUID'
   sl_insight_apiToken: 'SL_INSIGHT_API_TOKEN'
   sonarqube_token: 'SONARQUBE_TOKEN'
+  teamcity_user: 'TEAMCITY_USER'
+  teamcity_pass: 'TEAMCITY_PASS'
   twitch_client_id: 'TWITCH_CLIENT_ID'
   twitch_client_secret: 'TWITCH_CLIENT_SECRET'
   wheelmap_token: 'WHEELMAP_TOKEN'
+  influx_username: 'INFLUX_USERNAME'
+  influx_password: 'INFLUX_PASSWORD'

config/default.yml

@@ -5,7 +5,11 @@ public:
   metrics:
     prometheus:
       enabled: false
-
+      endpointEnabled: false
+    influx:
+      enabled: false
+      timeoutMilliseconds: 1000
+      intervalSeconds: 15
   ssl:
     isSecure: false
 
@@ -23,9 +27,6 @@ public:
         intervalSeconds: 200
     trace: false
 
-  profiling:
-    makeBadge: false
-
   cacheHeaders:
     defaultCacheLengthSeconds: 120
 
@@ -33,6 +34,17 @@ public:
 
   handleInternalErrors: true
 
-  fetchLimit: '10MB'
+  integrations:
+    default:
+      fetchLimit: '10MB'
+
+    DynamicJson:
+      fetchLimit: '2MB'
+
+    DynamicXml:
+      fetchLimit: '128KB'
+
+    DynamicYaml:
+      fetchLimit: '64KB'
 
 private: {}

config/local-shields-io-production.template.yml

@@ -1,8 +1,8 @@
 private:
-  bintray_user: ...
-  bintray_apikey: ...
+  # These are the keys which are set on the production servers.
   gh_client_id: ...
   gh_client_secret: ...
+  redis_url: ...
   sentry_dsn: ...
   shields_secret: ...
   sl_insight_userUuid: ...

config/shields-io-production.yml

@@ -2,6 +2,7 @@ public:
   metrics:
     prometheus:
       enabled: true
+      endpointEnabled: true
 
   ssl:
     isSecure: true

core/badge-urls/make-badge-url.js

@@ -2,7 +2,7 @@
 
 const { URL } = require('url')
 const queryString = require('query-string')
-const pathToRegexp = require('path-to-regexp')
+const { compile } = require('path-to-regexp')
 
 function badgeUrlFromPath({
   baseUrl = '',
@@ -33,9 +33,10 @@ function badgeUrlFromPattern({
   format = '',
   longCache = false,
 }) {
-  const toPath = pathToRegexp.compile(pattern, {
+  const toPath = compile(pattern, {
     strict: true,
     sensitive: true,
+    encode: encodeURIComponent,
   })
 
   const path = toPath(namedParams)

core/base-service/auth-helper.js

@@ -1,34 +1,68 @@
 'use strict'
 
+const { URL } = require('url')
+const { InvalidParameter } = require('./errors')
+
 class AuthHelper {
   constructor(
     {
       userKey,
       passKey,
+      authorizedOrigins,
+      serviceKey,
       isRequired = false,
       defaultToEmptyStringForUser = false,
     },
-    privateConfig
+    config
   ) {
     if (!userKey && !passKey) {
       throw Error('Expected userKey or passKey to be set')
     }
 
+    if (!authorizedOrigins && !serviceKey) {
+      throw Error('Expected authorizedOrigins or serviceKey to be set')
+    }
+
     this._userKey = userKey
     this._passKey = passKey
     if (userKey) {
-      this.user = privateConfig[userKey]
+      this._user = config.private[userKey]
     } else {
-      this.user = defaultToEmptyStringForUser ? '' : undefined
+      this._user = defaultToEmptyStringForUser ? '' : undefined
     }
-    this.pass = passKey ? privateConfig[passKey] : undefined
+    this._pass = passKey ? config.private[passKey] : undefined
     this.isRequired = isRequired
+
+    if (serviceKey !== undefined && !(serviceKey in config.public.services)) {
+      // Keep this as its own error, as it's useful to the programmer as they're
+      // getting auth set up.
+      throw Error(`Service key ${serviceKey} was missing from config schema`)
+    }
+
+    let requireStrictSsl, requireStrictSslToAuthenticate
+    if (serviceKey === undefined) {
+      requireStrictSsl = true
+      requireStrictSslToAuthenticate = true
+    } else {
+      ;({
+        authorizedOrigins,
+        requireStrictSsl = true,
+        requireStrictSslToAuthenticate = true,
+      } = config.public.services[serviceKey])
+    }
+    if (!Array.isArray(authorizedOrigins)) {
+      throw Error('Expected authorizedOrigins to be an array of origins')
+    }
+    this._authorizedOrigins = authorizedOrigins
+    this._requireStrictSsl = requireStrictSsl
+    this._requireStrictSslToAuthenticate = requireStrictSslToAuthenticate
   }
 
   get isConfigured() {
     return (
-      (this._userKey ? Boolean(this.user) : true) &&
-      (this._passKey ? Boolean(this.pass) : true)
+      this._authorizedOrigins.length > 0 &&
+      (this._userKey ? Boolean(this._user) : true) &&
+      (this._passKey ? Boolean(this._pass) : true)
     )
   }
 
@@ -36,20 +70,135 @@ class AuthHelper {
     if (this.isRequired) {
       return this.isConfigured
     } else {
-      const configIsEmpty = !this.user && !this.pass
+      const configIsEmpty = !this._user && !this._pass
       return this.isConfigured || configIsEmpty
     }
   }
 
-  get basicAuth() {
-    const { user, pass } = this
+  static _isInsecureSslRequest({ options = {} }) {
+    const { strictSSL = true } = options
+    return strictSSL !== true
+  }
+
+  enforceStrictSsl({ options = {} }) {
+    if (
+      this._requireStrictSsl &&
+      this.constructor._isInsecureSslRequest({ options })
+    ) {
+      throw new InvalidParameter({ prettyMessage: 'strict ssl is required' })
+    }
+  }
+
+  shouldAuthenticateRequest({ url, options = {} }) {
+    let parsed
+    try {
+      parsed = new URL(url)
+    } catch (e) {
+      throw new InvalidParameter({ prettyMessage: 'invalid url parameter' })
+    }
+
+    const { protocol, host } = parsed
+    const origin = `${protocol}//${host}`
+    const originViolation = !this._authorizedOrigins.includes(origin)
+
+    const strictSslCheckViolation =
+      this._requireStrictSslToAuthenticate &&
+      this.constructor._isInsecureSslRequest({ options })
+
+    return this.isConfigured && !originViolation && !strictSslCheckViolation
+  }
+
+  get _basicAuth() {
+    const { _user: user, _pass: pass } = this
     return this.isConfigured ? { user, pass } : undefined
   }
 
-  get bearerAuthHeader() {
-    const { pass } = this
+  /*
+   * Helper function for `withBasicAuth()` and friends.
+   */
+  _withAnyAuth(requestParams, mergeAuthFn) {
+    this.enforceStrictSsl(requestParams)
+
+    const shouldAuthenticate = this.shouldAuthenticateRequest(requestParams)
+    if (this.isRequired && !shouldAuthenticate) {
+      throw new InvalidParameter({
+        prettyMessage: 'requested origin not authorized',
+      })
+    }
+
+    return shouldAuthenticate ? mergeAuthFn(requestParams) : requestParams
+  }
+
+  static _mergeAuth(requestParams, auth) {
+    const { options, ...rest } = requestParams
+    return {
+      options: {
+        auth,
+        ...options,
+      },
+      ...rest,
+    }
+  }
+
+  withBasicAuth(requestParams) {
+    return this._withAnyAuth(requestParams, requestParams =>
+      this.constructor._mergeAuth(requestParams, this._basicAuth)
+    )
+  }
+
+  get _bearerAuthHeader() {
+    const { _pass: pass } = this
     return this.isConfigured ? { Authorization: `Bearer ${pass}` } : undefined
   }
+
+  static _mergeHeaders(requestParams, headers) {
+    const {
+      options: { headers: existingHeaders, ...restOptions } = {},
+      ...rest
+    } = requestParams
+    return {
+      options: {
+        headers: {
+          ...existingHeaders,
+          ...headers,
+        },
+        ...restOptions,
+      },
+      ...rest,
+    }
+  }
+
+  withBearerAuthHeader(requestParams) {
+    return this._withAnyAuth(requestParams, requestParams =>
+      this.constructor._mergeHeaders(requestParams, this._bearerAuthHeader)
+    )
+  }
+
+  static _mergeQueryParams(requestParams, query) {
+    const {
+      options: { qs: existingQuery, ...restOptions } = {},
+      ...rest
+    } = requestParams
+    return {
+      options: {
+        qs: {
+          ...existingQuery,
+          ...query,
+        },
+        ...restOptions,
+      },
+      ...rest,
+    }
+  }
+
+  withQueryStringAuth({ userKey, passKey }, requestParams) {
+    return this._withAnyAuth(requestParams, requestParams =>
+      this.constructor._mergeQueryParams(requestParams, {
+        ...(userKey ? { [userKey]: this._user } : undefined),
+        ...(passKey ? { [passKey]: this._pass } : undefined),
+      })
+    )
+  }
 }
 
 module.exports = { AuthHelper }

core/base-service/auth-helper.spec.js

@@ -3,18 +3,42 @@
 const { expect } = require('chai')
 const { test, given, forCases } = require('sazerac')
 const { AuthHelper } = require('./auth-helper')
+const { InvalidParameter } = require('./errors')
 
 describe('AuthHelper', function() {
-  it('throws without userKey or passKey', function() {
-    expect(() => new AuthHelper({}, {})).to.throw(
-      Error,
-      'Expected userKey or passKey to be set'
-    )
+  describe('constructor checks', function() {
+    it('throws without userKey or passKey', function() {
+      expect(() => new AuthHelper({}, {})).to.throw(
+        Error,
+        'Expected userKey or passKey to be set'
+      )
+    })
+    it('throws without serviceKey or authorizedOrigins', function() {
+      expect(
+        () => new AuthHelper({ userKey: 'myci_user', passKey: 'myci_pass' }, {})
+      ).to.throw(Error, 'Expected authorizedOrigins or serviceKey to be set')
+    })
+    it('throws when authorizedOrigins is not an array', function() {
+      expect(
+        () =>
+          new AuthHelper(
+            {
+              userKey: 'myci_user',
+              passKey: 'myci_pass',
+              authorizedOrigins: true,
+            },
+            { private: {} }
+          )
+      ).to.throw(Error, 'Expected authorizedOrigins to be an array of origins')
+    })
   })
 
   describe('isValid', function() {
     function validate(config, privateConfig) {
-      return new AuthHelper(config, privateConfig).isValid
+      return new AuthHelper(
+        { authorizedOrigins: ['https://example.test'], ...config },
+        { private: privateConfig }
+      ).isValid
     }
     test(validate, () => {
       forCases([
@@ -65,9 +89,12 @@ describe('AuthHelper', function() {
     })
   })
 
-  describe('basicAuth', function() {
+  describe('_basicAuth', function() {
     function validate(config, privateConfig) {
-      return new AuthHelper(config, privateConfig).basicAuth
+      return new AuthHelper(
+        { authorizedOrigins: ['https://example.test'], ...config },
+        { private: privateConfig }
+      )._basicAuth
     }
     test(validate, () => {
       forCases([
@@ -100,4 +127,250 @@ describe('AuthHelper', function() {
       })
     })
   })
+
+  describe('_isInsecureSslRequest', function() {
+    test(AuthHelper._isInsecureSslRequest, () => {
+      forCases([
+        given({ url: 'http://example.test' }),
+        given({ url: 'http://example.test', options: {} }),
+        given({ url: 'http://example.test', options: { strictSSL: true } }),
+        given({
+          url: 'http://example.test',
+          options: { strictSSL: undefined },
+        }),
+      ]).expect(false)
+      given({
+        url: 'http://example.test',
+        options: { strictSSL: false },
+      }).expect(true)
+    })
+  })
+
+  describe('enforceStrictSsl', function() {
+    const authConfig = {
+      userKey: 'myci_user',
+      passKey: 'myci_pass',
+      serviceKey: 'myci',
+    }
+
+    context('by default', function() {
+      const authHelper = new AuthHelper(authConfig, {
+        public: {
+          services: { myci: { authorizedOrigins: ['http://myci.test'] } },
+        },
+        private: { myci_user: 'admin', myci_pass: 'abc123' },
+      })
+      it('does not throw for secure requests', function() {
+        expect(() => authHelper.enforceStrictSsl({})).not.to.throw()
+      })
+      it('throws for insecure requests', function() {
+        expect(() =>
+          authHelper.enforceStrictSsl({ options: { strictSSL: false } })
+        ).to.throw(InvalidParameter)
+      })
+    })
+
+    context("when strict SSL isn't required", function() {
+      const authHelper = new AuthHelper(authConfig, {
+        public: {
+          services: {
+            myci: {
+              authorizedOrigins: ['http://myci.test'],
+              requireStrictSsl: false,
+            },
+          },
+        },
+        private: { myci_user: 'admin', myci_pass: 'abc123' },
+      })
+      it('does not throw for secure requests', function() {
+        expect(() => authHelper.enforceStrictSsl({})).not.to.throw()
+      })
+      it('does not throw for insecure requests', function() {
+        expect(() =>
+          authHelper.enforceStrictSsl({ options: { strictSSL: false } })
+        ).not.to.throw()
+      })
+    })
+  })
+
+  describe('shouldAuthenticateRequest', function() {
+    const authConfig = {
+      userKey: 'myci_user',
+      passKey: 'myci_pass',
+      serviceKey: 'myci',
+    }
+
+    context('by default', function() {
+      const authHelper = new AuthHelper(authConfig, {
+        public: {
+          services: {
+            myci: {
+              authorizedOrigins: ['https://myci.test'],
+            },
+          },
+        },
+        private: { myci_user: 'admin', myci_pass: 'abc123' },
+      })
+      const shouldAuthenticateRequest = requestOptions =>
+        authHelper.shouldAuthenticateRequest(requestOptions)
+      describe('a secure request to an authorized origin', function() {
+        test(shouldAuthenticateRequest, () => {
+          given({ url: 'https://myci.test/api' }).expect(true)
+        })
+      })
+      describe('an insecure request', function() {
+        test(shouldAuthenticateRequest, () => {
+          given({
+            url: 'https://myci.test/api',
+            options: { strictSSL: false },
+          }).expect(false)
+        })
+      })
+      describe('a request to an unauthorized origin', function() {
+        test(shouldAuthenticateRequest, () => {
+          forCases([
+            given({ url: 'http://myci.test/api' }),
+            given({ url: 'https://myci.test:12345/api' }),
+            given({ url: 'https://other.test/api' }),
+          ]).expect(false)
+        })
+      })
+    })
+
+    context('when auth over insecure SSL is allowed', function() {
+      const authHelper = new AuthHelper(authConfig, {
+        public: {
+          services: {
+            myci: {
+              authorizedOrigins: ['https://myci.test'],
+              requireStrictSslToAuthenticate: false,
+            },
+          },
+        },
+        private: { myci_user: 'admin', myci_pass: 'abc123' },
+      })
+      const shouldAuthenticateRequest = requestOptions =>
+        authHelper.shouldAuthenticateRequest(requestOptions)
+      describe('a secure request to an authorized origin', function() {
+        test(shouldAuthenticateRequest, () => {
+          given({ url: 'https://myci.test' }).expect(true)
+        })
+      })
+      describe('an insecure request', function() {
+        test(shouldAuthenticateRequest, () => {
+          given({
+            url: 'https://myci.test',
+            options: { strictSSL: false },
+          }).expect(true)
+        })
+      })
+      describe('a request to an unauthorized origin', function() {
+        test(shouldAuthenticateRequest, () => {
+          forCases([
+            given({ url: 'http://myci.test' }),
+            given({ url: 'https://myci.test:12345/' }),
+            given({ url: 'https://other.test' }),
+          ]).expect(false)
+        })
+      })
+    })
+
+    context('when the service is partly configured', function() {
+      const authHelper = new AuthHelper(authConfig, {
+        public: {
+          services: {
+            myci: {
+              authorizedOrigins: ['https://myci.test'],
+              requireStrictSslToAuthenticate: false,
+            },
+          },
+        },
+        private: { myci_user: 'admin' },
+      })
+      const shouldAuthenticateRequest = requestOptions =>
+        authHelper.shouldAuthenticateRequest(requestOptions)
+      describe('a secure request to an authorized origin', function() {
+        test(shouldAuthenticateRequest, () => {
+          given({ url: 'https://myci.test' }).expect(false)
+        })
+      })
+    })
+  })
+
+  describe('withBasicAuth', function() {
+    const authHelper = new AuthHelper(
+      {
+        userKey: 'myci_user',
+        passKey: 'myci_pass',
+        serviceKey: 'myci',
+      },
+      {
+        public: {
+          services: {
+            myci: {
+              authorizedOrigins: ['https://myci.test'],
+            },
+          },
+        },
+        private: { myci_user: 'admin', myci_pass: 'abc123' },
+      }
+    )
+    const withBasicAuth = requestOptions =>
+      authHelper.withBasicAuth(requestOptions)
+
+    describe('authenticates a secure request to an authorized origin', function() {
+      test(withBasicAuth, () => {
+        given({
+          url: 'https://myci.test/api',
+        }).expect({
+          url: 'https://myci.test/api',
+          options: {
+            auth: { user: 'admin', pass: 'abc123' },
+          },
+        })
+        given({
+          url: 'https://myci.test/api',
+          options: {
+            headers: { Accept: 'application/json' },
+          },
+        }).expect({
+          url: 'https://myci.test/api',
+          options: {
+            headers: { Accept: 'application/json' },
+            auth: { user: 'admin', pass: 'abc123' },
+          },
+        })
+      })
+    })
+
+    describe('does not authenticate a request to an unauthorized origin', function() {
+      test(withBasicAuth, () => {
+        given({
+          url: 'https://other.test/api',
+        }).expect({
+          url: 'https://other.test/api',
+        })
+        given({
+          url: 'https://other.test/api',
+          options: {
+            headers: { Accept: 'application/json' },
+          },
+        }).expect({
+          url: 'https://other.test/api',
+          options: {
+            headers: { Accept: 'application/json' },
+          },
+        })
+      })
+    })
+
+    describe('throws on an insecure SSL request', function() {
+      expect(() =>
+        withBasicAuth({
+          url: 'https://myci.test/api',
+          options: { strictSSL: false },
+        })
+      ).to.throw(InvalidParameter)
+    })
+  })
 })

core/base-service/base-json.spec.js

@@ -49,7 +49,9 @@ describe('BaseJsonService', function() {
 
       expect(sendAndCacheRequest).to.have.been.calledOnceWith(
         'http://example.com/foo.json',
-        { headers: { Accept: 'application/json' } }
+        {
+          headers: { Accept: 'application/json' },
+        }
       )
     })
 

core/base-service/base-static.js

@@ -13,9 +13,6 @@ const { prepareRoute, namedParamsForMatch } = require('./route')
 
 module.exports = class BaseStaticService extends BaseService {
   static register({ camp, metricInstance }, serviceConfig) {
-    const {
-      profiling: { makeBadge: shouldProfileMakeBadge },
-    } = serviceConfig
     const { regex, captureNames } = prepareRoute(this.route)
 
     const metricHelper = MetricHelper.create({
@@ -52,16 +49,9 @@ module.exports = class BaseStaticService extends BaseService {
       const format = (match.slice(-1)[0] || '.svg').replace(/^\./, '')
       badgeData.format = format
 
-      if (shouldProfileMakeBadge) {
-        console.time('makeBadge total')
-      }
-      const svg = makeBadge(badgeData)
-      if (shouldProfileMakeBadge) {
-        console.timeEnd('makeBadge total')
-      }
-
       setCacheHeadersForStaticResource(ask.res)
 
+      const svg = makeBadge(badgeData)
       makeSend(format, ask.res, end)(svg)
 
       metricHandle.noteResponseSent()

core/base-service/base-svg-scraping.spec.js

@@ -68,7 +68,9 @@ describe('BaseSvgScrapingService', function() {
 
       expect(sendAndCacheRequest).to.have.been.calledOnceWith(
         'http://example.com/foo.svg',
-        { headers: { Accept: 'image/svg+xml' } }
+        {
+          headers: { Accept: 'image/svg+xml' },
+        }
       )
     })
 

core/base-service/base-xml.spec.js

@@ -49,7 +49,9 @@ describe('BaseXmlService', function() {
 
       expect(sendAndCacheRequest).to.have.been.calledOnceWith(
         'http://example.com/foo.xml',
-        { headers: { Accept: 'application/xml, text/xml' } }
+        {
+          headers: { Accept: 'application/xml, text/xml' },
+        }
       )
     })
 

core/base-service/base.js

@@ -3,12 +3,13 @@
  * @module
  */
 
+const bytes = require('bytes')
 // See available emoji at http://emoji.muan.co/
 const emojic = require('emojic')
 const Joi = require('@hapi/joi')
 const log = require('../server/log')
 const { AuthHelper } = require('./auth-helper')
-const { MetricHelper } = require('./metric-helper')
+const { MetricHelper, MetricNames } = require('./metric-helper')
 const { assertValidCategory } = require('./categories')
 const checkErrorResponse = require('./check-error-response')
 const coalesceBadge = require('./coalesce-badge')
@@ -214,20 +215,43 @@ class BaseService {
     return result
   }
 
-  constructor({ sendAndCacheRequest, authHelper }, { handleInternalErrors }) {
+  constructor(
+    { sendAndCacheRequest, authHelper, metricHelper },
+    { handleInternalErrors }
+  ) {
     this._requestFetcher = sendAndCacheRequest
     this.authHelper = authHelper
     this._handleInternalErrors = handleInternalErrors
+    this._metricHelper = metricHelper
   }
 
   async _request({ url, options = {}, errorMessages = {} }) {
     const logTrace = (...args) => trace.logTrace('fetch', ...args)
     logTrace(emojic.bowAndArrow, 'Request', url, '\n', options)
     const { res, buffer } = await this._requestFetcher(url, options)
+    await this._meterResponse(res, buffer)
     logTrace(emojic.dart, 'Response status code', res.statusCode)
     return checkErrorResponse(errorMessages)({ buffer, res })
   }
 
+  static get enabledMetrics() {
+    return []
+  }
+
+  static isMetricEnabled(metricName) {
+    return this.enabledMetrics.includes(metricName)
+  }
+
+  async _meterResponse(res, buffer) {
+    if (
+      this._metricHelper &&
+      this.constructor.isMetricEnabled(MetricNames.SERVICE_RESPONSE_SIZE) &&
+      res.statusCode === 200
+    ) {
+      this._metricHelper.noteServiceResponseSize(buffer.length)
+    }
+  }
+
   static _validate(
     data,
     schema,
@@ -336,9 +360,7 @@ class BaseService {
     // Like the service instance, the auth helper could be reused for each request.
     // However, moving its instantiation to `register()` makes `invoke()` harder
     // to test.
-    const authHelper = this.auth
-      ? new AuthHelper(this.auth, config.private)
-      : undefined
+    const authHelper = this.auth ? new AuthHelper(this.auth, config) : undefined
 
     const serviceInstance = new this({ ...context, authHelper }, config)
 
@@ -404,7 +426,8 @@ class BaseService {
     { camp, handleRequest, githubApiProvider, metricInstance },
     serviceConfig
   ) {
-    const { cacheHeaders: cacheHeaderConfig, fetchLimitBytes } = serviceConfig
+    const { cacheHeaders: cacheHeaderConfig, fetchLimit } = serviceConfig
+    const fetchLimitBytes = bytes.parse(fetchLimit)
     const { regex, captureNames } = prepareRoute(this.route)
     const queryParams = getQueryParamNames(this.route)
 
@@ -426,6 +449,7 @@ class BaseService {
               sendAndCacheRequest: request.asPromise,
               sendAndCacheRequestWithCallbacks: request,
               githubApiProvider,
+              metricHelper,
             },
             serviceConfig,
             namedParams,

core/base-service/base.spec.js

@@ -1,8 +1,11 @@
 'use strict'
 
 const Joi = require('@hapi/joi')
-const { expect } = require('chai')
+const chai = require('chai')
+const { expect } = chai
 const sinon = require('sinon')
+const prometheus = require('prom-client')
+const PrometheusMetrics = require('../server/prometheus-metrics')
 const trace = require('./trace')
 const {
   NotFound,
@@ -12,8 +15,9 @@ const {
   Deprecated,
 } = require('./errors')
 const BaseService = require('./base')
-
+const { MetricHelper, MetricNames } = require('./metric-helper')
 require('../register-chai-plugins.spec')
+chai.use(require('chai-as-promised'))
 
 const queryParamSchema = Joi.object({
   queryParamA: Joi.string(),
@@ -63,8 +67,20 @@ class DummyService extends BaseService {
   }
 }
 
+class DummyServiceWithServiceResponseSizeMetricEnabled extends DummyService {
+  static get enabledMetrics() {
+    return [MetricNames.SERVICE_RESPONSE_SIZE]
+  }
+}
+
 describe('BaseService', function() {
-  const defaultConfig = { handleInternalErrors: false, private: {} }
+  const defaultConfig = {
+    public: {
+      handleInternalErrors: false,
+      services: {},
+    },
+    private: {},
+  }
 
   it('Invokes the handler as expected', async function() {
     expect(
@@ -97,17 +113,14 @@ describe('BaseService', function() {
   describe('Required overrides', function() {
     it('Should throw if render() is not overridden', function() {
       expect(() => BaseService.render()).to.throw(
-        'render() function not implemented for BaseService'
+        /^render\(\) function not implemented for BaseService$/
       )
     })
 
-    it('Should throw if route is not overridden', async function() {
-      try {
-        await BaseService.invoke({}, {}, {})
-        expect.fail('Expected to throw')
-      } catch (e) {
-        expect(e.message).to.equal('Route not defined for BaseService')
-      }
+    it('Should throw if route is not overridden', function() {
+      return expect(BaseService.invoke({}, {}, {})).to.be.rejectedWith(
+        /^Route not defined for BaseService$/
+      )
     })
 
     class WithRoute extends BaseService {
@@ -115,18 +128,15 @@ describe('BaseService', function() {
         return {}
       }
     }
-    it('Should throw if handle() is not overridden', async function() {
-      try {
-        await WithRoute.invoke({}, {}, {})
-        expect.fail('Expected to throw')
-      } catch (e) {
-        expect(e.message).to.equal('Handler not implemented for WithRoute')
-      }
+    it('Should throw if handle() is not overridden', function() {
+      return expect(WithRoute.invoke({}, {}, {})).to.be.rejectedWith(
+        /^Handler not implemented for WithRoute$/
+      )
     })
 
     it('Should throw if category is not overridden', function() {
       expect(() => BaseService.category).to.throw(
-        'Category not set for BaseService'
+        /^Category not set for BaseService$/
       )
     })
   })
@@ -427,16 +437,15 @@ describe('BaseService', function() {
       requiredString: Joi.string().required(),
     }).required()
 
-    it('throws error for invalid responses', async function() {
-      try {
+    it('throws error for invalid responses', function() {
+      expect(() =>
         DummyService._validate(
           { requiredString: ['this', "shouldn't", 'work'] },
           dummySchema
         )
-        expect.fail('Expected to throw')
-      } catch (e) {
-        expect(e).to.be.an.instanceof(InvalidResponse)
-      }
+      )
+        .to.throw()
+        .instanceof(InvalidResponse)
     })
   })
 
@@ -503,18 +512,72 @@ describe('BaseService', function() {
     })
   })
 
+  describe('Metrics', function() {
+    let register
+    beforeEach(function() {
+      register = new prometheus.Registry()
+    })
+    const url = 'some-url'
+
+    it('service response size metric is optional', async function() {
+      const metricHelper = MetricHelper.create({
+        metricInstance: new PrometheusMetrics({ register }),
+        ServiceClass: DummyServiceWithServiceResponseSizeMetricEnabled,
+      })
+      const sendAndCacheRequest = async () => ({
+        buffer: 'x'.repeat(65536 + 1),
+        res: { statusCode: 200 },
+      })
+      const serviceInstance = new DummyServiceWithServiceResponseSizeMetricEnabled(
+        { sendAndCacheRequest, metricHelper },
+        defaultConfig
+      )
+
+      await serviceInstance._request({ url })
+
+      expect(register.getSingleMetricAsString('service_response_bytes'))
+        .to.contain(
+          'service_response_bytes_bucket{le="65536",category="other",family="undefined",service="dummy_service_with_service_response_size_metric_enabled"} 0\n'
+        )
+        .and.to.contain(
+          'service_response_bytes_bucket{le="131072",category="other",family="undefined",service="dummy_service_with_service_response_size_metric_enabled"} 1\n'
+        )
+    })
+
+    it('service response size metric is disabled by default', async function() {
+      const metricHelper = MetricHelper.create({
+        metricInstance: new PrometheusMetrics({ register }),
+        ServiceClass: DummyService,
+      })
+      const sendAndCacheRequest = async () => ({
+        buffer: 'x',
+        res: { statusCode: 200 },
+      })
+      const serviceInstance = new DummyService(
+        { sendAndCacheRequest, metricHelper },
+        defaultConfig
+      )
+
+      await serviceInstance._request({ url })
+
+      expect(
+        register.getSingleMetricAsString('service_response_bytes')
+      ).to.not.contain('service_response_bytes_bucket')
+    })
+  })
   describe('auth', function() {
     class AuthService extends DummyService {
       static get auth() {
         return {
           passKey: 'myci_pass',
+          serviceKey: 'myci',
           isRequired: true,
         }
       }
 
       async handle() {
         return {
-          message: `The CI password is ${this.authHelper.pass}`,
+          message: `The CI password is ${this.authHelper._pass}`,
         }
       }
     }
@@ -523,7 +586,13 @@ describe('BaseService', function() {
       expect(
         await AuthService.invoke(
           {},
-          { defaultConfig, private: { myci_pass: 'abc123' } },
+          {
+            public: {
+              ...defaultConfig.public,
+              services: { myci: { authorizedOrigins: ['https://myci.test'] } },
+            },
+            private: { myci_pass: 'abc123' },
+          },
           { namedParamA: 'bar.bar.bar' }
         )
       ).to.deep.equal({ message: 'The CI password is abc123' })
@@ -531,9 +600,19 @@ describe('BaseService', function() {
 
     it('when auth is not configured properly, invoke() returns inacessible', async function() {
       expect(
-        await AuthService.invoke({}, defaultConfig, {
-          namedParamA: 'bar.bar.bar',
-        })
+        await AuthService.invoke(
+          {},
+          {
+            public: {
+              ...defaultConfig.public,
+              services: { myci: { authorizedOrigins: ['https://myci.test'] } },
+            },
+            private: {},
+          },
+          {
+            namedParamA: 'bar.bar.bar',
+          }
+        )
       ).to.deep.equal({
         color: 'lightgray',
         isError: true,

core/base-service/coalesce-badge.spec.js

@@ -15,9 +15,9 @@ describe('coalesceBadge', function() {
 
     // This behavior isn't great and we might want to remove it.
     it('uses the category as a default label', function() {
-      expect(coalesceBadge({}, {}, {}, { category: 'cat' }).text).to.deep.equal(
-        ['cat', 'n/a']
-      )
+      expect(
+        coalesceBadge({}, {}, {}, { category: 'cat' }).text
+      ).to.deep.equal(['cat', 'n/a'])
     })
 
     it('preserves an empty label', function() {

core/base-service/coalesce.spec.js

@@ -14,9 +14,9 @@ describe('coalesce', function() {
     given(null, [], {}).expect([])
     given(null, undefined, 0, {}).expect(0)
 
-    const a = null,
-      c = 0,
-      d = 1
+    const a = null
+    const c = 0
+    const d = 1
     let b
     given(a, b, c, d).expect(0)
   })

core/base-service/errors.js

@@ -56,6 +56,7 @@ class NotFound extends ShieldsRuntimeError {
   get name() {
     return 'NotFound'
   }
+
   get defaultPrettyMessage() {
     return defaultNotFoundError
   }
@@ -82,6 +83,7 @@ class InvalidResponse extends ShieldsRuntimeError {
   get name() {
     return 'InvalidResponse'
   }
+
   get defaultPrettyMessage() {
     return 'invalid'
   }
@@ -107,6 +109,7 @@ class Inaccessible extends ShieldsRuntimeError {
   get name() {
     return 'Inaccessible'
   }
+
   get defaultPrettyMessage() {
     return 'inaccessible'
   }
@@ -131,6 +134,7 @@ class ImproperlyConfigured extends ShieldsRuntimeError {
   get name() {
     return 'ImproperlyConfigured'
   }
+
   get defaultPrettyMessage() {
     return 'improperly configured'
   }
@@ -156,6 +160,7 @@ class InvalidParameter extends ShieldsRuntimeError {
   get name() {
     return 'InvalidParameter'
   }
+
   get defaultPrettyMessage() {
     return 'invalid parameter'
   }
@@ -180,6 +185,7 @@ class Deprecated extends ShieldsRuntimeError {
   get name() {
     return 'Deprecated'
   }
+
   get defaultPrettyMessage() {
     return 'no longer available'
   }

core/base-service/examples.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const Joi = require('@hapi/joi')
-const pathToRegexp = require('path-to-regexp')
+const { pathToRegexp, compile } = require('path-to-regexp')
 const categories = require('../../services/categories')
 const coalesceBadge = require('./coalesce-badge')
 const { makeFullUrl } = require('./route')
@@ -59,7 +59,9 @@ function validateExample(example, index, ServiceClass) {
 
   // Make sure we can build the full URL using these patterns.
   try {
-    pathToRegexp.compile(pattern || ServiceClass.route.pattern)(namedParams)
+    compile(pattern || ServiceClass.route.pattern, {
+      encode: encodeURIComponent,
+    })(namedParams)
   } catch (e) {
     throw Error(
       `In example for ${
@@ -69,7 +71,10 @@ function validateExample(example, index, ServiceClass) {
   }
   // Make sure there are no extra keys.
   let keys = []
-  pathToRegexp(pattern || ServiceClass.route.pattern, keys)
+  pathToRegexp(pattern || ServiceClass.route.pattern, keys, {
+    strict: true,
+    sensitive: true,
+  })
   keys = keys.map(({ name }) => name)
   const extraKeys = Object.keys(namedParams).filter(k => !keys.includes(k))
   if (extraKeys.length) {

core/base-service/legacy-request-handler.js

@@ -13,6 +13,8 @@ const { makeSend } = require('./legacy-result-sender')
 const LruCache = require('./lru-cache')
 const coalesceBadge = require('./coalesce-badge')
 
+const userAgent = 'Shields.io/2003a'
+
 // We avoid calling the vendor's server for computation of the information in a
 // number of badges.
 const minAccuracy = 0.75
@@ -204,8 +206,7 @@ function handleRequest(cacheHeaderConfig, handlerOptions) {
         options = uri
       }
       options.headers = options.headers || {}
-      options.headers['User-Agent'] =
-        options.headers['User-Agent'] || 'Shields.io'
+      options.headers['User-Agent'] = userAgent
 
       let bufferLength = 0
       const r = request(options, (err, res, body) => {
@@ -294,4 +295,5 @@ module.exports = {
   clearRequestCache,
   // Expose for testing.
   _requestCache: requestCache,
+  userAgent,
 }

core/base-service/loader.js

@@ -82,9 +82,12 @@ function assertNamesUnique(names, { message }) {
 
 function checkNames() {
   const services = loadServiceClasses()
-  assertNamesUnique(services.map(({ name }) => name), {
-    message: 'Duplicate service names found',
-  })
+  assertNamesUnique(
+    services.map(({ name }) => name),
+    {
+      message: 'Duplicate service names found',
+    }
+  )
 }
 
 function collectDefinitions() {

core/base-service/metric-helper.js

@@ -11,9 +11,17 @@ class MetricHelper {
         serviceFamily,
         name,
       })
+      this.serviceResponseSizeHistogram = metricInstance.createServiceResponseSizeHistogram(
+        {
+          category,
+          serviceFamily,
+          name,
+        }
+      )
     } else {
       this.metricInstance = undefined
       this.serviceRequestCounter = undefined
+      this.serviceResponseSizeHistogram = undefined
     }
   }
 
@@ -40,6 +48,16 @@ class MetricHelper {
       },
     }
   }
+
+  noteServiceResponseSize(size) {
+    if (this.serviceResponseSizeHistogram) {
+      return this.serviceResponseSizeHistogram.observe(size)
+    }
+  }
 }
 
-module.exports = { MetricHelper }
+const MetricNames = Object.freeze({
+  SERVICE_RESPONSE_SIZE: Symbol('service-response-size'),
+})
+
+module.exports = { MetricHelper, MetricNames }

core/base-service/route.js

@@ -2,7 +2,7 @@
 
 const escapeStringRegexp = require('escape-string-regexp')
 const Joi = require('@hapi/joi')
-const pathToRegexp = require('path-to-regexp')
+const { pathToRegexp } = require('path-to-regexp')
 
 function makeFullUrl(base, partialUrl) {
   return `/${[base, partialUrl].filter(Boolean).join('/')}`

core/base-service/validate.js

@@ -21,8 +21,8 @@ function validate(
   }
   const options = { abortEarly: false }
   if (allowAndStripUnknownKeys) {
-    options['allowUnknown'] = true
-    options['stripUnknown'] = true
+    options.allowUnknown = true
+    options.stripUnknown = true
   }
   const { error, value } = schema.validate(data, options)
   if (error) {

core/server/config.js

@@ -0,0 +1,38 @@
+'use strict'
+const deepmerge = require('deepmerge')
+
+class RedundantCustomConfiguration extends Error {
+  constructor(message) {
+    super(message)
+    this.name = 'RedundantCustomConfiguration'
+  }
+}
+
+function merge(_default, custom) {
+  // Overwrites the existing array values completely rather than concatenating them
+  // recipe from https://github.com/TehShrike/deepmerge#arraymerge
+  const overwriteMerge = (destinationArray, sourceArray, options) => sourceArray
+  return deepmerge(_default, custom, {
+    arrayMerge: overwriteMerge,
+  })
+}
+
+function checkCustomIntegrationConfiguration(config, serviceClasses) {
+  const serviceNames = new Set(
+    serviceClasses.map(serviceClass => serviceClass.name)
+  )
+  const redundantConfigurations = Object.keys(config.public.integrations)
+    .filter(configName => configName !== 'default')
+    .filter(configName => !serviceNames.has(configName))
+  if (redundantConfigurations.length) {
+    throw new RedundantCustomConfiguration(
+      `Custom configurations found without a corresponding service: ${redundantConfigurations}`
+    )
+  }
+}
+
+module.exports = {
+  RedundantCustomConfiguration,
+  merge,
+  checkCustomIntegrationConfiguration,
+}

core/server/config.spec.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const { test, given } = require('sazerac')
+const { expect } = require('chai')
+const {
+  RedundantCustomConfiguration,
+  merge,
+  checkCustomIntegrationConfiguration,
+} = require('./config')
+
+describe('configuration', function() {
+  test(merge, function() {
+    given({ a: 2 }, {})
+      .describe('copies the default value')
+      .expect({ a: 2 })
+    given({ a: 2 }, { a: 3 })
+      .describe('overrides a primitive value')
+      .expect({ a: 3 })
+    given({ a: { a1: 1, a2: 2 } }, { a: { a1: 2 } })
+      .describe('merges objects')
+      .expect({ a: { a1: 2, a2: 2 } })
+    given({ a: { a1: 1, a2: 2 } }, { a: 3 })
+      .describe('overrides an object with a primitive')
+      .expect({ a: 3 })
+    given({ a: { a1: 1, a2: 2 } }, { a: {} })
+      .describe('does not override an object with an empty object')
+      .expect({ a: { a1: 1, a2: 2 } })
+    given({ a: [2, 3, 4] }, { a: [5, 6] })
+      .describe('overrides array')
+      .expect({ a: [5, 6] })
+  })
+
+  describe('checkCustomIntegrationConfiguration function', function() {
+    it('accepts the default configuration', function() {
+      const config = { public: { integrations: { default: {} } } }
+      const serviceClasses = [{ name: 'SomeService' }]
+
+      expect(() =>
+        checkCustomIntegrationConfiguration(config, serviceClasses)
+      ).not.throw()
+    })
+
+    it('accepts a configuration for an existing service', function() {
+      const config = { public: { integrations: { SomeService: {} } } }
+      const serviceClasses = [{ name: 'SomeService' }]
+
+      expect(() =>
+        checkCustomIntegrationConfiguration(config, serviceClasses)
+      ).not.throw()
+    })
+
+    it('throws an error if a custom config does not have a corresponding service', function() {
+      const config = { public: { integrations: { UnknownService: {} } } }
+      const serviceClasses = [{ name: 'KnownService' }]
+
+      expect(() =>
+        checkCustomIntegrationConfiguration(config, serviceClasses)
+      ).to.throw(RedundantCustomConfiguration)
+    })
+  })
+})

core/server/in-process-server-test-helpers.js

@@ -1,21 +1,16 @@
 'use strict'
 
+const merge = require('deepmerge')
 const config = require('config').util.toObject()
+const portfinder = require('portfinder')
 const Server = require('./server')
 
-function createTestServer({ port }) {
-  const serverConfig = {
-    ...config,
-    public: {
-      ...config.public,
-      bind: {
-        ...config.public.bind,
-        port,
-      },
-    },
+async function createTestServer(customConfig = {}) {
+  const mergedConfig = merge(config, customConfig)
+  if (!mergedConfig.public.bind.port) {
+    mergedConfig.public.bind.port = await portfinder.getPortPromise()
   }
-
-  return new Server(serverConfig)
+  return new Server(mergedConfig)
 }
 
 module.exports = {

core/server/influx-metrics.js

@@ -0,0 +1,86 @@
+'use strict'
+const os = require('os')
+const { promisify } = require('util')
+const { post } = require('request')
+const postAsync = promisify(post)
+const generateInstanceId = require('./instance-id-generator')
+const { promClientJsonToInfluxV2 } = require('./metrics/format-converters')
+const log = require('./log')
+
+module.exports = class InfluxMetrics {
+  constructor(metricInstance, config) {
+    this._metricInstance = metricInstance
+    this._config = config
+    this._instanceId = this.getInstanceId()
+  }
+
+  async sendMetrics() {
+    const auth = {
+      user: this._config.username,
+      pass: this._config.password,
+    }
+    const request = {
+      uri: this._config.url,
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: this.metrics(),
+      timeout: this._config.timeoutMillseconds,
+      auth,
+    }
+
+    let response
+    try {
+      response = await postAsync(request)
+    } catch (error) {
+      log.error(
+        new Error(`Cannot push metrics. Cause: ${error.name}: ${error.message}`)
+      )
+    }
+    if (response && response.statusCode >= 300) {
+      log.error(
+        new Error(
+          `Cannot push metrics. ${response.request.href} responded with status code ${response.statusCode}`
+        )
+      )
+    }
+  }
+
+  startPushingMetrics() {
+    this._intervalId = setInterval(
+      () => this.sendMetrics(),
+      this._config.intervalSeconds * 1000
+    )
+  }
+
+  metrics() {
+    return promClientJsonToInfluxV2(this._metricInstance.metrics(), {
+      env: this._config.envLabel,
+      application: 'shields',
+      instance: this._instanceId,
+    })
+  }
+
+  getInstanceId() {
+    const {
+      hostnameAliases = {},
+      instanceIdFrom,
+      instanceIdEnvVarName,
+    } = this._config
+    let instance
+    if (instanceIdFrom === 'env-var') {
+      instance = process.env[instanceIdEnvVarName]
+    } else if (instanceIdFrom === 'hostname') {
+      const hostname = os.hostname()
+      instance = hostnameAliases[hostname] || hostname
+    } else if (instanceIdFrom === 'random') {
+      instance = generateInstanceId()
+    }
+    return instance
+  }
+
+  stopPushingMetrics() {
+    if (this._intervalId) {
+      clearInterval(this._intervalId)
+      this._intervalId = undefined
+    }
+  }
+}

core/server/influx-metrics.spec.js

@@ -0,0 +1,177 @@
+'use strict'
+const os = require('os')
+const nock = require('nock')
+const sinon = require('sinon')
+const { expect } = require('chai')
+const log = require('./log')
+const InfluxMetrics = require('./influx-metrics')
+require('../register-chai-plugins.spec')
+describe('Influx metrics', function() {
+  const metricInstance = {
+    metrics() {
+      return [
+        {
+          help: 'counter 1 help',
+          name: 'counter1',
+          type: 'counter',
+          values: [{ value: 11, labels: {} }],
+          aggregator: 'sum',
+        },
+      ]
+    },
+  }
+  describe('"metrics" function', function() {
+    let osHostnameStub
+    afterEach(function() {
+      nock.enableNetConnect()
+      delete process.env.INSTANCE_ID
+      if (osHostnameStub) {
+        osHostnameStub.restore()
+      }
+    })
+    it('should use an environment variable value as an instance label', async function() {
+      process.env.INSTANCE_ID = 'instance3'
+      const influxMetrics = new InfluxMetrics(metricInstance, {
+        instanceIdFrom: 'env-var',
+        instanceIdEnvVarName: 'INSTANCE_ID',
+      })
+
+      expect(influxMetrics.metrics()).to.contain('instance=instance3')
+    })
+
+    it('should use a hostname as an instance label', async function() {
+      osHostnameStub = sinon.stub(os, 'hostname').returns('test-hostname')
+      const customConfig = {
+        instanceIdFrom: 'hostname',
+      }
+      const influxMetrics = new InfluxMetrics(metricInstance, customConfig)
+
+      expect(influxMetrics.metrics()).to.be.contain('instance=test-hostname')
+    })
+
+    it('should use a random string as an instance label', async function() {
+      const customConfig = {
+        instanceIdFrom: 'random',
+      }
+      const influxMetrics = new InfluxMetrics(metricInstance, customConfig)
+
+      expect(influxMetrics.metrics()).to.be.match(/instance=\w+ /)
+    })
+
+    it('should use a hostname alias as an instance label', async function() {
+      osHostnameStub = sinon.stub(os, 'hostname').returns('test-hostname')
+      const customConfig = {
+        instanceIdFrom: 'hostname',
+        hostnameAliases: { 'test-hostname': 'test-hostname-alias' },
+      }
+      const influxMetrics = new InfluxMetrics(metricInstance, customConfig)
+
+      expect(influxMetrics.metrics()).to.be.contain(
+        'instance=test-hostname-alias'
+      )
+    })
+  })
+
+  describe('startPushingMetrics', function() {
+    let influxMetrics, clock
+    beforeEach(function() {
+      clock = sinon.useFakeTimers()
+    })
+    afterEach(function() {
+      influxMetrics.stopPushingMetrics()
+      nock.cleanAll()
+      nock.enableNetConnect()
+      delete process.env.INSTANCE_ID
+      clock.restore()
+    })
+
+    it('should send metrics', async function() {
+      const scope = nock('http://shields-metrics.io/', {
+        reqheaders: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+      })
+        .persist()
+        .post(
+          '/metrics',
+          'prometheus,application=shields,env=test-env,instance=instance2 counter1=11'
+        )
+        .basicAuth({ user: 'metrics-username', pass: 'metrics-password' })
+        .reply(200)
+      process.env.INSTANCE_ID = 'instance2'
+      influxMetrics = new InfluxMetrics(metricInstance, {
+        url: 'http://shields-metrics.io/metrics',
+        timeoutMillseconds: 100,
+        intervalSeconds: 0.001,
+        username: 'metrics-username',
+        password: 'metrics-password',
+        instanceIdFrom: 'env-var',
+        instanceIdEnvVarName: 'INSTANCE_ID',
+        envLabel: 'test-env',
+      })
+
+      influxMetrics.startPushingMetrics()
+
+      await clock.tickAsync(10)
+      expect(scope.isDone()).to.be.equal(
+        true,
+        `pending mocks: ${scope.pendingMocks()}`
+      )
+    })
+  })
+
+  describe('sendMetrics', function() {
+    beforeEach(function() {
+      sinon.spy(log, 'error')
+    })
+    afterEach(function() {
+      log.error.restore()
+      nock.cleanAll()
+      nock.enableNetConnect()
+    })
+
+    const influxMetrics = new InfluxMetrics(metricInstance, {
+      url: 'http://shields-metrics.io/metrics',
+      timeoutMillseconds: 50,
+      intervalSeconds: 0,
+      username: 'metrics-username',
+      password: 'metrics-password',
+    })
+    it('should log errors', async function() {
+      nock.disableNetConnect()
+
+      await influxMetrics.sendMetrics()
+
+      expect(log.error).to.be.calledWith(
+        sinon.match
+          .instanceOf(Error)
+          .and(
+            sinon.match.has(
+              'message',
+              'Cannot push metrics. Cause: NetConnectNotAllowedError: Nock: Disallowed net connect for "shields-metrics.io:80/metrics"'
+            )
+          )
+      )
+    })
+
+    it('should log error responses', async function() {
+      nock('http://shields-metrics.io/')
+        .persist()
+        .post('/metrics')
+        .reply(400)
+
+      await influxMetrics.sendMetrics()
+
+      expect(log.error).to.be.calledWith(
+        sinon.match
+          .instanceOf(Error)
+          .and(
+            sinon.match.has(
+              'message',
+              'Cannot push metrics. http://shields-metrics.io/metrics responded with status code 400'
+            )
+          )
+      )
+    })
+  })
+})

core/server/instance-id-generator.js

@@ -0,0 +1,10 @@
+'use strict'
+
+function generateInstanceId() {
+  // from https://gist.github.com/gordonbrander/2230317
+  return Math.random()
+    .toString(36)
+    .substr(2, 9)
+}
+
+module.exports = generateInstanceId

core/server/metrics/format-converters.js

@@ -0,0 +1,27 @@
+'use strict'
+const groupBy = require('lodash.groupby')
+
+function promClientJsonToInfluxV2(metrics, extraLabels = {}) {
+  // TODO Replace with Array.prototype.flatMap() after migrating to Node.js >= 11
+  const flatMap = (f, arr) => arr.reduce((acc, x) => acc.concat(f(x)), [])
+  return flatMap(metric => {
+    const valuesByLabels = groupBy(metric.values, value =>
+      JSON.stringify(Object.entries(value.labels).sort())
+    )
+    return Object.values(valuesByLabels).map(metricsWithSameLabel => {
+      const labels = Object.entries(metricsWithSameLabel[0].labels)
+        .concat(Object.entries(extraLabels))
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(labelEntry => `${labelEntry[0]}=${labelEntry[1]}`)
+        .join(',')
+      const labelsFormatted = labels ? `,${labels}` : ''
+      const values = metricsWithSameLabel
+        .sort((a, b) => a.metricName.localeCompare(b.metricName))
+        .map(value => `${value.metricName || metric.name}=${value.value}`)
+        .join(',')
+      return `prometheus${labelsFormatted} ${values}`
+    })
+  }, metrics).join('\n')
+}
+
+module.exports = { promClientJsonToInfluxV2 }

core/server/metrics/format-converters.spec.js

@@ -0,0 +1,217 @@
+'use strict'
+
+const { expect } = require('chai')
+const prometheus = require('prom-client')
+const { promClientJsonToInfluxV2 } = require('./format-converters')
+
+describe('Metric format converters', function() {
+  describe('prom-client JSON to InfluxDB line protocol (version 2)', function() {
+    it('converts a counter', function() {
+      const json = [
+        {
+          help: 'counter 1 help',
+          name: 'counter1',
+          type: 'counter',
+          values: [{ value: 11, labels: {} }],
+          aggregator: 'sum',
+        },
+      ]
+
+      const influx = promClientJsonToInfluxV2(json)
+
+      expect(influx).to.be.equal('prometheus counter1=11')
+    })
+
+    it('converts a counter (from prometheus registry)', function() {
+      const register = new prometheus.Registry()
+      const counter = new prometheus.Counter({
+        name: 'counter1',
+        help: 'counter 1 help',
+        registers: [register],
+      })
+      counter.inc(11)
+
+      const influx = promClientJsonToInfluxV2(register.getMetricsAsJSON())
+
+      expect(influx).to.be.equal('prometheus counter1=11')
+    })
+
+    it('converts a gauge', function() {
+      const json = [
+        {
+          help: 'gause 1 help',
+          name: 'gauge1',
+          type: 'gauge',
+          values: [{ value: 20, labels: {} }],
+          aggregator: 'sum',
+        },
+      ]
+
+      const influx = promClientJsonToInfluxV2(json)
+
+      expect(influx).to.be.equal('prometheus gauge1=20')
+    })
+
+    it('converts a gauge (from prometheus registry)', function() {
+      const register = new prometheus.Registry()
+      const gauge = new prometheus.Gauge({
+        name: 'gauge1',
+        help: 'gauge 1 help',
+        registers: [register],
+      })
+      gauge.inc(20)
+
+      const influx = promClientJsonToInfluxV2(register.getMetricsAsJSON())
+
+      expect(influx).to.be.equal('prometheus gauge1=20')
+    })
+
+    const sortLines = text =>
+      text
+        .split('\n')
+        .sort()
+        .join('\n')
+
+    it('converts a histogram', function() {
+      const json = [
+        {
+          name: 'histogram1',
+          help: 'histogram 1 help',
+          type: 'histogram',
+          values: [
+            { labels: { le: 5 }, value: 1, metricName: 'histogram1_bucket' },
+            { labels: { le: 15 }, value: 2, metricName: 'histogram1_bucket' },
+            { labels: { le: 50 }, value: 2, metricName: 'histogram1_bucket' },
+            {
+              labels: { le: '+Inf' },
+              value: 3,
+              metricName: 'histogram1_bucket',
+            },
+            { labels: {}, value: 111, metricName: 'histogram1_sum' },
+            { labels: {}, value: 3, metricName: 'histogram1_count' },
+          ],
+          aggregator: 'sum',
+        },
+      ]
+
+      const influx = promClientJsonToInfluxV2(json)
+
+      expect(sortLines(influx)).to.be.equal(
+        sortLines(`prometheus,le=+Inf histogram1_bucket=3
+prometheus,le=50 histogram1_bucket=2
+prometheus,le=15 histogram1_bucket=2
+prometheus,le=5 histogram1_bucket=1
+prometheus histogram1_count=3,histogram1_sum=111`)
+      )
+    })
+
+    it('converts a histogram (from prometheus registry)', function() {
+      const register = new prometheus.Registry()
+      const histogram = new prometheus.Histogram({
+        name: 'histogram1',
+        help: 'histogram 1 help',
+        buckets: [5, 15, 50],
+        registers: [register],
+      })
+      histogram.observe(100)
+      histogram.observe(10)
+      histogram.observe(1)
+
+      const influx = promClientJsonToInfluxV2(register.getMetricsAsJSON())
+
+      expect(sortLines(influx)).to.be.equal(
+        sortLines(`prometheus,le=+Inf histogram1_bucket=3
+prometheus,le=50 histogram1_bucket=2
+prometheus,le=15 histogram1_bucket=2
+prometheus,le=5 histogram1_bucket=1
+prometheus histogram1_count=3,histogram1_sum=111`)
+      )
+    })
+
+    it('converts a summary', function() {
+      const json = [
+        {
+          name: 'summary1',
+          help: 'summary 1 help',
+          type: 'summary',
+          values: [
+            { labels: { quantile: 0.1 }, value: 1 },
+            { labels: { quantile: 0.9 }, value: 100 },
+            { labels: { quantile: 0.99 }, value: 100 },
+            { metricName: 'summary1_sum', labels: {}, value: 111 },
+            { metricName: 'summary1_count', labels: {}, value: 3 },
+          ],
+          aggregator: 'sum',
+        },
+      ]
+
+      const influx = promClientJsonToInfluxV2(json)
+
+      expect(sortLines(influx)).to.be.equal(
+        sortLines(`prometheus,quantile=0.99 summary1=100
+prometheus,quantile=0.9 summary1=100
+prometheus,quantile=0.1 summary1=1
+prometheus summary1_count=3,summary1_sum=111`)
+      )
+    })
+
+    it('converts a summary (from prometheus registry)', function() {
+      const register = new prometheus.Registry()
+      const summary = new prometheus.Summary({
+        name: 'summary1',
+        help: 'summary 1 help',
+        percentiles: [0.1, 0.9, 0.99],
+        registers: [register],
+      })
+      summary.observe(100)
+      summary.observe(10)
+      summary.observe(1)
+
+      const influx = promClientJsonToInfluxV2(register.getMetricsAsJSON())
+
+      expect(sortLines(influx)).to.be.equal(
+        sortLines(`prometheus,quantile=0.99 summary1=100
+prometheus,quantile=0.9 summary1=100
+prometheus,quantile=0.1 summary1=1
+prometheus summary1_count=3,summary1_sum=111`)
+      )
+    })
+
+    it('converts a counter and skip a timestamp', function() {
+      const json = [
+        {
+          help: 'counter 4 help',
+          name: 'counter4',
+          type: 'counter',
+          values: [{ value: 11, labels: {}, timestamp: 1581850552292 }],
+          aggregator: 'sum',
+        },
+      ]
+
+      const influx = promClientJsonToInfluxV2(json)
+
+      expect(influx).to.be.equal('prometheus counter4=11')
+    })
+
+    it('converts a counter and adds extra labels', function() {
+      const json = [
+        {
+          help: 'counter 1 help',
+          name: 'counter1',
+          type: 'counter',
+          values: [{ value: 11, labels: {} }],
+          aggregator: 'sum',
+        },
+      ]
+
+      const influx = promClientJsonToInfluxV2(json, {
+        instance: 'instance1',
+        env: 'production',
+      })
+
+      expect(influx).to.be.equal(
+        'prometheus,env=production,instance=instance1 counter1=11'
+      )
+    })
+  })
+})

core/server/monitor.js

@@ -43,7 +43,7 @@ function setRoutes({ rateLimit }, { server, metricInstance }) {
         .split(/[/-]/)
         .slice(0, 3)
         .join('')
-      const referer = req.headers['referer']
+      const referer = req.headers.referer
 
       if (ipRateLimit.isBanned(ip, req, res)) {
         metricInstance.noteRateLimitExceeded('ip')

core/server/prometheus-metrics.js

@@ -4,8 +4,8 @@ const decamelize = require('decamelize')
 const prometheus = require('prom-client')
 
 module.exports = class PrometheusMetrics {
-  constructor() {
-    this.register = new prometheus.Registry()
+  constructor({ register } = {}) {
+    this.register = register || new prometheus.Registry()
     this.counters = {
       numRequests: new prometheus.Counter({
         name: 'service_requests_total',
@@ -59,12 +59,22 @@ module.exports = class PrometheusMetrics {
         labelNames: ['rate_limit_type'],
         registers: [this.register],
       }),
+      serviceResponseSize: new prometheus.Histogram({
+        name: 'service_response_bytes',
+        help: 'Service response size in bytes',
+        labelNames: ['category', 'family', 'service'],
+        // buckets: 64KiB, 128KiB, 256KiB, 512KiB, 1MiB, 2MiB, 4MiB, 8MiB
+        buckets: prometheus.exponentialBuckets(64 * 1024, 2, 8),
+        registers: [this.register],
+      }),
     }
+    this.interval = prometheus.collectDefaultMetrics({
+      register: this.register,
+    })
   }
 
-  async initialize(server) {
+  async registerMetricsEndpoint(server) {
     const { register } = this
-    this.interval = prometheus.collectDefaultMetrics({ register })
 
     server.route(/^\/metrics$/, (data, match, end, ask) => {
       ask.res.setHeader('Content-Type', register.contentType)
@@ -80,6 +90,10 @@ module.exports = class PrometheusMetrics {
     }
   }
 
+  metrics() {
+    return this.register.getMetricsAsJSON()
+  }
+
   /**
    * @returns {object} `{ inc() {} }`.
    */
@@ -95,4 +109,13 @@ module.exports = class PrometheusMetrics {
   noteRateLimitExceeded(rateLimitType) {
     return this.counters.rateLimitExceeded.labels(rateLimitType).inc()
   }
+
+  createServiceResponseSizeHistogram({ category, serviceFamily, name }) {
+    const service = decamelize(name)
+    return this.counters.serviceResponseSize.labels(
+      category,
+      serviceFamily,
+      service
+    )
+  }
 }

core/server/prometheus-metrics.spec.js

@@ -7,26 +7,26 @@ const got = require('../got-test-client')
 const Metrics = require('./prometheus-metrics')
 
 describe('Prometheus metrics route', function() {
-  let port, baseUrl
+  let port, baseUrl, camp, metrics
   beforeEach(async function() {
     port = await portfinder.getPortPromise()
     baseUrl = `http://127.0.0.1:${port}`
-  })
-
-  let camp
-  beforeEach(async function() {
     camp = Camp.start({ port, hostname: '::' })
     await new Promise(resolve => camp.on('listening', () => resolve()))
   })
   afterEach(async function() {
+    if (metrics) {
+      metrics.stop()
+    }
     if (camp) {
       await new Promise(resolve => camp.close(resolve))
       camp = undefined
     }
   })
 
-  it('returns metrics', async function() {
-    new Metrics({ enabled: true }).initialize(camp)
+  it('returns default metrics', async function() {
+    metrics = new Metrics()
+    metrics.registerMetricsEndpoint(camp)
 
     const { statusCode, body } = await got(`${baseUrl}/metrics`)
 

core/server/server.js

@@ -5,9 +5,9 @@
 
 const path = require('path')
 const url = require('url')
-const bytes = require('bytes')
-const Joi = require('@hapi/joi')
+const { URL } = url
 const Camp = require('camp')
+const originalJoi = require('@hapi/joi')
 const makeBadge = require('../../gh-badges/lib/make-badge')
 const GithubConstellation = require('../../services/github/github-constellation')
 const suggest = require('../../services/suggest')
@@ -19,16 +19,64 @@ const {
 } = require('../base-service/legacy-request-handler')
 const { clearRegularUpdateCache } = require('../legacy/regular-update')
 const { rasterRedirectUrl } = require('../badge-urls/make-badge-url')
+const { merge, checkCustomIntegrationConfiguration } = require('./config')
 const log = require('./log')
 const sysMonitor = require('./monitor')
 const PrometheusMetrics = require('./prometheus-metrics')
+const InfluxMetrics = require('./influx-metrics')
+
+const Joi = originalJoi
+  .extend(base => ({
+    type: 'arrayFromString',
+    base: base.array(),
+    coerce: (value, state, options) => ({
+      value: typeof value === 'string' ? value.split(' ') : value,
+    }),
+  }))
+  .extend(base => ({
+    type: 'string',
+    base: base.string(),
+    messages: {
+      'string.origin':
+        'needs to be an origin string, e.g. https://host.domain with optional port and no trailing slash',
+    },
+    rules: {
+      origin: {
+        validate(value, helpers) {
+          let origin
+          try {
+            ;({ origin } = new URL(value))
+          } catch (e) {}
+          if (origin !== undefined && origin === value) {
+            return value
+          } else {
+            return helpers.error('string.origin')
+          }
+        },
+      },
+    },
+  }))
 
 const optionalUrl = Joi.string().uri({ scheme: ['http', 'https'] })
 const requiredUrl = optionalUrl.required()
+const bytes = Joi.string().regex(/^[0-9]+(b|kb|mb|gb|tb)$/i)
+const requireFields = {
+  required: schema => schema.required(),
+}
+const integrationSchema = Joi.object({
+  fetchLimit: bytes.alter(requireFields),
+})
+const origins = Joi.arrayFromString().items(Joi.string().origin())
+const defaultService = Joi.object({ authorizedOrigins: origins }).default({
+  authorizedOrigins: [],
+})
 
 const publicConfigSchema = Joi.object({
   bind: {
-    port: Joi.number().port(),
+    port: Joi.alternatives().try(
+      Joi.number().port(),
+      Joi.string().pattern(/^\\\\\.\\pipe\\.+$/)
+    ),
     address: Joi.alternatives().try(
       Joi.string()
         .ip()
@@ -41,6 +89,33 @@ const publicConfigSchema = Joi.object({
   metrics: {
     prometheus: {
       enabled: Joi.boolean().required(),
+      endpointEnabled: Joi.boolean().required(),
+    },
+    influx: {
+      enabled: Joi.boolean().required(),
+      url: Joi.string()
+        .uri()
+        .when('enabled', { is: true, then: Joi.required() }),
+      timeoutMilliseconds: Joi.number()
+        .integer()
+        .min(1)
+        .when('enabled', { is: true, then: Joi.required() }),
+      intervalSeconds: Joi.number()
+        .integer()
+        .min(1)
+        .when('enabled', { is: true, then: Joi.required() }),
+      instanceIdFrom: Joi.string()
+        .equal('hostname', 'env-var', 'random')
+        .when('enabled', { is: true, then: Joi.required() }),
+      instanceIdEnvVarName: Joi.string().when('instanceIdFrom', {
+        is: 'env-var',
+        then: Joi.required(),
+      }),
+      envLabel: Joi.string().when('enabled', {
+        is: true,
+        then: Joi.required(),
+      }),
+      hostnameAliases: Joi.object(),
     },
   },
   ssl: {
@@ -58,7 +133,9 @@ const publicConfigSchema = Joi.object({
   persistence: {
     dir: Joi.string().required(),
   },
-  services: {
+  services: Joi.object({
+    bitbucketServer: defaultService,
+    drone: defaultService,
     github: {
       baseUri: requiredUrl,
       debug: {
@@ -69,11 +146,18 @@ const publicConfigSchema = Joi.object({
           .required(),
       },
     },
+    jira: defaultService,
+    jenkins: Joi.object({
+      authorizedOrigins: origins,
+      requireStrictSsl: Joi.boolean(),
+      requireStrictSslToAuthenticate: Joi.boolean(),
+    }).default({ authorizedOrigins: [] }),
+    nexus: defaultService,
+    npm: defaultService,
+    sonar: defaultService,
+    teamcity: defaultService,
     trace: Joi.boolean().required(),
-  },
-  profiling: {
-    makeBadge: Joi.boolean().required(),
-  },
+  }).required(),
   cacheHeaders: {
     defaultCacheLengthSeconds: Joi.number()
       .integer()
@@ -81,13 +165,16 @@ const publicConfigSchema = Joi.object({
   },
   rateLimit: Joi.boolean().required(),
   handleInternalErrors: Joi.boolean().required(),
-  fetchLimit: Joi.string().regex(/^[0-9]+(b|kb|mb|gb|tb)$/i),
+  integrations: Joi.object({
+    default: integrationSchema.tailor('required').required(),
+  }).pattern(Joi.string(), integrationSchema),
 }).required()
 
 const privateConfigSchema = Joi.object({
   azure_devops_token: Joi.string(),
   bintray_user: Joi.string(),
   bintray_apikey: Joi.string(),
+  drone_token: Joi.string(),
   gh_client_id: Joi.string(),
   gh_client_secret: Joi.string(),
   gh_token: Joi.string(),
@@ -105,11 +192,18 @@ const privateConfigSchema = Joi.object({
   sl_insight_userUuid: Joi.string(),
   sl_insight_apiToken: Joi.string(),
   sonarqube_token: Joi.string(),
+  teamcity_user: Joi.string(),
+  teamcity_pass: Joi.string(),
   twitch_client_id: Joi.string(),
   twitch_client_secret: Joi.string(),
   wheelmap_token: Joi.string(),
+  influx_username: Joi.string(),
+  influx_password: Joi.string(),
 }).required()
-
+const privateMetricsInfluxConfigSchema = privateConfigSchema.append({
+  influx_username: Joi.string().required(),
+  influx_password: Joi.string().required(),
+})
 /**
  * The Server is based on the web framework Scoutcamp. It creates
  * an http server, sets up helpers for token persistence and monitoring.
@@ -121,22 +215,25 @@ class Server {
    * Badge Server Constructor
    *
    * @param {object} config Configuration object read from config yaml files
-   *    by https://www.npmjs.com/package/config and validated against
-   *    publicConfigSchema and privateConfigSchema
+   * by https://www.npmjs.com/package/config and validated against
+   * publicConfigSchema and privateConfigSchema
    * @see https://github.com/badges/shields/blob/master/doc/production-hosting.md#configuration
    * @see https://github.com/badges/shields/blob/master/doc/server-secrets.md
    */
   constructor(config) {
     const publicConfig = Joi.attempt(config.public, publicConfigSchema)
-    let privateConfig
-    try {
-      privateConfig = Joi.attempt(config.private, privateConfigSchema)
-    } catch (e) {
-      const badPaths = e.details.map(({ path }) => path)
-      throw Error(
-        `Private configuration is invalid. Check these paths: ${badPaths.join(
-          ','
-        )}`
+    const privateConfig = this.validatePrivateConfig(
+      config.private,
+      privateConfigSchema
+    )
+    // We want to require an username and a password for the influx metrics
+    // only if the influx metrics are enabled. The private config schema
+    // and the public config schema are two separate schemas so we have to run
+    // validation manually.
+    if (publicConfig.metrics.influx && publicConfig.metrics.influx.enabled) {
+      this.validatePrivateConfig(
+        config.private,
+        privateMetricsInfluxConfigSchema
       )
     }
     this.config = {
@@ -149,8 +246,31 @@ class Server {
       service: publicConfig.services.github,
       private: privateConfig,
     })
+
     if (publicConfig.metrics.prometheus.enabled) {
       this.metricInstance = new PrometheusMetrics()
+      if (publicConfig.metrics.influx.enabled) {
+        this.influxMetrics = new InfluxMetrics(
+          this.metricInstance,
+          Object.assign({}, publicConfig.metrics.influx, {
+            username: privateConfig.influx_username,
+            password: privateConfig.influx_password,
+          })
+        )
+      }
+    }
+  }
+
+  validatePrivateConfig(privateConfig, privateConfigSchema) {
+    try {
+      return Joi.attempt(privateConfig, privateConfigSchema)
+    } catch (e) {
+      const badPaths = e.details.map(({ path }) => path)
+      throw Error(
+        `Private configuration is invalid. Check these paths: ${badPaths.join(
+          ','
+        )}`
+      )
     }
   }
 
@@ -187,7 +307,11 @@ class Server {
 
     camp.route(/\.(gif|jpg)$/, (query, match, end, request) => {
       const [, format] = match
-      makeSend('svg', request.res, end)(
+      makeSend(
+        'svg',
+        request.res,
+        end
+      )(
         makeBadge({
           text: ['410', `${format} no longer available`],
           color: 'lightgray',
@@ -198,7 +322,11 @@ class Server {
 
     if (!rasterUrl) {
       camp.route(/\.png$/, (query, match, end, request) => {
-        makeSend('svg', request.res, end)(
+        makeSend(
+          'svg',
+          request.res,
+          end
+        )(
           makeBadge({
             text: ['404', 'raster badges not available'],
             color: 'lightgray',
@@ -212,7 +340,11 @@ class Server {
       const [, extension] = match
       const format = (extension || '.svg').replace(/^\./, '')
 
-      makeSend(format, request.res, end)(
+      makeSend(
+        format,
+        request.res,
+        end
+      )(
         makeBadge({
           text: ['404', 'badge not found'],
           color: 'red',
@@ -268,19 +400,25 @@ class Server {
     const { config, camp, metricInstance } = this
     const { apiProvider: githubApiProvider } = this.githubConstellation
 
-    loadServiceClasses().forEach(serviceClass =>
+    const serviceClasses = loadServiceClasses()
+    checkCustomIntegrationConfiguration(config, serviceClasses)
+    serviceClasses.forEach(serviceClass => {
+      const serviceConfig = merge(
+        config.public.integrations.default,
+        config.public.integrations[serviceClass.name] || {}
+      )
       serviceClass.register(
         { camp, handleRequest, githubApiProvider, metricInstance },
         {
           handleInternalErrors: config.public.handleInternalErrors,
           cacheHeaders: config.public.cacheHeaders,
-          profiling: config.public.profiling,
-          fetchLimitBytes: bytes(config.public.fetchLimit),
           rasterUrl: config.public.rasterUrl,
           private: config.private,
+          public: config.public,
+          ...serviceConfig,
         }
       )
-    )
+    })
   }
 
   /**
@@ -317,7 +455,12 @@ class Server {
     const { githubConstellation } = this
     githubConstellation.initialize(camp)
     if (metricInstance) {
-      metricInstance.initialize(camp)
+      if (this.config.public.metrics.prometheus.endpointEnabled) {
+        metricInstance.registerMetricsEndpoint(camp)
+      }
+      if (this.influxMetrics) {
+        this.influxMetrics.startPushingMetrics()
+      }
     }
 
     const { apiProvider: githubApiProvider } = this.githubConstellation
@@ -361,6 +504,9 @@ class Server {
     }
 
     if (this.metricInstance) {
+      if (this.influxMetrics) {
+        this.influxMetrics.stopPushingMetrics()
+      }
       this.metricInstance.stop()
     }
   }

core/server/server.spec.js

@@ -2,153 +2,333 @@
 
 const { expect } = require('chai')
 const isSvg = require('is-svg')
-const portfinder = require('portfinder')
+const config = require('config')
 const got = require('../got-test-client')
+const Server = require('./server')
 const { createTestServer } = require('./in-process-server-test-helpers')
 
 describe('The server', function() {
-  let server, baseUrl
-  before('Start the server', async function() {
-    // Fixes https://github.com/badges/shields/issues/2611
-    this.timeout(10000)
-    const port = await portfinder.getPortPromise()
-    server = createTestServer({ port })
-    baseUrl = server.baseUrl
-    await server.start()
-  })
-  after('Shut down the server', async function() {
-    if (server) {
-      await server.stop()
-    }
-    server = undefined
-  })
-
-  it('should produce colorscheme badges', async function() {
-    const { statusCode, body } = await got(`${baseUrl}:fruit-apple-green.svg`)
-    expect(statusCode).to.equal(200)
-    expect(body)
-      .to.satisfy(isSvg)
-      .and.to.include('fruit')
-      .and.to.include('apple')
-  })
-
-  it('should redirect colorscheme PNG badges as configured', async function() {
-    const { statusCode, headers } = await got(
-      `${baseUrl}:fruit-apple-green.png`,
-      {
-        followRedirect: false,
+  describe('running', function() {
+    let server, baseUrl
+    before('Start the server', async function() {
+      // Fixes https://github.com/badges/shields/issues/2611
+      this.timeout(10000)
+      server = await createTestServer()
+      baseUrl = server.baseUrl
+      await server.start()
+    })
+    after('Shut down the server', async function() {
+      if (server) {
+        await server.stop()
       }
-    )
-    expect(statusCode).to.equal(301)
-    expect(headers.location).to.equal(
-      'http://raster.example.test/:fruit-apple-green.png'
-    )
-  })
-
-  it('should redirect modern PNG badges as configured', async function() {
-    const { statusCode, headers } = await got(`${baseUrl}npm/v/express.png`, {
-      followRedirect: false,
-    })
-    expect(statusCode).to.equal(301)
-    expect(headers.location).to.equal(
-      'http://raster.example.test/npm/v/express.png'
-    )
-  })
-
-  it('should produce json badges', async function() {
-    const { statusCode, body, headers } = await got(
-      `${baseUrl}npm/v/express.json`
-    )
-    expect(statusCode).to.equal(200)
-    expect(headers['content-type']).to.equal('application/json')
-    expect(() => JSON.parse(body)).not.to.throw()
-  })
-
-  it('should preserve label case', async function() {
-    const { statusCode, body } = await got(`${baseUrl}:fRuiT-apple-green.svg`)
-    expect(statusCode).to.equal(200)
-    expect(body)
-      .to.satisfy(isSvg)
-      .and.to.include('fRuiT')
-  })
-
-  // https://github.com/badges/shields/pull/1319
-  it('should not crash with a numeric logo', async function() {
-    const { statusCode, body } = await got(
-      `${baseUrl}:fruit-apple-green.svg?logo=1`
-    )
-    expect(statusCode).to.equal(200)
-    expect(body)
-      .to.satisfy(isSvg)
-      .and.to.include('fruit')
-      .and.to.include('apple')
-  })
-
-  it('should not crash with a numeric link', async function() {
-    const { statusCode, body } = await got(
-      `${baseUrl}:fruit-apple-green.svg?link=1`
-    )
-    expect(statusCode).to.equal(200)
-    expect(body)
-      .to.satisfy(isSvg)
-      .and.to.include('fruit')
-      .and.to.include('apple')
-  })
-
-  it('should not crash with a boolean link', async function() {
-    const { statusCode, body } = await got(
-      `${baseUrl}:fruit-apple-green.svg?link=true`
-    )
-    expect(statusCode).to.equal(200)
-    expect(body)
-      .to.satisfy(isSvg)
-      .and.to.include('fruit')
-      .and.to.include('apple')
-  })
-
-  it('should return the 404 badge for unknown badges', async function() {
-    const { statusCode, body } = await got(
-      `${baseUrl}this/is/not/a/badge.svg`,
-      { throwHttpErrors: false }
-    )
-    expect(statusCode).to.equal(404)
-    expect(body)
-      .to.satisfy(isSvg)
-      .and.to.include('404')
-      .and.to.include('badge not found')
-  })
-
-  it('should return the 404 badge page for rando links', async function() {
-    const { statusCode, body } = await got(
-      `${baseUrl}this/is/most/definitely/not/a/badge.js`,
-      { throwHttpErrors: false }
-    )
-    expect(statusCode).to.equal(404)
-    expect(body)
-      .to.satisfy(isSvg)
-      .and.to.include('404')
-      .and.to.include('badge not found')
-  })
-
-  it('should redirect the root as configured', async function() {
-    const { statusCode, headers } = await got(baseUrl, {
-      followRedirect: false,
+      server = undefined
     })
 
-    expect(statusCode).to.equal(302)
-    // This value is set in `config/test.yml`
-    expect(headers.location).to.equal('http://frontend.example.test')
+    it('should allow strings for port', async function() {
+      // fixes #4391 - This allows the app to be run using iisnode, which uses a named pipe for the port.
+      const pipeServer = await createTestServer({
+        public: {
+          bind: {
+            port: '\\\\.\\pipe\\9c137306-7c4d-461e-b7cf-5213a3939ad6',
+          },
+        },
+      })
+      expect(pipeServer).to.not.be.undefined
+    })
+
+    it('should produce colorscheme badges', async function() {
+      const { statusCode, body } = await got(`${baseUrl}:fruit-apple-green.svg`)
+      expect(statusCode).to.equal(200)
+      expect(body)
+        .to.satisfy(isSvg)
+        .and.to.include('fruit')
+        .and.to.include('apple')
+    })
+
+    it('should redirect colorscheme PNG badges as configured', async function() {
+      const { statusCode, headers } = await got(
+        `${baseUrl}:fruit-apple-green.png`,
+        {
+          followRedirect: false,
+        }
+      )
+      expect(statusCode).to.equal(301)
+      expect(headers.location).to.equal(
+        'http://raster.example.test/:fruit-apple-green.png'
+      )
+    })
+
+    it('should redirect modern PNG badges as configured', async function() {
+      const { statusCode, headers } = await got(`${baseUrl}npm/v/express.png`, {
+        followRedirect: false,
+      })
+      expect(statusCode).to.equal(301)
+      expect(headers.location).to.equal(
+        'http://raster.example.test/npm/v/express.png'
+      )
+    })
+
+    it('should produce json badges', async function() {
+      const { statusCode, body, headers } = await got(
+        `${baseUrl}twitter/follow/_Pyves.json`
+      )
+      expect(statusCode).to.equal(200)
+      expect(headers['content-type']).to.equal('application/json')
+      expect(() => JSON.parse(body)).not.to.throw()
+    })
+
+    it('should preserve label case', async function() {
+      const { statusCode, body } = await got(`${baseUrl}:fRuiT-apple-green.svg`)
+      expect(statusCode).to.equal(200)
+      expect(body)
+        .to.satisfy(isSvg)
+        .and.to.include('fRuiT')
+    })
+
+    // https://github.com/badges/shields/pull/1319
+    it('should not crash with a numeric logo', async function() {
+      const { statusCode, body } = await got(
+        `${baseUrl}:fruit-apple-green.svg?logo=1`
+      )
+      expect(statusCode).to.equal(200)
+      expect(body)
+        .to.satisfy(isSvg)
+        .and.to.include('fruit')
+        .and.to.include('apple')
+    })
+
+    it('should not crash with a numeric link', async function() {
+      const { statusCode, body } = await got(
+        `${baseUrl}:fruit-apple-green.svg?link=1`
+      )
+      expect(statusCode).to.equal(200)
+      expect(body)
+        .to.satisfy(isSvg)
+        .and.to.include('fruit')
+        .and.to.include('apple')
+    })
+
+    it('should not crash with a boolean link', async function() {
+      const { statusCode, body } = await got(
+        `${baseUrl}:fruit-apple-green.svg?link=true`
+      )
+      expect(statusCode).to.equal(200)
+      expect(body)
+        .to.satisfy(isSvg)
+        .and.to.include('fruit')
+        .and.to.include('apple')
+    })
+
+    it('should return the 404 badge for unknown badges', async function() {
+      const { statusCode, body } = await got(
+        `${baseUrl}this/is/not/a/badge.svg`,
+        {
+          throwHttpErrors: false,
+        }
+      )
+      expect(statusCode).to.equal(404)
+      expect(body)
+        .to.satisfy(isSvg)
+        .and.to.include('404')
+        .and.to.include('badge not found')
+    })
+
+    it('should return the 404 badge page for rando links', async function() {
+      const { statusCode, body } = await got(
+        `${baseUrl}this/is/most/definitely/not/a/badge.js`,
+        {
+          throwHttpErrors: false,
+        }
+      )
+      expect(statusCode).to.equal(404)
+      expect(body)
+        .to.satisfy(isSvg)
+        .and.to.include('404')
+        .and.to.include('badge not found')
+    })
+
+    it('should redirect the root as configured', async function() {
+      const { statusCode, headers } = await got(baseUrl, {
+        followRedirect: false,
+      })
+
+      expect(statusCode).to.equal(302)
+      // This value is set in `config/test.yml`
+      expect(headers.location).to.equal('http://frontend.example.test')
+    })
+
+    it('should return the 410 badge for obsolete formats', async function() {
+      const { statusCode, body } = await got(`${baseUrl}npm/v/express.jpg`, {
+        throwHttpErrors: false,
+      })
+      // TODO It would be nice if this were 404 or 410.
+      expect(statusCode).to.equal(200)
+      expect(body)
+        .to.satisfy(isSvg)
+        .and.to.include('410')
+        .and.to.include('jpg no longer available')
+    })
   })
 
-  it('should return the 410 badge for obsolete formats', async function() {
-    const { statusCode, body } = await got(`${baseUrl}npm/v/express.jpg`, {
-      throwHttpErrors: false,
+  describe('configuration', function() {
+    let server
+    afterEach(async function() {
+      if (server) {
+        server.stop()
+      }
+    })
+
+    it('should allow to enable prometheus metrics', async function() {
+      // Fixes https://github.com/badges/shields/issues/2611
+      this.timeout(10000)
+      server = await createTestServer({
+        public: {
+          metrics: { prometheus: { enabled: true, endpointEnabled: true } },
+        },
+      })
+      await server.start()
+
+      const { statusCode } = await got(`${server.baseUrl}metrics`)
+
+      expect(statusCode).to.be.equal(200)
+    })
+
+    it('should allow to disable prometheus metrics', async function() {
+      // Fixes https://github.com/badges/shields/issues/2611
+      this.timeout(10000)
+      server = await createTestServer({
+        public: {
+          metrics: { prometheus: { enabled: true, endpointEnabled: false } },
+        },
+      })
+      await server.start()
+
+      const { statusCode } = await got(`${server.baseUrl}metrics`, {
+        throwHttpErrors: false,
+      })
+
+      expect(statusCode).to.be.equal(404)
+    })
+  })
+
+  describe('configuration validation', function() {
+    describe('influx', function() {
+      let customConfig
+      beforeEach(function() {
+        customConfig = config.util.toObject()
+        customConfig.public.metrics.influx = {
+          enabled: true,
+          url: 'http://localhost:8081/telegraf',
+          timeoutMilliseconds: 1000,
+          intervalSeconds: 2,
+          instanceIdFrom: 'random',
+          instanceIdEnvVarName: 'INSTANCE_ID',
+          hostnameAliases: { 'metrics-hostname': 'metrics-hostname-alias' },
+          envLabel: 'test-env',
+        }
+        customConfig.private = {
+          influx_username: 'telegraf',
+          influx_password: 'telegrafpass',
+        }
+      })
+
+      it('should not require influx configuration', function() {
+        delete customConfig.public.metrics.influx
+        expect(() => new Server(config.util.toObject())).to.not.throw()
+      })
+
+      it('should require url when influx configuration is enabled', function() {
+        delete customConfig.public.metrics.influx.url
+        expect(() => new Server(customConfig)).to.throw(
+          '"metrics.influx.url" is required'
+        )
+      })
+
+      it('should not require url when influx configuration is disabled', function() {
+        customConfig.public.metrics.influx.enabled = false
+        delete customConfig.public.metrics.influx.url
+        expect(() => new Server(customConfig)).to.not.throw()
+      })
+
+      it('should require timeoutMilliseconds when influx configuration is enabled', function() {
+        delete customConfig.public.metrics.influx.timeoutMilliseconds
+        expect(() => new Server(customConfig)).to.throw(
+          '"metrics.influx.timeoutMilliseconds" is required'
+        )
+      })
+
+      it('should require intervalSeconds when influx configuration is enabled', function() {
+        delete customConfig.public.metrics.influx.intervalSeconds
+        expect(() => new Server(customConfig)).to.throw(
+          '"metrics.influx.intervalSeconds" is required'
+        )
+      })
+
+      it('should require instanceIdFrom when influx configuration is enabled', function() {
+        delete customConfig.public.metrics.influx.instanceIdFrom
+        expect(() => new Server(customConfig)).to.throw(
+          '"metrics.influx.instanceIdFrom" is required'
+        )
+      })
+
+      it('should require instanceIdEnvVarName when instanceIdFrom is env-var', function() {
+        customConfig.public.metrics.influx.instanceIdFrom = 'env-var'
+        delete customConfig.public.metrics.influx.instanceIdEnvVarName
+        expect(() => new Server(customConfig)).to.throw(
+          '"metrics.influx.instanceIdEnvVarName" is required'
+        )
+      })
+
+      it('should allow instanceIdFrom = hostname', function() {
+        customConfig.public.metrics.influx.instanceIdFrom = 'hostname'
+        expect(() => new Server(customConfig)).to.not.throw()
+      })
+
+      it('should allow instanceIdFrom = env-var', function() {
+        customConfig.public.metrics.influx.instanceIdFrom = 'env-var'
+        expect(() => new Server(customConfig)).to.not.throw()
+      })
+
+      it('should allow instanceIdFrom = random', function() {
+        customConfig.public.metrics.influx.instanceIdFrom = 'random'
+        expect(() => new Server(customConfig)).to.not.throw()
+      })
+
+      it('should require envLabel when influx configuration is enabled', function() {
+        delete customConfig.public.metrics.influx.envLabel
+        expect(() => new Server(customConfig)).to.throw(
+          '"metrics.influx.envLabel" is required'
+        )
+      })
+
+      it('should not require hostnameAliases', function() {
+        delete customConfig.public.metrics.influx.hostnameAliases
+        expect(() => new Server(customConfig)).to.not.throw()
+      })
+
+      it('should allow empty hostnameAliases', function() {
+        customConfig.public.metrics.influx.hostnameAliases = {}
+        expect(() => new Server(customConfig)).to.not.throw()
+      })
+
+      it('should require username when influx configuration is enabled', function() {
+        delete customConfig.private.influx_username
+        expect(() => new Server(customConfig)).to.throw(
+          'Private configuration is invalid. Check these paths: influx_username'
+        )
+      })
+
+      it('should require password when influx configuration is enabled', function() {
+        delete customConfig.private.influx_password
+        expect(() => new Server(customConfig)).to.throw(
+          'Private configuration is invalid. Check these paths: influx_password'
+        )
+      })
+
+      it('should allow other private keys', function() {
+        customConfig.private.gh_token = 'my-token'
+        expect(() => new Server(customConfig)).to.not.throw()
+      })
     })
-    // TODO It would be nice if this were 404 or 410.
-    expect(statusCode).to.equal(200)
-    expect(body)
-      .to.satisfy(isSvg)
-      .and.to.include('410')
-      .and.to.include('jpg no longer available')
   })
 })

core/service-test-runner/cli.js

@@ -73,8 +73,14 @@ if (process.env.TESTED_SERVER_URL) {
 } else {
   const port = 1111
   baseUrl = 'http://localhost:1111'
-  before('Start running the server', function() {
-    server = createTestServer({ port })
+  before('Start running the server', async function() {
+    server = await createTestServer({
+      public: {
+        bind: {
+          port,
+        },
+      },
+    })
     server.start()
   })
   after('Shut down the server', async function() {

core/service-test-runner/icedfrisby-shields.js

@@ -22,6 +22,14 @@ const factory = superclass =>
       this.intercepted = false
     }
 
+    get(uri, options = { followRedirect: false }) {
+      if (!options.followRedirect) {
+        options.followRedirect = false
+      }
+      super.get(uri, options)
+      return this
+    }
+
     intercept(setup) {
       super.intercept(setup)
       this.intercepted = true
@@ -51,6 +59,10 @@ const factory = superclass =>
       })
     }
 
+    expectRedirect(location) {
+      return this.expectStatus(301).expectHeader('Location', location)
+    }
+
     static _expectField(json, name, expected) {
       if (typeof expected === 'undefined') return
       if (typeof expected === 'string' || typeof expected === 'number') {

core/service-test-runner/pull-request-services-cli.js

@@ -25,8 +25,10 @@ async function getTitle(owner, repo, pullRequest) {
   } = await got(
     `https://api.github.com/repos/${owner}/${repo}/pulls/${pullRequest}`,
     {
-      headers: { 'User-Agent': 'badges/shields' },
-      query: { access_token: process.env.GITHUB_TOKEN },
+      headers: {
+        'User-Agent': 'badges/shields',
+        Authorization: `token ${process.env.GITHUB_TOKEN}`,
+      },
       json: true,
     }
   )

core/token-pooling/token-pool.js

@@ -55,18 +55,23 @@ class Token {
   get id() {
     return this._id
   }
+
   get data() {
     return this._data
   }
+
   get usesRemaining() {
     return this._usesRemaining
   }
+
   get nextReset() {
     return this._nextReset
   }
+
   get isValid() {
     return this._isValid
   }
+
   get isFrozen() {
     return this._isFrozen
   }

doc/TUTORIAL.md

@@ -151,6 +151,7 @@ Description of the code:
      number of named parameters. These are converted into
      regular expressions by [`path-to-regexp`][path-to-regexp].
      Because a service instance won't be created until it's time to handle a request, the route and other metadata must be obtained by examining the classes themselves. [That's why they're marked `static`.][static]
+   - There is additional documentation on conventions for [designing badge URLs](badge-urls)
 6. All badges must implement the `async handle()` function that receives parameters to render the badge. Parameters of `handle()` will match the name defined in `route()` Because we're capturing a single variable called `text` our function signature is `async handle({ text })`. `async` is needed to let JavaScript do other things while we are waiting for result from external API. Although in this simple case, we don't make any external calls. Our `handle()` function should return an object with 3 properties:
    - `label`: the text on the left side of the badge
    - `message`: the text on the right side of the badge - here we are passing through the parameter we captured in the route regex

doc/badge-urls.md

@@ -0,0 +1,26 @@
+# Badge URL Conventions
+
+- The format of new badges should be of the form `/SERVICE/NOUN/PARAMETERS?QUERYSTRING` e.g:
+  `/github/issues/:user/:repo`. The service is github, the
+  badge is for issues, and the parameters are `:user/:repo`.
+- Parameters should always be part of the route if they are required to display a badge e.g: `:packageName`.
+- Common optional params like, `:branch` or `:tag` should also be passed as part of the route.
+- Query string parameters should be used when:
+  - The parameter is related to formatting. e.g: `/appveyor/tests/:user/:repo?compact_message`.
+  - The parameter is for an uncommon optional attribute, like an alternate registry URL.
+  - The parameter triggers application of alternative logic, like version semantics. e.g: `/github/v/tag/:user/:repo?sort=semver`.
+  - Services which require a url/hostname parameter always should use a query string parameter to accept that value. e.g: `/discourse/topics?server=https://meta.discourse.org`.
+
+It is convention to use the following standard routes and abbreviations across services:
+
+- Coverage: `/coverage`
+- Downloads or Installs:
+  - Total: `/dt` - Use this even for services that only provide the total download/install data
+  - Per month: `/dm`
+  - Per week: `/dw`
+  - Per day: `/dd`
+- Rating:
+  - Numeric: `/rating`
+  - Stars: `/stars`
+- License: `/l`
+- Version or Release: `/v`

doc/performance-testing.md

@@ -0,0 +1,45 @@
+# Performance testing
+
+Shields has some basic tooling available to help you get started with
+performance testing.
+
+## Benchmarking the badge generation
+
+Want to micro-benchmark a section of the code responsible for generating the
+static badges? Follow these two simple steps:
+
+1. Surround the code you want to time with `console.time` and `console.timeEnd`
+   statements. For example:
+
+```
+console.time('makeBadge')
+const svg = makeBadge(badgeData)
+console.timeEnd('makeBadge')
+```
+
+2. Run `npm run benchmark:badge` in your terminal. An average timing will
+   be displayed!
+
+If you want to change the number of iterations in the benchmark, you can modify
+the values specified by the `benchmark:badge` script in _package.json_. If
+you want to benchmark a specific code path not covered by the static badge, you
+can modify the badge URL in _scripts/benchmark-performance.js_.
+
+## Profiling the full code
+
+Want to have an overview of how the entire application is performing? Simply
+run `npm run profile:server` in your terminal. This will start the
+backend server (i.e. without the frontend) in profiling mode and any requests
+you make on `localhost:8080` will generate data in a file with a name
+similar to _isolate-00000244AB6ED3B0-11920-v8.log_.
+
+You can then make use of this profiling data in various tools, for example
+[flamebearer](https://github.com/mapbox/flamebearer):
+
+```
+npm install -g flamebearer
+node --prof-process --preprocess -j isolate-00000244AB6ED3B0-11920-v8.log | flamebearer
+```
+
+An example output is the following:
+![](https://raw.github.com/badges/shields/master/doc/flamegraph.png)

doc/self-hosting.md

@@ -8,7 +8,7 @@ You will need Node 8 or later, which you can install using a
 On Ubuntu / Debian:
 
 ```sh
-curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -; sudo apt-get install -y nodejs
+curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -; sudo apt-get install -y nodejs
 ```
 
 ```sh

doc/server-secrets.md

@@ -10,14 +10,19 @@ There are two ways of setting secrets:
    environment.
 
 ```sh
-GH_TOKEN=...
+DRONE_TOKEN=...
+DRONE_ORIGINS="https://drone.example.com"
 ```
 
 2. Via checked-in `config/local.yml`:
 
 ```yml
+public:
+  services:
+    drone:
+      authorizedOrigins: ['https://drone.example.com']
 private:
-  gh_token: '...'
+  drone_token: '...'
 ```
 
 For more complex scenarios, configuration files can cascade. See the [node-config documentation][]
@@ -25,9 +30,43 @@ for details.
 
 [node-config documentation]: https://github.com/lorenwest/node-config/wiki/Configuration-Files
 
-## Azure DevOps
+## Authorized origins
 
-- `AZURE_DEVOPS_TOKEN` (yml: `azure_devops_token`)
+Several of the badges provided by Shields allow users to specify the target
+URL/server of the upstream instance to use via a query parameter in the badge URL
+(e.g. https://img.shields.io/nexus/s/com.google.guava/guava?server=https%3A%2F%2Foss.sonatype.org).
+This supports scenarios where your users may need badges from multiple upstream
+targets, for example if you have more than one Nexus server.
+
+Accordingly, if you configure credentials for one of these services with your
+self-hosted Shields instance, you must also specifically authorize the hosts
+to which the credentials are allowed to be sent. If your self-hosted Shields
+instance then receives a badge request for a target that does not match any
+of the authorized origins, one of two things will happen:
+
+- if credentials are required for the targeted service, Shields will render
+  an error badge.
+- if credentials are optional for the targeted service, Shields will attempt
+  the request, but without sending any credentials.
+
+When setting authorized origins through an environment variable, use a space
+to separate multiple origins. Note that failing to define authorized origins
+for a service will default to an empty list, i.e. no authorized origins.
+
+It is highly recommended to use `https` origins with valid SSL, to avoid the
+possibility of exposing your credentials, for example through DNS-based attacks.
+
+It is also recommended to use tokens for a service account having
+[the fewest privileges needed][polp] for fetching the relevant status
+information.
+
+[polp]: https://en.wikipedia.org/wiki/Principle_of_least_privilege
+
+## Services
+
+### Azure DevOps
+
+- `AZURE_DEVOPS_TOKEN` (yml: `private.azure_devops_token`)
 
 An Azure DevOps Token (PAT) is required for accessing [private Azure DevOps projects][ado project visibility].
 
@@ -41,24 +80,45 @@ An Azure DevOps Token (PAT) is required for accessing [private Azure DevOps proj
 [ado personal access tokens]: https://docs.microsoft.com/en-us/azure/devops/organizations/accounts/use-personal-access-tokens-to-authenticate?view=vsts#create-personal-access-tokens-to-authenticate-access
 [ado token scopes]: https://docs.microsoft.com/en-us/azure/devops/integrate/get-started/authentication/oauth?view=vsts#scopes
 
-## Bintray
+### Bintray
 
-- `BINTRAY_USER` (yml: `bintray_user`)
-- `BINTRAY_API_KEY` (yml: `bintray_apikey`)
+- `BINTRAY_USER` (yml: `private.bintray_user`)
+- `BINTRAY_API_KEY` (yml: `private.bintray_apikey`)
 
 The bintray API [requires authentication](https://bintray.com/docs/api/#_authentication)
 Create an account and obtain a token from the user profile page.
 
-## Drone
+### Bitbucket (Cloud)
 
-- `DRONE_TOKEN` (yml: `drone_token`)
+- `BITBUCKET_USER` (yml: `private.bitbucket_username`)
+- `BITBUCKET_PASS` (yml: `private.bitbucket_password`)
 
-The self-hosted Drone API [requires authentication](https://0-8-0.docs.drone.io/api-authentication/)
-Login to your Drone instance and obtain a token from the user profile page.
+Bitbucket badges use basic auth. Provide a username and password to give your
+self-hosted Shields installation access to private repositories hosted on bitbucket.org.
 
-## GitHub
+### Bitbucket Server
 
-- `GH_TOKEN` (yml: `gh_token`)
+- `BITBUCKET_SERVER_ORIGINS` (yml: `public.services.bitbucketServer.authorizedOrigins`)
+- `BITBUCKET_SERVER_USER` (yml: `private.bitbucket_server_username`)
+- `BITBUCKET_SERVER_PASS` (yml: `private.bitbucket_server_password`)
+
+Bitbucket badges use basic auth. Provide a username and password to give your
+self-hosted Shields installation access to a private Bitbucket Server instance.
+
+### Drone
+
+- `DRONE_ORIGINS` (yml: `public.services.drone.authorizedOrigins`)
+- `DRONE_TOKEN` (yml: `private.drone_token`)
+
+The self-hosted Drone API [requires authentication][drone auth]. Log in to your
+Drone instance and obtain a token from the user profile page.
+
+[drone auth]: https://0-8-0.docs.drone.io/api-authentication/
+
+### GitHub
+
+- `GITHUB_URL` (yml: `public.services.github.baseUri`)
+- `GH_TOKEN` (yml: `private.gh_token`)
 
 Because of Github rate limits, you will need to provide a token, or else badges
 will stop working once you hit 60 requests per hour, the
@@ -72,76 +132,85 @@ will have access to your private repositories.
 When a `gh_token` is specified, it is used in place of the Shields token
 rotation logic.
 
+`GITHUB_URL` can be used to optionally send all the GitHub requests to a
+GitHub Enterprise server. This can be done in conjunction with setting a
+token, though it's not required.
+
 [github rate limit]: https://developer.github.com/v3/#rate-limiting
 [personal access tokens]: https://github.com/settings/tokens
 
-- `GH_CLIENT_ID` (yml: `gh_client_id`)
-- `GH_CLIENT_SECRET` (yml: `gh_client_secret`)
+- `GH_CLIENT_ID` (yml: `private.gh_client_id`)
+- `GH_CLIENT_SECRET` (yml: `private.gh_client_secret`)
 
 These settings are used by shields.io for GitHub OAuth app authorization
 but will not be necessary for most self-hosted installations. See
 [production-hosting.md](./production-hosting.md).
 
-## Jenkins CI
+### Jenkins CI
 
-- `JENKINS_USER` (yml: `jenkins_user`)
-- `JENKINS_PASS` (yml: `jenkins_pass`)
+- `JENKINS_ORIGINS` (yml: `public.services.jenkins.authorizedOrigins`)
+- `JENKINS_USER` (yml: `private.jenkins_user`)
+- `JENKINS_PASS` (yml: `private.jenkins_pass`)
 
 Provide a username and password to give your self-hosted Shields installation
 access to a private Jenkins CI instance.
 
-## JIRA
+### Jira
 
-- `JIRA_USER` (yml: `jira_user`)
-- `JIRA_PASS` (yml: `jira_pass`)
+- `JIRA_ORIGINS` (yml: `public.services.jira.authorizedOrigins`)
+- `JIRA_USER` (yml: `private.jira_user`)
+- `JIRA_PASS` (yml: `private.jira_pass`)
 
 Provide a username and password to give your self-hosted Shields installation
 access to a private JIRA instance.
 
-## Nexus
+### Nexus
 
-- `NEXUS_USER` (yml: `nexus_user`)
-- `NEXUS_PASS` (yml: `nexus_pass`)
+- `NEXUS_ORIGINS` (yml: `public.services.nexus.authorizedOrigins`)
+- `NEXUS_USER` (yml: `private.nexus_user`)
+- `NEXUS_PASS` (yml: `private.nexus_pass`)
 
 Provide a username and password to give your self-hosted Shields installation
 access to your private nexus repositories.
 
-## NPM
+### npm
 
-- `NPM_TOKEN` (yml: `npm_token`)
+- `NPM_ORIGINS` (yml: `public.services.npm.authorizedOrigins`)
+- `NPM_TOKEN` (yml: `private.npm_token`)
 
 [Generate an npm token][npm token] to give your self-hosted Shields
 installation access to private npm packages
 
 [npm token]: https://docs.npmjs.com/getting-started/working_with_tokens
 
-## Sentry
+### SymfonyInsight (formerly Sensiolabs)
 
-- `SENTRY_DSN` (yml: `sentry_dsn`)
-
-A [Sentry DSN](https://docs.sentry.io/error-reporting/quickstart/?platform=javascript#configure-the-dsn)
-may be used to send error reports from your installation to
-[Sentry.io](http://sentry.io/). For more info, see the
-[self hosting docs](https://github.com/badges/shields/blob/master/doc/self-hosting.md#sentry).
-
-## SymfonyInsight (formerly Sensiolabs)
-
-- `SL_INSIGHT_USER_UUID` (yml: `sl_insight_userUuid`)
-- `SL_INSIGHT_API_TOKEN` (yml: `sl_insight_apiToken`)
+- `SL_INSIGHT_USER_UUID` (yml: `private.sl_insight_userUuid`)
+- `SL_INSIGHT_API_TOKEN` (yml: `private.sl_insight_apiToken`)
 
 The SymfonyInsight API requires authentication. To obtain a token,
 Create an account, sign in and obtain a uuid and token from your
 [account page](https://insight.sensiolabs.com/account).
 
-## SonarQube
+### SonarQube
 
-- `SONARQUBE_TOKEN` (yml: `sonarqube_token`)
+- `SONAR_ORIGINS` (yml: `public.services.sonar.authorizedOrigins`)
+- `SONARQUBE_TOKEN` (yml: `private.sonarqube_token`)
 
 [Generate a token](https://docs.sonarqube.org/latest/user-guide/user-token/)
 to give your self-hosted Shields installation access to a
 private SonarQube instance or private project on a public instance.
 
-## Twitch
+### TeamCity
+
+- `TEAMCITY_ORIGINS` (yml: `public.services.teamcity.authorizedOrigins`)
+- `TEAMCITY_USER` (yml: `private.teamcity_user`)
+- `TEAMCITY_PASS` (yml: `private.teamcity_pass`)
+
+Provide a username and password to give your self-hosted Shields installation
+access to your private nexus repositories.
+
+### Twitch
 
 - `TWITCH_CLIENT_ID` (yml: `twitch_client_id`)
 - `TWITCH_CLIENT_SECRET` (yml: `twitch_client_secret`)
@@ -149,12 +218,23 @@ private SonarQube instance or private project on a public instance.
 Register an application in the [Twitch developer console](https://dev.twitch.tv/console)
 in order to obtain a client id and a client secret for making Twitch API calls.
 
-## Wheelmap
+### Wheelmap
 
-- `WHEELMAP_TOKEN` (yml: `wheelmap_token`)
+- `WHEELMAP_TOKEN` (yml: `private.wheelmap_token`)
 
 The wheelmap API requires authentication. To obtain a token,
 Create an account, [sign in][wheelmap token] and use the _Authentication Token_
 displayed on your profile page.
 
 [wheelmap token]: http://classic.wheelmap.org/en/users/sign_in
+
+## Error reporting
+
+- `SENTRY_DSN` (yml: `private.sentry_dsn`)
+
+A [Sentry DSN][] may be used to send error reports from your installation to
+[Sentry.io][]. For more info, see the [self hosting docs][].
+
+[sentry dsn]: https://docs.sentry.io/error-reporting/quickstart/?platform=javascript#configure-the-dsn
+[sentry.io]: http://sentry.io/
+[self hosting docs]: https://github.com/badges/shields/blob/master/doc/self-hosting.md#sentry

doc/service-tests.md

@@ -148,7 +148,7 @@ Once we have multiple tests, sometimes it is useful to run only one test. We can
 npm run test:services -- --only="wercker" --fgrep="Build status (with branch)"
 ```
 
-Having covered the typical and custom cases, we'll move on to errors. We should include a test for the 'not found' response and also tests for any other cusom error handling. The Wercker integration defines a custom error condition for 401 as well as a custom 404 message:
+Having covered the typical and custom cases, we'll move on to errors. We should include a test for the 'not found' response and also tests for any other custom error handling. The Wercker integration defines a custom error condition for 401 as well as a custom 404 message:
 
 ```js
 errorMessages: {

frontend/components/badge-examples.tsx

@@ -42,8 +42,8 @@ function Example({
   onClick: (example: RenderableExample, isSuggestion: boolean) => void
   exampleData: RenderableExample
   isBadgeSuggestion: boolean
-}) {
-  function handleClick() {
+}): JSX.Element {
+  function handleClick(): void {
     onClick(exampleData, isBadgeSuggestion)
   }
 
@@ -106,7 +106,7 @@ export function BadgeExamples({
   areBadgeSuggestions: boolean
   baseUrl?: string
   onClick: (exampleData: RenderableExample, isSuggestion: boolean) => void
-}) {
+}): JSX.Element {
   return (
     <ExampleTable>
       <tbody>

frontend/components/category-headings.tsx

@@ -12,7 +12,7 @@ export function CategoryHeading({
   category: { id, name },
 }: {
   category: Category
-}) {
+}): JSX.Element {
   return (
     <Link to={`/category/${id}`}>
       <H3 id={id}>{name}</H3>
@@ -20,7 +20,11 @@ export function CategoryHeading({
   )
 }
 
-export function CategoryHeadings({ categories }: { categories: Category[] }) {
+export function CategoryHeadings({
+  categories,
+}: {
+  categories: Category[]
+}): JSX.Element {
   return (
     <div>
       {categories.map(category => (
@@ -61,7 +65,11 @@ const StyledNav = styled.nav`
   }
 `
 
-export function CategoryNav({ categories }: { categories: Category[] }) {
+export function CategoryNav({
+  categories,
+}: {
+  categories: Category[]
+}): JSX.Element {
   return (
     <StyledNav>
       <ul>

frontend/components/common.tsx

@@ -74,7 +74,7 @@ export function Badge({
   height = '20px',
   clickable = false,
   ...rest
-}: BadgeProps) {
+}: BadgeProps): JSX.Element {
   return (
     <BadgeWrapper clickable={clickable} display={display} height={height}>
       {src ? <img alt={alt} src={src} {...rest} /> : nonBreakingSpace}

frontend/components/customizer/builder-common.tsx

@@ -20,7 +20,7 @@ export function BuilderContainer({
   children,
 }: {
   children: JSX.Element[] | JSX.Element
-}) {
+}): JSX.Element {
   return (
     <BuilderOuterContainer>
       <BuilderInnerContainer>{children}</BuilderInnerContainer>

frontend/components/customizer/copied-content-indicator.tsx

@@ -41,7 +41,7 @@ function _CopiedContentIndicator(
     children: JSX.Element | JSX.Element[]
   },
   ref: React.Ref<CopiedContentIndicatorHandle>
-) {
+): JSX.Element {
   const [pose, setPose] = useState('hidden')
 
   useImperativeHandle(ref, () => ({
@@ -50,7 +50,7 @@ function _CopiedContentIndicator(
     },
   }))
 
-  function handlePoseComplete() {
+  function handlePoseComplete(): void {
     if (pose === 'effectStart') {
       setPose('effectEnd')
     } else {

frontend/components/customizer/customizer.tsx

@@ -36,24 +36,24 @@ export default function Customizer({
   initialStyle?: string
   isPrefilled: boolean
   link?: string
-}) {
+}): JSX.Element {
   // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/35572
   // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/28884#issuecomment-471341041
   const indicatorRef = useRef<
     CopiedContentIndicatorHandle
   >() as React.MutableRefObject<CopiedContentIndicatorHandle>
   const [path, setPath] = useState('')
-  const [queryString, setQueryString] = useState()
-  const [pathIsComplete, setPathIsComplete] = useState()
-  const [markup, setMarkup] = useState()
-  const [message, setMessage] = useState()
+  const [queryString, setQueryString] = useState<string>()
+  const [pathIsComplete, setPathIsComplete] = useState<boolean>()
+  const [markup, setMarkup] = useState<string>()
+  const [message, setMessage] = useState<string>()
 
-  function generateBuiltBadgeUrl() {
+  function generateBuiltBadgeUrl(): string {
     const suffix = queryString ? `?${queryString}` : ''
     return `${baseUrl || getBaseUrlFromWindowLocation()}${path}${suffix}`
   }
 
-  function renderLivePreview() {
+  function renderLivePreview(): JSX.Element {
     // There are some usability issues here. It would be better if the message
     // changed from a validation error to a loading message once the
     // parameters were filled in, and also switched back to loading when the
@@ -75,7 +75,7 @@ export default function Customizer({
     )
   }
 
-  async function copyMarkup(markupFormat: MarkupFormat) {
+  async function copyMarkup(markupFormat: MarkupFormat): Promise<void> {
     const builtBadgeUrl = generateBuiltBadgeUrl()
     const markup = generateMarkup({
       badgeUrl: builtBadgeUrl,
@@ -98,7 +98,7 @@ export default function Customizer({
     }
   }
 
-  function renderMarkupAndLivePreview() {
+  function renderMarkupAndLivePreview(): JSX.Element {
     return (
       <div>
         {renderLivePreview()}
@@ -124,7 +124,7 @@ export default function Customizer({
   }: {
     path: string
     isComplete: boolean
-  }) {
+  }): void {
     setPath(path)
     setPathIsComplete(isComplete)
   }
@@ -135,7 +135,7 @@ export default function Customizer({
   }: {
     queryString: string
     isComplete: boolean
-  }) {
+  }): void {
     setQueryString(queryString)
   }
 

frontend/components/customizer/path-builder.tsx

@@ -1,6 +1,6 @@
 import React, { useState, useEffect, ChangeEvent } from 'react'
 import styled, { css } from 'styled-components'
-import pathToRegexp, { Token, Key } from 'path-to-regexp'
+import { Token, Key, parse } from 'path-to-regexp'
 import humanizeString from 'humanize-string'
 import { patternToOptions } from '../../lib/pattern-helpers'
 import { noAutocorrect, StyledInput } from '../common'
@@ -11,11 +11,13 @@ import {
 } from './builder-common'
 
 interface PathBuilderColumnProps {
+  pathContainsOnlyLiterals: boolean
   withHorizPadding?: boolean
 }
 
 const PathBuilderColumn = styled.span<PathBuilderColumnProps>`
-  height: 78px;
+  height: ${({ pathContainsOnlyLiterals }) =>
+    pathContainsOnlyLiterals ? '18px' : '78px'};
 
   float: left;
   display: flex;
@@ -32,10 +34,12 @@ const PathBuilderColumn = styled.span<PathBuilderColumnProps>`
 
 interface PathLiteralProps {
   isFirstToken: boolean
+  pathContainsOnlyLiterals: boolean
 }
 
 const PathLiteral = styled.div<PathLiteralProps>`
-  margin-top: 39px;
+  margin-top: ${({ pathContainsOnlyLiterals }) =>
+    pathContainsOnlyLiterals ? '0px' : '39px'};
   ${({ isFirstToken }) =>
     isFirstToken &&
     css`
@@ -80,17 +84,17 @@ export function constructPath({
 }: {
   tokens: Token[]
   namedParams: { [k: string]: string }
-}) {
+}): { path: string; isComplete: boolean } {
   let isComplete = true
   const path = tokens
     .map(token => {
       if (typeof token === 'string') {
-        return token
+        return token.trim()
       } else {
         const { delimiter, name, optional } = token
         const value = namedParams[name]
         if (value) {
-          return `${delimiter}${value}`
+          return `${delimiter}${value.trim()}`
         } else if (optional) {
           return ''
         } else {
@@ -119,8 +123,8 @@ export default function PathBuilder({
     isComplete: boolean
   }) => void
   isPrefilled: boolean
-}) {
-  const [tokens] = useState(() => pathToRegexp.parse(pattern))
+}): JSX.Element {
+  const [tokens] = useState(() => parse(pattern))
   const [namedParams, setNamedParams] = useState(() =>
     isPrefilled
       ? exampleParams
@@ -130,13 +134,10 @@ export default function PathBuilder({
         tokens
           .filter(t => typeof t !== 'string')
           .map(t => t as Key)
-          .reduce(
-            (accum, { name }) => {
-              accum[name] = ''
-              return accum
-            },
-            {} as { [k: string]: string }
-          )
+          .reduce((accum, { name }) => {
+            accum[name] = ''
+            return accum
+          }, {} as { [k: string]: string })
   )
 
   useEffect(() => {
@@ -149,22 +150,34 @@ export default function PathBuilder({
 
   function handleTokenChange({
     target: { name, value },
-  }: ChangeEvent<HTMLInputElement | HTMLSelectElement>) {
+  }: ChangeEvent<HTMLInputElement | HTMLSelectElement>): void {
     setNamedParams({
       ...namedParams,
       [name]: value,
     })
   }
 
-  function renderLiteral(literal: string, tokenIndex: number) {
+  function renderLiteral(
+    literal: string,
+    tokenIndex: number,
+    pathContainsOnlyLiterals: boolean
+  ): JSX.Element {
     return (
-      <PathBuilderColumn key={`${tokenIndex}-${literal}`}>
-        <PathLiteral isFirstToken={tokenIndex === 0}>{literal}</PathLiteral>
+      <PathBuilderColumn
+        key={`${tokenIndex}-${literal}`}
+        pathContainsOnlyLiterals={pathContainsOnlyLiterals}
+      >
+        <PathLiteral
+          isFirstToken={tokenIndex === 0}
+          pathContainsOnlyLiterals={pathContainsOnlyLiterals}
+        >
+          {literal}
+        </PathLiteral>
       </PathBuilderColumn>
     )
   }
 
-  function renderNamedParamInput(token: Key) {
+  function renderNamedParamInput(token: Key): JSX.Element {
     const { pattern } = token
     const name = `${token.name}`
     const options = patternToOptions(pattern)
@@ -206,7 +219,7 @@ export default function PathBuilder({
     token: Key,
     tokenIndex: number,
     namedParamIndex: number
-  ) {
+  ): JSX.Element {
     const { delimiter, optional } = token
     const name = `${token.name}`
 
@@ -214,8 +227,8 @@ export default function PathBuilder({
 
     return (
       <React.Fragment key={token.name}>
-        {renderLiteral(delimiter, tokenIndex)}
-        <PathBuilderColumn withHorizPadding>
+        {renderLiteral(delimiter, tokenIndex, false)}
+        <PathBuilderColumn pathContainsOnlyLiterals={false} withHorizPadding>
           <NamedParamLabelContainer>
             <BuilderLabel htmlFor={name}>{humanizeString(name)}</BuilderLabel>
             {optional ? <BuilderLabel>(optional)</BuilderLabel> : null}
@@ -232,11 +245,14 @@ export default function PathBuilder({
   }
 
   let namedParamIndex = 0
+  const pathContainsOnlyLiterals = tokens.every(
+    token => typeof token === 'string'
+  )
   return (
     <BuilderContainer>
       {tokens.map((token, tokenIndex) =>
         typeof token === 'string'
-          ? renderLiteral(token, tokenIndex)
+          ? renderLiteral(token, tokenIndex, pathContainsOnlyLiterals)
           : renderNamedParam(token, tokenIndex, namedParamIndex++)
       )}
     </BuilderContainer>

frontend/components/customizer/query-string-builder.tsx

@@ -72,7 +72,7 @@ function getQueryString({
     // booleans.
     if (typeof value === 'string') {
       if (value) {
-        outQuery[name] = value
+        outQuery[name] = value.trim()
       } else {
         // Skip empty params.
         isComplete = false
@@ -113,7 +113,7 @@ function ServiceQueryParam({
   isStringParam: boolean
   stringParamCount?: number
   handleServiceQueryParamChange: ChangeEventHandler<HTMLInputElement>
-}) {
+}): JSX.Element {
   return (
     <tr>
       <td>
@@ -160,7 +160,7 @@ function BadgeOptionInput({
   handleBadgeOptionChange: ChangeEventHandler<
     HTMLSelectElement | HTMLInputElement
   >
-}) {
+}): JSX.Element {
   if (name === 'style') {
     return (
       <select name="style" onChange={handleBadgeOptionChange} value={value}>
@@ -192,7 +192,7 @@ function BadgeOption({
   name: BadgeOptionName
   value: string
   handleBadgeOptionChange: ChangeEventHandler<HTMLInputElement>
-}) {
+}): JSX.Element {
   const {
     label = humanizeString(name),
     shieldsDefaultValue: hasShieldsDefaultValue,
@@ -237,49 +237,43 @@ export default function QueryStringBuilder({
     queryString: string
     isComplete: boolean
   }) => void
-}) {
+}): JSX.Element {
   const [queryParams, setQueryParams] = useState(() =>
     // For each of the custom query params defined in `exampleParams`,
     // create empty values in `queryParams`.
-    Object.entries(exampleParams).reduce(
-      (accum, [name, value]) => {
-        // Custom query params are either string or boolean. Inspect the example
-        // value to infer which one, and set empty values accordingly.
-        // Throughout the component, these two types are supported in the same
-        // manner: by inspecting this value type.
-        const isStringParam = typeof value === 'string'
-        accum[name] = isStringParam ? '' : true
-        return accum
-      },
-      {} as { [k: string]: string | boolean }
-    )
+    Object.entries(exampleParams).reduce((accum, [name, value]) => {
+      // Custom query params are either string or boolean. Inspect the example
+      // value to infer which one, and set empty values accordingly.
+      // Throughout the component, these two types are supported in the same
+      // manner: by inspecting this value type.
+      const isStringParam = typeof value === 'string'
+      accum[name] = isStringParam ? '' : true
+      return accum
+    }, {} as { [k: string]: string | boolean })
   )
   // For each of the standard badge options, create empty values in
   // `badgeOptions`. When `initialStyle` has been provided, use it.
   const [badgeOptions, setBadgeOptions] = useState(() =>
-    supportedBadgeOptions.reduce(
-      (accum, { name }) => {
-        if (name === 'style') {
-          accum[name] = initialStyle
-        } else {
-          accum[name] = ''
-        }
-        return accum
-      },
-      {} as Record<BadgeOptionName, string>
-    )
+    supportedBadgeOptions.reduce((accum, { name }) => {
+      if (name === 'style') {
+        accum[name] = initialStyle
+      } else {
+        accum[name] = ''
+      }
+      return accum
+    }, {} as Record<BadgeOptionName, string>)
   )
 
   function handleServiceQueryParamChange({
     target: { name, type: targetType, checked, value },
-  }: ChangeEvent<HTMLInputElement>) {
+  }: ChangeEvent<HTMLInputElement>): void {
     const outValue = targetType === 'checkbox' ? checked : value
     setQueryParams({ ...queryParams, [name]: outValue })
   }
 
   function handleBadgeOptionChange({
     target: { name, value },
-  }: ChangeEvent<HTMLInputElement>) {
+  }: ChangeEvent<HTMLInputElement>): void {
     setBadgeOptions({ ...badgeOptions, [name]: value })
   }
 

frontend/components/customizer/request-markup-button.tsx

@@ -3,14 +3,17 @@ import styled from 'styled-components'
 import Select, { components } from 'react-select'
 import { MarkupFormat } from '../../lib/generate-image-markup'
 
-const ClickableControl = (props: any) => (
-  <components.Control
-    {...props}
-    innerProps={{
-      onMouseDown: props.selectProps.onControlMouseDown,
-    }}
-  />
-)
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function ClickableControl(props: any): JSX.Element {
+  return (
+    <components.Control
+      {...props}
+      innerProps={{
+        onMouseDown: props.selectProps.onControlMouseDown,
+      }}
+    />
+  )
+}
 
 interface Option {
   value: MarkupFormat
@@ -76,14 +79,14 @@ export default function GetMarkupButton({
 }: {
   onMarkupRequested: (markupFormat: MarkupFormat) => Promise<void>
   isDisabled: boolean
-}) {
+}): JSX.Element {
   // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/35572
   // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/28884#issuecomment-471341041
   const selectRef = useRef<Select<Option>>() as React.MutableRefObject<
     Select<Option>
   >
 
-  async function onControlMouseDown(event: MouseEvent) {
+  async function onControlMouseDown(event: MouseEvent): Promise<void> {
     if (onMarkupRequested) {
       await onMarkupRequested('link')
     }

frontend/components/development/logo-page.tsx

@@ -18,7 +18,7 @@ const StyledTable = styled.table`
   }
 `
 
-function NamedLogoTable({ logoNames }: { logoNames: string[] }) {
+function NamedLogoTable({ logoNames }: { logoNames: string[] }): JSX.Element {
   return (
     <StyledTable>
       <thead>
@@ -62,7 +62,7 @@ function NamedLogoTable({ logoNames }: { logoNames: string[] }) {
   )
 }
 
-export default function LogoPage() {
+export default function LogoPage(): JSX.Element {
   return (
     <div>
       <Meta />

frontend/components/donate.tsx

@@ -5,7 +5,7 @@ const Donate = styled.div`
   padding: 25px 50px;
 `
 
-export default function DonateBox() {
+export default function DonateBox(): JSX.Element {
   return (
     <Donate>
       Love Shields? Please consider{' '}

frontend/components/dynamic-badge-maker.tsx

@@ -28,7 +28,7 @@ const inputs = [
 
 export default function DynamicBadgeMaker({
   baseUrl = document.location.href,
-}) {
+}): JSX.Element {
   const [values, setValues] = useState<State>({
     datatype: '',
     label: '',
@@ -44,14 +44,14 @@ export default function DynamicBadgeMaker({
 
   function onChange({
     target: { name, value },
-  }: ChangeEvent<HTMLInputElement | HTMLSelectElement>) {
+  }: ChangeEvent<HTMLInputElement | HTMLSelectElement>): void {
     setValues({
       ...values,
       [name]: value,
     })
   }
 
-  function onSubmit(e: React.FormEvent) {
+  function onSubmit(e: React.FormEvent): void {
     e.preventDefault()
 
     const { datatype, label, dataUrl, query, color, prefix, suffix } = values

frontend/components/footer.tsx

@@ -8,7 +8,7 @@ const SpacedA = styled.a`
   margin-right: 10px;
 `
 
-export default function Footer({ baseUrl }: { baseUrl: string }) {
+export default function Footer({ baseUrl }: { baseUrl: string }): JSX.Element {
   return (
     <section>
       <H2 id="like-this">Like This?</H2>

frontend/components/header.tsx

@@ -8,7 +8,7 @@ const Highlights = styled.p`
   font-style: italic;
 `
 
-export default function Header() {
+export default function Header(): JSX.Element {
   return (
     <section>
       <Link to="/">

frontend/components/main.tsx

@@ -38,7 +38,11 @@ interface PageContext {
   category?: Category
 }
 
-export default function Main({ pageContext }: { pageContext: PageContext }) {
+export default function Main({
+  pageContext,
+}: {
+  pageContext: PageContext
+}): JSX.Element {
   const [searchIsInProgress, setSearchIsInProgress] = useState(false)
   const [queryIsTooShort, setQueryIsTooShort] = useState(false)
   const [searchResults, setSearchResults] = useState<{
@@ -51,7 +55,7 @@ export default function Main({ pageContext }: { pageContext: PageContext }) {
   ] = useState(false)
   const searchTimeout = useRef(0)
 
-  function performSearch(query: string) {
+  function performSearch(query: string): void {
     setSearchIsInProgress(false)
 
     setQueryIsTooShort(query.length === 1)
@@ -67,7 +71,7 @@ export default function Main({ pageContext }: { pageContext: PageContext }) {
     }
   }
 
-  function searchQueryChanged(query: string) {
+  function searchQueryChanged(query: string): void {
     /*
     Add a small delay before showing search results
     so that we wait until the user has stopped typing
@@ -83,12 +87,15 @@ export default function Main({ pageContext }: { pageContext: PageContext }) {
     searchTimeout.current = window.setTimeout(() => performSearch(query), 500)
   }
 
-  function exampleClicked(example: RenderableExample, isSuggestion: boolean) {
+  function exampleClicked(
+    example: RenderableExample,
+    isSuggestion: boolean
+  ): void {
     setSelectedExample(example)
     setSelectedExampleIsSuggestion(isSuggestion)
   }
 
-  function dismissMarkupModal() {
+  function dismissMarkupModal(): void {
     setSelectedExample(undefined)
   }
 
@@ -98,14 +105,11 @@ export default function Main({ pageContext }: { pageContext: PageContext }) {
   }: {
     category: Category
     definitions: ServiceDefinition[]
-  }) {
-    const flattened = definitions.reduce(
-      (accum, current) => {
-        const { examples } = current
-        return accum.concat(examples)
-      },
-      [] as Example[]
-    )
+  }): JSX.Element {
+    const flattened = definitions.reduce((accum, current) => {
+      const { examples } = current
+      return accum.concat(examples)
+    }, [] as Example[])
 
     return (
       <div>
@@ -120,7 +124,7 @@ export default function Main({ pageContext }: { pageContext: PageContext }) {
     )
   }
 
-  function renderMain() {
+  function renderMain(): JSX.Element | JSX.Element[] {
     const { category } = pageContext
 
     if (searchIsInProgress) {

frontend/components/markup-modal/index.tsx

@@ -19,7 +19,7 @@ export function MarkupModal({
   isBadgeSuggestion: boolean
   baseUrl: string
   onRequestClose: () => void
-}) {
+}): JSX.Element {
   return (
     <Modal
       ariaHideApp={false}

frontend/components/markup-modal/markup-modal-content.tsx

@@ -22,7 +22,7 @@ export function MarkupModalContent({
   example: RenderableExample
   isBadgeSuggestion: boolean
   baseUrl: string
-}) {
+}): JSX.Element {
   let documentation: { __html: string } | undefined
   let link: string | undefined
   if (isBadgeSuggestion) {

frontend/components/meta.tsx

@@ -7,7 +7,7 @@ const description = `We serve fast and scalable informational images as badges
 for GitHub, Travis CI, Jenkins, WordPress and many more services. Use them to
 track the state of your projects, or for promotional purposes.`
 
-export default function Meta() {
+export default function Meta(): JSX.Element {
   return (
     <Helmet>
       <title>

frontend/components/snippet.tsx

@@ -50,7 +50,7 @@ export function Snippet({
   snippet: string
   truncate?: boolean
   fontSize?: string
-}) {
+}): JSX.Element {
   return (
     <CodeContainer truncate={truncate}>
       <ClickToSelect>

frontend/components/static-badge-maker.tsx

@@ -5,7 +5,9 @@ import { InlineInput } from './common'
 type StateKey = 'label' | 'message' | 'color'
 type State = Record<StateKey, string>
 
-export default function StaticBadgeMaker({ baseUrl = document.location.href }) {
+export default function StaticBadgeMaker({
+  baseUrl = document.location.href,
+}): JSX.Element {
   const [values, setValues] = useState<State>({
     label: '',
     message: '',
@@ -16,14 +18,14 @@ export default function StaticBadgeMaker({ baseUrl = document.location.href }) {
 
   function onChange({
     target: { name, value },
-  }: ChangeEvent<HTMLInputElement | HTMLSelectElement>) {
+  }: ChangeEvent<HTMLInputElement | HTMLSelectElement>): void {
     setValues({
       ...values,
       [name]: value,
     })
   }
 
-  function onSubmit(e: React.FormEvent) {
+  function onSubmit(e: React.FormEvent): void {
     e.preventDefault()
 
     const { label, message, color } = values

frontend/components/suggestion-and-search.tsx

@@ -32,7 +32,7 @@ export default function SuggestionAndSearch({
   queryChanged: (query: string) => void
   onBadgeClick: (example: RenderableExample, isSuggestion: boolean) => void
   baseUrl: string
-}) {
+}): JSX.Element {
   const queryChangedDebounced = useRef(
     debounce(queryChanged, 50, { leading: true })
   )
@@ -43,7 +43,7 @@ export default function SuggestionAndSearch({
 
   function onQueryChanged({
     target: { value: query },
-  }: ChangeEvent<HTMLInputElement>) {
+  }: ChangeEvent<HTMLInputElement>): void {
     const isUrl = query.startsWith('https://') || query.startsWith('http://')
     setIsUrl(isUrl)
     setProjectUrl(isUrl ? query : undefined)
@@ -51,7 +51,7 @@ export default function SuggestionAndSearch({
     queryChangedDebounced.current(query)
   }
 
-  async function getSuggestions() {
+  async function getSuggestions(): Promise<void> {
     if (!projectUrl) {
       setSuggestions([])
       return
@@ -77,7 +77,7 @@ export default function SuggestionAndSearch({
     setSuggestions(suggestions)
   }
 
-  function renderSuggestions() {
+  function renderSuggestions(): JSX.Element | null {
     if (suggestions.length === 0) {
       return null
     }

frontend/components/usage.tsx

@@ -44,7 +44,7 @@ function QueryParam({
 }: {
   snippet: string
   documentation: JSX.Element | JSX.Element[]
-}) {
+}): JSX.Element {
   return (
     <tr>
       <QueryParamSyntax>
@@ -61,7 +61,7 @@ function EscapingConversion({
 }: {
   lhs: JSX.Element
   rhs: JSX.Element
-}) {
+}): JSX.Element {
   return (
     <tr>
       <Lhs>{lhs}</Lhs>
@@ -77,7 +77,7 @@ function ColorExamples({
 }: {
   baseUrl: string
   colors: string[]
-}) {
+}): JSX.Element {
   return (
     <span>
       {colors.map((color, i) => (
@@ -91,7 +91,7 @@ function ColorExamples({
   )
 }
 
-function StyleExamples({ baseUrl }: { baseUrl: string }) {
+function StyleExamples({ baseUrl }: { baseUrl: string }): JSX.Element {
   return (
     <QueryParamTable>
       <tbody>
@@ -118,7 +118,7 @@ function StyleExamples({ baseUrl }: { baseUrl: string }) {
   )
 }
 
-function NamedLogos() {
+function NamedLogos(): JSX.Element {
   const renderLogo = (logo: string): JSX.Element => (
     <LogoName key={logo}>{logo}</LogoName>
   )
@@ -132,7 +132,7 @@ function NamedLogos() {
   return <>{result}</>
 }
 
-function StaticBadgeEscapingRules() {
+function StaticBadgeEscapingRules(): JSX.Element {
   return (
     <EscapingRuleTable>
       <tbody>
@@ -180,7 +180,7 @@ function StaticBadgeEscapingRules() {
   )
 }
 
-export default function Usage({ baseUrl }: { baseUrl: string }) {
+export default function Usage({ baseUrl }: { baseUrl: string }): JSX.Element {
   return (
     <section>
       <H2 id="your-badge">Your Badge</H2>
@@ -353,7 +353,8 @@ export default function Usage({ baseUrl }: { baseUrl: string }) {
             documentation={
               <span>
                 Set the color of the logo (hex, rgb, rgba, hsl, hsla and css
-                named colors supported)
+                named colors supported). Supported for named logos but not for
+                custom logos.
               </span>
             }
             key="logoColor"

frontend/lib/generate-image-markup.ts

@@ -1,8 +1,8 @@
-export function bareLink(badgeUrl: string, link?: string, title = '') {
+export function bareLink(badgeUrl: string, link?: string, title = ''): string {
   return badgeUrl
 }
 
-export function html(badgeUrl: string, link?: string, title?: string) {
+export function html(badgeUrl: string, link?: string, title?: string): string {
   // To be more robust, this should escape the title.
   const alt = title ? ` alt="${title}"` : ''
   const img = `<img${alt} src="${badgeUrl}">`
@@ -13,7 +13,11 @@ export function html(badgeUrl: string, link?: string, title?: string) {
   }
 }
 
-export function markdown(badgeUrl: string, link?: string, title?: string) {
+export function markdown(
+  badgeUrl: string,
+  link?: string,
+  title?: string
+): string {
   const withoutLink = `![${title || ''}](${badgeUrl})`
   if (link) {
     return `[${withoutLink}](${link})`
@@ -26,7 +30,7 @@ export function reStructuredText(
   badgeUrl: string,
   link?: string,
   title?: string
-) {
+): string {
   let result = `.. image:: ${badgeUrl}`
   if (title) {
     result += `   :alt: ${title}`
@@ -37,7 +41,7 @@ export function reStructuredText(
   return result
 }
 
-function quoteAsciiDocAttribute(attr: string | null) {
+function quoteAsciiDocAttribute(attr: string | null): string {
   if (attr == null) {
     return 'None'
   } else {
@@ -61,7 +65,7 @@ function mapValues(
 export function renderAsciiDocAttributes(
   positional: string[],
   named: { [k: string]: string | null }
-) {
+): string {
   // http://asciidoc.org/userguide.html#X21
   const needsQuoting =
     positional.some(attr => attr && attr.includes(',')) ||
@@ -83,7 +87,11 @@ export function renderAsciiDocAttributes(
   }
 }
 
-export function asciiDoc(badgeUrl: string, link?: string, title?: string) {
+export function asciiDoc(
+  badgeUrl: string,
+  link?: string,
+  title?: string
+): string {
   const positional = title ? [title] : []
   const named = link ? { link } : ({} as { [k: string]: string })
   const attrs = renderAsciiDocAttributes(positional, named)
@@ -102,7 +110,7 @@ export function generateMarkup({
   link?: string
   title?: string
   markupFormat: MarkupFormat
-}) {
+}): string {
   const generatorFn = {
     markdown,
     rst: reStructuredText,

frontend/lib/pattern-helpers.ts

@@ -1,4 +1,4 @@
-import pathToRegexp from 'path-to-regexp'
+import { parse } from 'path-to-regexp'
 
 // Given a patternToRegex `pattern` with multiple-choice options like
 // `foo|bar|baz`, return an array with the options. If it can't be described
@@ -15,7 +15,7 @@ export function patternToOptions(pattern: string): string[] | undefined {
 
 // Removes regexp for named parameters.
 export function removeRegexpFromPattern(pattern: string): string {
-  const tokens = pathToRegexp.parse(pattern)
+  const tokens = parse(pattern)
   const simplePattern = tokens
     .map(token => {
       if (typeof token === 'string') {

frontend/lib/redirect-legacy-routes.ts

@@ -1,6 +1,6 @@
 import { navigate } from 'gatsby'
 
-export default function redirectLegacyRoutes() {
+export default function redirectLegacyRoutes(): void {
   const { hash } = window.location
   if (hash && hash.startsWith('#/examples/')) {
     const category = hash.replace('#/examples/', '')

frontend/lib/service-definitions/index.spec.ts

@@ -11,6 +11,6 @@ describe('Service definition helpers', function() {
   it('getDefinitionsForCategory', function() {
     expect(getDefinitionsForCategory('build'))
       .to.have.length.greaterThan(10)
-      .and.lessThan(50)
+      .and.lessThan(75)
   })
 })

frontend/lib/service-definitions/index.ts

@@ -53,13 +53,15 @@ export interface ServiceDefinition {
 export const services = definitions.services as ServiceDefinition[]
 export const categories = definitions.categories as Category[]
 
-export function findCategory(category: string) {
+export function findCategory(category: string): Category | undefined {
   return categories.find(({ id }) => id === category)
 }
 
 const byCategory = groupBy(services, 'category')
-export function getDefinitionsForCategory(category: string) {
-  return byCategory[category]
+export function getDefinitionsForCategory(
+  category: string
+): ServiceDefinition[] {
+  return byCategory[category] || []
 }
 
 export interface Suggestion {

frontend/lib/service-definitions/service-definition-set-helper.spec.ts

@@ -3,10 +3,12 @@ import { predicateFromQuery } from './service-definition-set-helper'
 import { Example } from '.'
 
 describe('Badge example functions', function() {
-  const exampleMatchesQuery = (
+  function exampleMatchesQuery(
     { examples }: { examples: Example[] },
     query: string
-  ) => predicateFromQuery(query)({ examples })
+  ): boolean {
+    return predicateFromQuery(query)({ examples })
+  }
 
   test(exampleMatchesQuery, () => {
     forCases([given({ examples: [{ title: 'node version' }] }, 'npm')]).expect(

frontend/lib/service-definitions/service-definition-set-helper.ts

@@ -1,13 +1,15 @@
 import escapeStringRegexp from 'escape-string-regexp'
 import { Example, ServiceDefinition } from '.'
 
-export function exampleMatchesRegex(example: Example, regex: RegExp) {
+export function exampleMatchesRegex(example: Example, regex: RegExp): boolean {
   const { title, keywords } = example
   const haystack = [title].concat(keywords).join(' ')
   return regex.test(haystack)
 }
 
-export function predicateFromQuery(query: string) {
+export function predicateFromQuery(
+  query: string
+): ({ examples }: { examples: Example[] }) => boolean {
   const escaped = escapeStringRegexp(query)
   const regex = new RegExp(escaped, 'i') // Case-insensitive.
   return ({ examples }: { examples: Example[] }) =>
@@ -21,30 +23,32 @@ export default class ServiceDefinitionSetHelper {
     this.definitionData = definitionData
   }
 
-  public static create(definitionData: ServiceDefinition[]) {
+  public static create(
+    definitionData: ServiceDefinition[]
+  ): ServiceDefinitionSetHelper {
     return new ServiceDefinitionSetHelper(definitionData)
   }
 
-  public getCategory(wantedCategory: string) {
+  public getCategory(wantedCategory: string): ServiceDefinitionSetHelper {
     return ServiceDefinitionSetHelper.create(
       this.definitionData.filter(({ category }) => category === wantedCategory)
     )
   }
 
-  public search(query: string) {
+  public search(query: string): ServiceDefinitionSetHelper {
     const predicate = predicateFromQuery(query)
     return ServiceDefinitionSetHelper.create(
       this.definitionData.filter(predicate)
     )
   }
 
-  public notDeprecated() {
+  public notDeprecated(): ServiceDefinitionSetHelper {
     return ServiceDefinitionSetHelper.create(
       this.definitionData.filter(({ isDeprecated }) => !isDeprecated)
     )
   }
 
-  public toArray() {
+  public toArray(): ServiceDefinition[] {
     return this.definitionData
   }
 }

frontend/pages/endpoint.tsx

@@ -1,5 +1,4 @@
 import React from 'react'
-import PropTypes from 'prop-types'
 import styled, { css } from 'styled-components'
 import { staticBadgeUrl } from '../../core/badge-urls/make-badge-url'
 import { baseUrl } from '../constants'
@@ -44,11 +43,11 @@ const JsonExampleBlock = styled.code<JsonExampleBlockProps>`
   white-space: pre;
 `
 
-const JsonExample = ({ data }: { [k: string]: any }) => (
-  <JsonExampleBlock>{JSON.stringify(data, undefined, 2)}</JsonExampleBlock>
-)
-JsonExample.propTypes = {
-  data: PropTypes.object.isRequired,
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function JsonExample({ data }: { [k: string]: any }): JSX.Element {
+  return (
+    <JsonExampleBlock>{JSON.stringify(data, undefined, 2)}</JsonExampleBlock>
+  )
 }
 
 const Schema = styled.dl`
@@ -89,161 +88,166 @@ const Schema = styled.dl`
   }
 `
 
-const EndpointPage = () => (
-  <MainContainer>
-    <GlobalStyle />
-    <Meta />
-    <Header />
-    <H3>Endpoint</H3>
-    <Snippet snippet={`${baseUrl}/endpoint?url=...&style=...`} />
-    <p>Endpoint response:</p>
-    <JsonExample
-      data={{
-        schemaVersion: 1,
-        label: 'hello',
-        message: 'sweet world',
-        color: 'orange',
-      }}
-    />
-    <p>Shields response:</p>
-    <Badge
-      alt="hello | sweet world"
-      src={staticBadgeUrl({
-        baseUrl,
-        label: 'hello',
-        message: 'sweet world',
-        color: 'orange',
-      })}
-    />
-    <Explanation>
-      <p>
-        Developers rely on Shields for visual consistency and powerful
-        customization options. As a service provider or data provider, you can
-        use the endpoint badge to provide content while giving users the full
-        power of Shields' badge customization.
-      </p>
-      <p>
-        Using the endpoint badge, you can provide content for a badge through a
-        JSON endpoint. The content can be prerendered, or generated on the fly.
-        To strike a balance between responsiveness and bandwidth utilization on
-        one hand, and freshness on the other, cache behavior is configurable,
-        subject to the Shields minimum. The endpoint URL is provided to Shields
-        through the query string. Shields fetches it and formats the badge.
-      </p>
-      <p>
-        The endpoint badge is a better alternative than redirecting to the
-        static badge enpoint or generating SVG on your server:
-      </p>
-      <ol>
-        <li>
-          <a href="https://en.wikipedia.org/wiki/Separation_of_content_and_presentation">
-            Content and presentation are separate.
-          </a>{' '}
-          The service provider authors the badge, and Shields takes input from
-          the user to format it. As a service provider you author the badge but
-          don't have to concern yourself with styling. You don't even have to
-          pass the formatting options through to Shields.
-        </li>
-        <li>
-          Badge formatting is always 100% up to date. There's no need to track
-          updates to the npm package, badge templates, or options.
-        </li>
-        <li>
-          A JSON response is easy to implement; easier than an HTTP redirect. It
-          is trivial in almost any framework, and is more compatible with
-          hosting environments such as{' '}
-          <a href="https://runkit.com/docs/endpoint">RunKit endpoints</a>.
-        </li>
-        <li>
-          As a service provider you can rely on the Shields CDN. There's no need
-          to study the HTTP headers. Adjusting cache behavior is as simple as
-          setting a property in the JSON response.
-        </li>
-      </ol>
-    </Explanation>
-    <h4>Schema</h4>
-    <Explanation>
-      <p>
-        Breaking changes to the schema will trigger an increment to the
-        `schemaVersion`.
-      </p>
-    </Explanation>
-    <Schema>
-      <dt>schemaVersion</dt>
-      <dd>
-        Required. Always the number <code>1</code>.
-      </dd>
-      <dt>label</dt>
-      <dd>
-        Required. The left text, or the empty string to omit the left side of
-        the badge. This can be overridden by the query string.
-      </dd>
-      <dt>message</dt>
-      <dd>Required. Can't be empty. The right text.</dd>
-      <dt>color</dt>
-      <dd>
-        Default: <code>lightgrey</code>. The right color. Supports the eight
-        named colors above, as well as hex, rgb, rgba, hsl, hsla and css named
-        colors. This can be overridden by the query string.
-      </dd>
-      <dt>labelColor</dt>
-      <dd>
-        Default: <code>grey</code>. The left color. This can be overridden by
-        the query string.
-      </dd>
-      <dt>isError</dt>
-      <dd>
-        Default: <code>false</code>. <code>true</code> to treat this as an error
-        badge. This prevents the user from overriding the color. In the future
-        it may affect cache behavior.
-      </dd>
-      <dt>namedLogo</dt>
-      <dd>
-        Default: none. One of the named logos supported by Shields or {}
-        <a href="https://simpleicons.org/">simple-icons</a>. Can be overridden
-        by the query string.
-      </dd>
-      <dt>logoSvg</dt>
-      <dd>Default: none. An SVG string containing a custom logo.</dd>
-      <dt>logoColor</dt>
-      <dd>
-        Default: none. Same meaning as the query string. Can be overridden by
-        the query string.
-      </dd>
-      <dt>logoWidth</dt>
-      <dd>
-        Default: none. Same meaning as the query string. Can be overridden by
-        the query string.
-      </dd>
-      <dt>logoPosition</dt>
-      <dd>
-        Default: none. Same meaning as the query string. Can be overridden by
-        the query string.
-      </dd>
-      <dt>style</dt>
-      <dd>
-        Default: <code>flat</code>. The default template to use. Can be
-        overridden by the query string.
-      </dd>
-      <dt>cacheSeconds</dt>
-      <dd>
-        Default: <code>300</code>, min <code>300</code>. Set the HTTP cache
-        lifetime in seconds, which should respected by the Shields' CDN and
-        downstream users. Values below 300 will be ignored. This lets you tune
-        performance and traffic vs. responsiveness. The value you specify can be
-        overridden by the user via the query string, but only to a longer value.
-      </dd>
-    </Schema>
-    <h4>Customize and test</h4>
-    <Customizer
-      baseUrl={baseUrl}
-      exampleNamedParams={{}}
-      exampleQueryParams={{ url: 'https://shields.redsparr0w.com/2473/monday' }}
-      isPrefilled={false}
-      pattern="/endpoint"
-      title="Custom badge"
-    />
-    <Footer baseUrl={baseUrl} />
-  </MainContainer>
-)
-export default EndpointPage
+export default function EndpointPage(): JSX.Element {
+  return (
+    <MainContainer>
+      <GlobalStyle />
+      <Meta />
+      <Header />
+      <H3>Endpoint</H3>
+      <Snippet snippet={`${baseUrl}/endpoint?url=...&style=...`} />
+      <p>Endpoint response:</p>
+      <JsonExample
+        data={{
+          schemaVersion: 1,
+          label: 'hello',
+          message: 'sweet world',
+          color: 'orange',
+        }}
+      />
+      <p>Shields response:</p>
+      <Badge
+        alt="hello | sweet world"
+        src={staticBadgeUrl({
+          baseUrl,
+          label: 'hello',
+          message: 'sweet world',
+          color: 'orange',
+        })}
+      />
+      <Explanation>
+        <p>
+          Developers rely on Shields for visual consistency and powerful
+          customization options. As a service provider or data provider, you can
+          use the endpoint badge to provide content while giving users the full
+          power of Shields' badge customization.
+        </p>
+        <p>
+          Using the endpoint badge, you can provide content for a badge through
+          a JSON endpoint. The content can be prerendered, or generated on the
+          fly. To strike a balance between responsiveness and bandwidth
+          utilization on one hand, and freshness on the other, cache behavior is
+          configurable, subject to the Shields minimum. The endpoint URL is
+          provided to Shields through the query string. Shields fetches it and
+          formats the badge.
+        </p>
+        <p>
+          The endpoint badge is a better alternative than redirecting to the
+          static badge enpoint or generating SVG on your server:
+        </p>
+        <ol>
+          <li>
+            <a href="https://en.wikipedia.org/wiki/Separation_of_content_and_presentation">
+              Content and presentation are separate.
+            </a>{' '}
+            The service provider authors the badge, and Shields takes input from
+            the user to format it. As a service provider you author the badge
+            but don't have to concern yourself with styling. You don't even have
+            to pass the formatting options through to Shields.
+          </li>
+          <li>
+            Badge formatting is always 100% up to date. There's no need to track
+            updates to the npm package, badge templates, or options.
+          </li>
+          <li>
+            A JSON response is easy to implement; easier than an HTTP redirect.
+            It is trivial in almost any framework, and is more compatible with
+            hosting environments such as{' '}
+            <a href="https://runkit.com/docs/endpoint">RunKit endpoints</a>.
+          </li>
+          <li>
+            As a service provider you can rely on the Shields CDN. There's no
+            need to study the HTTP headers. Adjusting cache behavior is as
+            simple as setting a property in the JSON response.
+          </li>
+        </ol>
+      </Explanation>
+      <h4>Schema</h4>
+      <Explanation>
+        <p>
+          Breaking changes to the schema will trigger an increment to the
+          `schemaVersion`.
+        </p>
+      </Explanation>
+      <Schema>
+        <dt>schemaVersion</dt>
+        <dd>
+          Required. Always the number <code>1</code>.
+        </dd>
+        <dt>label</dt>
+        <dd>
+          Required. The left text, or the empty string to omit the left side of
+          the badge. This can be overridden by the query string.
+        </dd>
+        <dt>message</dt>
+        <dd>Required. Can't be empty. The right text.</dd>
+        <dt>color</dt>
+        <dd>
+          Default: <code>lightgrey</code>. The right color. Supports the eight
+          named colors above, as well as hex, rgb, rgba, hsl, hsla and css named
+          colors. This can be overridden by the query string.
+        </dd>
+        <dt>labelColor</dt>
+        <dd>
+          Default: <code>grey</code>. The left color. This can be overridden by
+          the query string.
+        </dd>
+        <dt>isError</dt>
+        <dd>
+          Default: <code>false</code>. <code>true</code> to treat this as an
+          error badge. This prevents the user from overriding the color. In the
+          future it may affect cache behavior.
+        </dd>
+        <dt>namedLogo</dt>
+        <dd>
+          Default: none. One of the named logos supported by Shields or {}
+          <a href="https://simpleicons.org/">simple-icons</a>. Can be overridden
+          by the query string.
+        </dd>
+        <dt>logoSvg</dt>
+        <dd>Default: none. An SVG string containing a custom logo.</dd>
+        <dt>logoColor</dt>
+        <dd>
+          Default: none. Same meaning as the query string. Can be overridden by
+          the query string.
+        </dd>
+        <dt>logoWidth</dt>
+        <dd>
+          Default: none. Same meaning as the query string. Can be overridden by
+          the query string.
+        </dd>
+        <dt>logoPosition</dt>
+        <dd>
+          Default: none. Same meaning as the query string. Can be overridden by
+          the query string.
+        </dd>
+        <dt>style</dt>
+        <dd>
+          Default: <code>flat</code>. The default template to use. Can be
+          overridden by the query string.
+        </dd>
+        <dt>cacheSeconds</dt>
+        <dd>
+          Default: <code>300</code>, min <code>300</code>. Set the HTTP cache
+          lifetime in seconds, which should be respected by the Shields' CDN and
+          downstream users. Values below 300 will be ignored. This lets you tune
+          performance and traffic vs. responsiveness. The value you specify can
+          be overridden by the user via the query string, but only to a longer
+          value.
+        </dd>
+      </Schema>
+      <h4>Customize and test</h4>
+      <Customizer
+        baseUrl={baseUrl}
+        exampleNamedParams={{}}
+        exampleQueryParams={{
+          url: 'https://shields.redsparr0w.com/2473/monday',
+        }}
+        isPrefilled={false}
+        pattern="/endpoint"
+        title="Custom badge"
+      />
+      <Footer baseUrl={baseUrl} />
+    </MainContainer>
+  )
+}

lib/load-simple-icons.js

@@ -1,15 +1,13 @@
 'use strict'
 
-const simpleIcons = require('simple-icons')
+const originalSimpleIcons = require('simple-icons')
 const { svg2base64 } = require('./svg-helpers')
 
 function loadSimpleIcons() {
-  Object.keys(simpleIcons).forEach(key => {
+  const simpleIcons = {}
+  Object.keys(originalSimpleIcons).forEach(key => {
     const k = key.toLowerCase().replace(/ /g, '-')
-    if (k !== key) {
-      simpleIcons[k] = simpleIcons[key]
-      delete simpleIcons[key]
-    }
+    simpleIcons[k] = originalSimpleIcons[key]
     simpleIcons[k].base64 = {
       default: svg2base64(
         simpleIcons[k].svg.replace('<svg', `<svg fill="#${simpleIcons[k].hex}"`)

lib/load-simple-icons.spec.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const { expect } = require('chai')
+const loadSimpleIcons = require('./load-simple-icons')
+
+describe('loadSimpleIcons', function() {
+  let simpleIcons
+  before(function() {
+    simpleIcons = loadSimpleIcons()
+  })
+
+  it('prepares three color themes', function() {
+    expect(simpleIcons.sentry.base64).to.have.all.keys(
+      'default',
+      'light',
+      'dark'
+    )
+  })
+
+  it('normalizes icon keys', function() {
+    // original key in the simple-icons is 'Linux Foundation'
+    expect(simpleIcons).to.include.key('linux-foundation')
+  })
+
+  // https://github.com/badges/shields/issues/4016
+  it('excludes "get" function provided by the simple-icons', function() {
+    expect(simpleIcons).to.not.have.property('get')
+  })
+})

lib/logos.spec.js

@@ -19,7 +19,7 @@ describe('Logo helpers', function() {
   })
 
   test(isDataUrl, () => {
-    //valid input
+    // valid input
     given('data:image/svg+xml;base64,PHN2ZyB4bWxu').expect(true)
 
     // invalid inputs

package.json

@@ -22,49 +22,50 @@
     "url": "https://github.com/badges/shields"
   },
   "dependencies": {
-    "@hapi/joi": "^16.1.7",
-    "@sentry/node": "^5.7.1",
+    "@hapi/joi": "^16.1.8",
+    "@sentry/node": "^5.15.4",
     "bytes": "^3.1.0",
     "camelcase": "^5.3.1",
     "camp": "~17.2.4",
-    "chalk": "^2.4.2",
-    "check-node-version": "^4.0.1",
-    "chrome-web-store-item-property": "~1.1.2",
-    "config": "^3.2.4",
+    "chai-as-promised": "^7.1.1",
+    "chalk": "^3.0.0",
+    "check-node-version": "^4.0.3",
+    "chrome-web-store-item-property": "~1.2.0",
+    "config": "^3.3.1",
     "cross-env": "^6.0.3",
     "decamelize": "^3.2.0",
+    "deepmerge": "^4.2.2",
     "dotenv": "^8.2.0",
     "emojic": "^1.1.15",
     "escape-string-regexp": "^2.0.0",
-    "fast-xml-parser": "^3.14.0",
+    "fast-xml-parser": "^3.16.0",
     "fsos": "^1.1.6",
     "gh-badges": "file:gh-badges",
     "glob": "^7.1.6",
-    "graphql": "^14.5.8",
-    "graphql-tag": "^2.10.1",
-    "ioredis": "4.14.1",
+    "graphql": "^14.6.0",
+    "graphql-tag": "^2.10.3",
+    "ioredis": "4.16.2",
     "joi-extension-semver": "4.0.0",
     "js-yaml": "^3.13.1",
     "jsonpath": "~1.0.2",
     "lodash.countby": "^4.6.0",
-    "lodash.throttle": "^4.1.1",
+    "lodash.groupby": "^4.6.0",
     "lodash.times": "^4.3.2",
     "moment": "^2.24.0",
     "node-env-flag": "^0.1.0",
     "parse-link-header": "^1.0.1",
-    "path-to-regexp": "^3.1.0",
+    "path-to-regexp": "^5.0.0",
     "pretty-bytes": "^5.3.0",
     "priorityqueuejs": "^1.0.0",
     "prom-client": "^11.5.3",
-    "query-string": "^6.8.3",
-    "request": "~2.88.0",
-    "semver": "~6.3.0",
-    "simple-icons": "1.19.1",
-    "xmldom": "~0.1.27",
+    "query-string": "^6.12.1",
+    "request": "~2.88.2",
+    "semver": "~7.3.2",
+    "simple-icons": "2.9.0",
+    "xmldom": "~0.2.1",
     "xpath": "~0.0.27"
   },
   "scripts": {
-    "coverage:test:server": "echo \"Deprecated; run `npm run coverage:test:core` instead.\" && npm run coverage:test:core",
     "coverage:test:core": "nyc npm run test:core",
     "coverage:test:frontend": "nyc --nycrc-path .nycrc-frontend.json npm run test:frontend",
     "coverage:test:package": "nyc npm run test:package",
@@ -73,7 +74,7 @@
     "coverage:test:services": "nyc npm run test:services",
     "coverage:clean": "rimraf .nyc_output coverage",
     "precoverage:test": "run-s --silent coverage:clean defs features",
-    "coverage:test": "run-s --silent --continue-on-error coverage:test:server coverage:test:package coverage:test:entrypoint coverage:test:frontend coverage:test:integration",
+    "coverage:test": "run-s --silent --continue-on-error coverage:test:core coverage:test:package coverage:test:entrypoint coverage:test:frontend coverage:test:integration",
     "coverage:report:generate": "nyc report",
     "coverage:report:open": "open-cli coverage/lcov-report/index.html",
     "coverage:report": "run-s --silent coverage:report:generate coverage:report:open",
@@ -81,10 +82,6 @@
     "prettier": "prettier --write \"**/*.@(js|ts|tsx|md|json|yml)\"",
     "prettier:check": "prettier --check \"**/*.@(js|ts|tsx|md|json|yml)\"",
     "danger": "danger",
-    "test:server": "echo \"Deprecated; run `npm run test:core` instead.\" && npm run test:core",
-    "test:js:server": "echo \"Deprecated; run `npm run test:core` instead.\" && npm run test:core",
-    "test:js:frontend": "echo \"Deprecated; run `npm run test:frontend` instead.\" && npm run test:frontend",
-    "test:js:package": "echo \"Deprecated; run `npm run test:package` instead.\" && npm run test:package",
     "test:frontend": "cross-env NODE_ENV=test ts-mocha --config .mocharc-frontend.yml \"frontend/**/*.spec.@(js|ts|tsx)\"",
     "test:e2e": "cypress run",
     "test:core": "cross-env NODE_CONFIG_ENV=test mocha \"core/**/*.spec.js\" \"lib/**/*.spec.js\" \"services/**/*.spec.js\"",
@@ -97,7 +94,7 @@
     "test:services:pr:run": "cross-env NODE_CONFIG_ENV=test mocha --delay core/service-test-runner/cli.js --stdin < pull-request-services.log",
     "test:services:pr": "run-s --silent test:services:pr:prepare test:services:pr:run",
     "pretest": "run-s --silent defs features",
-    "test": "run-s --silent --continue-on-error lint test:frontend test:package test:server test:entrypoint prettier:check",
+    "test": "run-s --silent --continue-on-error lint test:frontend test:package test:core test:entrypoint prettier:check",
     "check-types:frontend": "tsc --noEmit --project .",
     "depcheck": "check-node-version --node \">= 8.0\"",
     "postinstall": "run-s --silent depcheck",
@@ -111,6 +108,8 @@
     "start:server:e2e-on-build": "node server 8080",
     "start:server": "cross-env NODE_CONFIG_ENV=development nodemon server 8080",
     "debug:server": "cross-env NODE_CONFIG_ENV=development nodemon --inspect server.js 8080",
+    "profile:server": "cross-env NODE_CONFIG_ENV=development node --prof server 8080",
+    "benchmark:badge": "cross-env NODE_CONFIG_ENV=test node scripts/benchmark-performance.js --iterations 10100 | node scripts/capture-timings.js --warmup-iterations 100",
     "prestart": "run-s --silent depcheck defs features",
     "start": "concurrently --names server,frontend \"npm run start:server\" \"cross-env GATSBY_BASE_URL=http://localhost:8080 gatsby develop --port 3000\"",
     "e2e": "start-server-and-test start http://localhost:3000 test:e2e",
@@ -144,117 +143,111 @@
     ]
   },
   "devDependencies": {
-    "@babel/core": "^7.7.2",
-    "@babel/plugin-proposal-class-properties": "^7.7.0",
-    "@babel/plugin-proposal-object-rest-spread": "^7.6.2",
-    "@babel/polyfill": "^7.7.0",
-    "@babel/preset-env": "^7.7.1",
-    "@babel/register": "7.7.0",
+    "@babel/core": "^7.9.0",
+    "@babel/polyfill": "^7.8.7",
+    "@babel/register": "7.9.0",
     "@mapbox/react-click-to-select": "^2.2.0",
-    "@types/chai": "^4.2.4",
+    "@types/chai": "^4.2.11",
     "@types/chai-enzyme": "^0.6.7",
-    "@types/enzyme": "^3.10.3",
+    "@types/enzyme": "^3.10.5",
     "@types/lodash.debounce": "^4.0.6",
     "@types/lodash.groupby": "^4.6.6",
-    "@types/mocha": "^5.2.7",
-    "@types/node": "^12.12.6",
-    "@types/react-helmet": "^5.0.14",
-    "@types/react-modal": "^3.10.0",
-    "@types/react-select": "^3.0.8",
+    "@types/mocha": "^7.0.2",
+    "@types/node": "^13.11.1",
+    "@types/react-helmet": "^5.0.15",
+    "@types/react-modal": "^3.10.5",
+    "@types/react-select": "^3.0.11",
     "@types/styled-components": "4.1.8",
-    "@typescript-eslint/eslint-plugin": "^1.13.0",
-    "@typescript-eslint/parser": "^1.13.0",
-    "babel-plugin-inline-react-svg": "^1.1.0",
-    "babel-plugin-istanbul": "^5.2.0",
-    "babel-preset-gatsby": "^0.2.20",
+    "@typescript-eslint/eslint-plugin": "^2.28.0",
+    "@typescript-eslint/parser": "^2.28.0",
+    "babel-plugin-inline-react-svg": "^1.1.1",
+    "babel-plugin-istanbul": "^6.0.0",
+    "babel-preset-gatsby": "^0.2.36",
     "caller": "^1.0.1",
     "chai": "^4.1.2",
     "chai-datetime": "^1.5.0",
     "chai-enzyme": "^1.0.0-beta.1",
     "chai-string": "^1.4.0",
+    "cheerio": "^1.0.0-rc.3",
     "child-process-promise": "^2.2.1",
     "clipboard-copy": "^3.1.0",
-    "concurrently": "^5.0.0",
-    "cypress": "^3.6.0",
-    "danger": "^9.2.4",
+    "concurrently": "^5.1.0",
+    "cypress": "^4.4.0",
+    "danger": "^10.1.1",
     "danger-plugin-no-test-shortcuts": "^2.0.0",
-    "enzyme": "^3.10.0",
-    "enzyme-adapter-react-16": "^1.15.1",
-    "eslint": "^5.16.0",
-    "eslint-config-prettier": "^6.5.0",
-    "eslint-config-standard": "^12.0.0",
-    "eslint-config-standard-jsx": "^8.1.0",
-    "eslint-config-standard-react": "^9.0.0",
+    "deepmerge": "^4.2.2",
+    "enzyme": "^3.11.0",
+    "enzyme-adapter-react-16": "^1.15.2",
+    "eslint": "^6.8.0",
+    "eslint-config-prettier": "^6.10.1",
+    "eslint-config-standard": "^14.1.1",
+    "eslint-config-standard-react": "^9.2.0",
     "eslint-plugin-chai-friendly": "^0.5.0",
-    "eslint-plugin-cypress": "^2.7.0",
-    "eslint-plugin-import": "^2.18.2",
-    "eslint-plugin-jsdoc": "^17.1.1",
-    "eslint-plugin-mocha": "^6.2.1",
+    "eslint-plugin-cypress": "^2.10.3",
+    "eslint-plugin-import": "^2.20.2",
+    "eslint-plugin-jsdoc": "^20.4.0",
+    "eslint-plugin-mocha": "^6.3.0",
     "eslint-plugin-no-extension-in-require": "^0.2.0",
-    "eslint-plugin-node": "^10.0.0",
+    "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^4.2.1",
-    "eslint-plugin-react": "^7.16.0",
-    "eslint-plugin-react-hooks": "^2.2.0",
-    "eslint-plugin-sort-class-members": "^1.6.0",
+    "eslint-plugin-react": "^7.19.0",
+    "eslint-plugin-react-hooks": "^2.5.1",
+    "eslint-plugin-sort-class-members": "^1.7.0",
     "eslint-plugin-standard": "^4.0.1",
     "fetch-ponyfill": "^6.1.0",
     "fs-readfile-promise": "^3.0.1",
-    "gatsby": "2.17.10",
-    "gatsby-plugin-catch-links": "^2.1.15",
-    "gatsby-plugin-page-creator": "^2.1.28",
-    "gatsby-plugin-react-helmet": "^3.1.13",
-    "gatsby-plugin-remove-trailing-slashes": "^2.1.12",
-    "gatsby-plugin-styled-components": "^3.1.11",
-    "gatsby-plugin-typescript": "^2.1.15",
+    "gatsby": "2.19.41",
+    "gatsby-plugin-catch-links": "^2.1.28",
+    "gatsby-plugin-page-creator": "^2.1.46",
+    "gatsby-plugin-react-helmet": "^3.1.24",
+    "gatsby-plugin-remove-trailing-slashes": "^2.1.24",
+    "gatsby-plugin-styled-components": "^3.1.21",
+    "gatsby-plugin-typescript": "^2.2.5",
     "got": "^9.6.0",
     "humanize-string": "^2.1.0",
-    "husky": "^3.0.9",
+    "husky": "^3.1.0",
     "icedfrisby": "3.0.0",
     "icedfrisby-nock": "^2.0.0",
     "is-png": "^2.0.0",
-    "is-svg": "^4.2.0",
+    "is-svg": "^4.2.1",
     "js-yaml-loader": "^1.2.2",
-    "jsdoc": "^3.6.3",
-    "lint-staged": "^9.4.2",
+    "jsdoc": "^3.6.4",
+    "lint-staged": "^9.5.0",
     "lodash.debounce": "^4.0.8",
     "lodash.difference": "^4.5.0",
-    "lodash.groupby": "^4.6.0",
-    "minimist": "^1.2.0",
-    "mkdirp": "^0.5.1",
-    "mocha": "^6.2.2",
+    "minimist": "^1.2.5",
+    "mocha": "^6.2.3",
     "mocha-env-reporter": "^4.0.0",
-    "mocha-junit-reporter": "^1.23.1",
+    "mocha-junit-reporter": "^1.23.3",
     "mocha-yaml-loader": "^1.0.3",
-    "nock": "11.7.0",
-    "node-mocks-http": "^1.8.0",
-    "nodemon": "^1.19.4",
+    "nock": "11.9.1",
+    "node-mocks-http": "^1.8.1",
+    "nodemon": "^2.0.3",
     "npm-run-all": "^4.1.5",
-    "nyc": "^14.1.1",
+    "nyc": "^15.0.1",
     "opn-cli": "^5.0.0",
     "portfinder": "^1.0.25",
-    "prettier": "1.18.2",
-    "react": "^16.11.0",
-    "react-dom": "^16.11.0",
-    "react-error-overlay": "^6.0.3",
+    "prettier": "1.19.1",
+    "react": "^16.13.1",
+    "react-dom": "^16.13.1",
+    "react-error-overlay": "^3.0.0",
     "react-helmet": "^5.2.1",
-    "react-modal": "^3.11.1",
-    "react-pose": "^4.0.9",
-    "react-select": "^3.0.8",
+    "react-modal": "^3.11.2",
+    "react-pose": "^4.0.10",
+    "react-select": "^3.1.0",
     "read-all-stdin-sync": "^1.0.5",
     "redis-server": "^1.2.2",
     "require-hacker": "^3.0.1",
-    "rimraf": "^3.0.0",
+    "rimraf": "^3.0.2",
     "sazerac": "^1.1.0",
-    "sinon": "^7.5.0",
-    "sinon-chai": "^3.3.0",
-    "snap-shot-it": "^7.9.0",
-    "start-server-and-test": "^1.10.6",
-    "styled-components": "^4.4.1",
+    "sinon": "^8.1.1",
+    "sinon-chai": "^3.5.0",
+    "snap-shot-it": "^7.9.3",
+    "start-server-and-test": "1.10.7",
+    "styled-components": "^5.1.0",
     "tmp": "0.1.0",
-    "ts-mocha": "^6.0.0",
-    "typescript": "^3.6.4",
-    "url": "^0.11.0",
-    "walkdir": "0.4.1"
+    "ts-mocha": "^7.0.0",
+    "typescript": "^3.8.3"
   },
   "engines": {
     "node": "^10.16.3",

scripts/badge-cli.js

@@ -10,7 +10,10 @@ const trace = require('../core/base-service/trace')
 function normalizeBadgeUrl(url) {
   // Provide a base URL in order to accept fragments.
   const { pathname, searchParams } = new URL(url, 'http://example.com')
-  const newPath = pathname.replace('.svg', '.json')
+  let newPath = pathname.replace('.svg', '')
+  if (!newPath.endsWith('.json')) {
+    newPath = `${newPath}.json`
+  }
   return `${newPath}?${searchParams.toString()}`
 }
 

scripts/benchmark-performance.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const config = require('config').util.toObject()
+const got = require('got')
+const minimist = require('minimist')
+const Server = require('../core/server/server')
+
+async function main() {
+  const server = new Server(config)
+  await server.start()
+  const args = minimist(process.argv)
+  const iterations = parseInt(args.iterations) || 10000
+  for (let i = 0; i < iterations; ++i) {
+    await got(`${server.baseUrl}badge/coverage-${i}-green.svg`)
+  }
+  await server.stop()
+}
+
+;(async () => {
+  try {
+    await main()
+  } catch (e) {
+    console.error(e)
+    process.exit(1)
+  }
+})()

scripts/benchmark-performance.sh

@@ -1,11 +0,0 @@
-#!/bin/sh
-
-PROFILE_MAKE_BADGE=1 node server 1111 >perftest.log &
-sleep 2
-for ((i=0;i<10000;i++)); do
-  curl -s http://localhost:1111/badge/coverage-"$i"%-green.svg >/dev/null
-done
-kill $(jobs -p)
-<perftest.log grep 'makeBadge total' | \
-  grep -Eo '[0-9\.]+' | \
-  awk '{s+=$1;n++} END {print s/n}'

scripts/capture-timings.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const readline = require('readline')
+const minimist = require('minimist')
+
+async function captureTimings(warmupIterations) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+  })
+
+  const times = {}
+  let timingsCount = 0
+  let labelsCount = 0
+  const timing = /^(.+): ([0-9.]+)ms$/i
+
+  for await (const line of rl) {
+    const match = timing.exec(line)
+    if (match) {
+      labelsCount = Object.keys(times).length
+      if (timingsCount > warmupIterations * labelsCount) {
+        const label = match[1]
+        const time = parseFloat(match[2])
+        times[label] = time + (times[label] || 0)
+      }
+      ++timingsCount
+    }
+  }
+  return { times, iterations: timingsCount / labelsCount }
+}
+
+function logResults({ times, iterations, warmupIterations }) {
+  if (isNaN(iterations)) {
+    console.log(
+      `No timings captured. Have you included console.time statements in the badge creation code path?`
+    )
+  } else {
+    const timedIterations = iterations - warmupIterations
+    for (const [label, time] of Object.entries(times)) {
+      const averageTime = time / timedIterations
+      console.log(
+        `Average '${label}' time over ${timedIterations} iterations: ${averageTime}ms`
+      )
+    }
+  }
+}
+
+async function main() {
+  const args = minimist(process.argv)
+  const warmupIterations = parseInt(args['warmup-iterations']) || 100
+  const { times, iterations } = await captureTimings(warmupIterations)
+  logResults({ times, iterations, warmupIterations })
+}
+
+;(async () => {
+  try {
+    await main()
+  } catch (e) {
+    console.error(e)
+    process.exit(1)
+  }
+})()

server.js

@@ -16,7 +16,7 @@ Sentry.init({
     const filtered = integrations.filter(
       integration => !disabledIntegrations.includes(integration.name)
     )
-    if (filtered.length != integrations.length - disabledIntegrations.length) {
+    if (filtered.length !== integrations.length - disabledIntegrations.length) {
       throw Error(
         `An error occurred while filtering integrations. The following inetgrations were found: ${integrations.map(
           ({ name }) => name

services/amo/amo-downloads.service.js

@@ -2,8 +2,8 @@
 
 const { metric } = require('../text-formatters')
 const { downloadCount } = require('../color-formatters')
-const { BaseAmoService, keywords } = require('./amo-base')
 const { redirector } = require('..')
+const { BaseAmoService, keywords } = require('./amo-base')
 
 const documentation = `
 <p>

services/amo/amo-downloads.tester.js

@@ -17,5 +17,5 @@ t.create('Weekly Downloads (not found)')
   .expectBadge({ label: 'downloads', message: 'not found' })
 
 t.create('/d URL should redirect to /dw')
-  .get('/d/dustman.json')
-  .expectBadge({ label: 'downloads', message: isMetricOverTimePeriod })
+  .get('/d/dustman.svg')
+  .expectRedirect('/amo/dw/dustman.svg')

services/appveyor/appveyor-base.js

@@ -10,6 +10,10 @@ const schema = Joi.object({
     status: isBuildStatus,
     jobs: Joi.array()
       .items({
+        name: Joi.string()
+          .allow('')
+          .required(),
+        status: isBuildStatus,
         testsCount: nonNegativeInteger,
         passedTestsCount: nonNegativeInteger,
         failedTestsCount: nonNegativeInteger,

services/appveyor/appveyor-build-redirect.service.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const { redirector } = require('..')
+
+module.exports = [
+  redirector({
+    category: 'build',
+    route: {
+      base: 'appveyor/ci',
+      pattern: ':user/:repo/:branch*',
+    },
+    transformPath: ({ user, repo, branch }) =>
+      `/appveyor/build/${user}/${repo}${branch ? `/${branch}` : ''}`,
+    dateAdded: new Date('2019-12-10'),
+  }),
+]

services/appveyor/appveyor-build-redirect.tester.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const { ServiceTester } = require('../tester')
+
+const t = (module.exports = new ServiceTester({
+  id: 'AppveyorBuildRedirect',
+  title: 'AppveyorBuildRedirect',
+  pathPrefix: '/appveyor/ci',
+}))
+
+t.create('Appveyor CI')
+  .get('/gruntjs/grunt', {
+    followRedirect: false,
+  })
+  .expectStatus(301)
+  .expectHeader('Location', '/appveyor/build/gruntjs/grunt.svg')
+
+t.create('Appveyor CI (branch)')
+  .get('/gruntjs/grunt/develop', {
+    followRedirect: false,
+  })
+  .expectStatus(301)
+  .expectHeader('Location', '/appveyor/build/gruntjs/grunt/develop.svg')

services/appveyor/appveyor-build.service.js

@@ -3,9 +3,9 @@
 const { renderBuildStatusBadge } = require('../build-status')
 const AppVeyorBase = require('./appveyor-base')
 
-module.exports = class AppVeyorCi extends AppVeyorBase {
+module.exports = class AppVeyorBuild extends AppVeyorBase {
   static get route() {
-    return this.buildRoute('appveyor/ci')
+    return this.buildRoute('appveyor/build')
   }
 
   static get examples() {
@@ -31,7 +31,7 @@ module.exports = class AppVeyorCi extends AppVeyorBase {
 
   async handle({ user, repo, branch }) {
     const data = await this.fetch({ user, repo, branch })
-    if (!data.hasOwnProperty('build')) {
+    if (!('build' in data)) {
       // this project exists but no builds have been run on it yet
       return this.constructor.render({ status: 'no builds found' })
     }

services/appveyor/appveyor-job-build.service.js

@@ -0,0 +1,68 @@
+'use strict'
+
+const { renderBuildStatusBadge } = require('../build-status')
+const { NotFound } = require('..')
+const AppVeyorBase = require('./appveyor-base')
+
+module.exports = class AppVeyorJobBuild extends AppVeyorBase {
+  static get route() {
+    return {
+      base: 'appveyor/job/build',
+      pattern: ':user/:repo/:job/:branch*',
+    }
+  }
+
+  static get examples() {
+    return [
+      {
+        title: 'AppVeyor Job',
+        pattern: ':user/:repo/:job',
+        namedParams: {
+          user: 'wpmgprostotema',
+          repo: 'voicetranscoder',
+          job: 'Linux',
+        },
+        staticPreview: renderBuildStatusBadge({ status: 'success' }),
+      },
+      {
+        title: 'AppVeyor Job branch',
+        pattern: ':user/:repo/:job/:branch',
+        namedParams: {
+          user: 'wpmgprostotema',
+          repo: 'voicetranscoder',
+          job: 'Windows',
+          branch: 'master',
+        },
+        staticPreview: renderBuildStatusBadge({ status: 'success' }),
+      },
+    ]
+  }
+
+  transform({ data, jobName }) {
+    if (!('build' in data)) {
+      // this project exists but no builds have been run on it yet
+      return { status: 'no builds found' }
+    }
+
+    const {
+      build: { jobs },
+    } = data
+    if (!jobs) {
+      throw new NotFound({ prettyMessage: 'no jobs found' })
+    }
+
+    const job = jobs.find(j => j.name === jobName)
+
+    if (!job) {
+      throw new NotFound({ prettyMessage: 'job not found' })
+    }
+
+    return { status: job.status }
+  }
+
+  async handle({ user, repo, job, branch }) {
+    const data = await this.fetch({ user, repo, branch })
+    const { status } = this.transform({ data, jobName: job })
+    return renderBuildStatusBadge({ status })
+  }
+}