evaengine 1.0.14 → 3.0.0

package/src/middlewares/debug.js

@@ -1,88 +0,0 @@
-import morgan from 'morgan';
-import os from 'os';
-import constitute from 'constitute';
-import Logger from '../services/logger.js';
-
-/**
- Log format:
- NCSA Combined Log Format + extended fields
-
- Nginx config as below
-
- log_format upstream '$http_x_forwarded_for - $remote_user [$time_local] '
- '"$request" $status $body_bytes_sent '
- '"$http_referer" "$http_user_agent" '
- '"$remote_addr" $host $request_time $upstream_response_time $scheme $server_port '
- '$hostname $upstream_addr $http_x_device_id $sent_http_x_uid $sent_http_x_token '
- '$sent_http_x_service_name $sent_http_x_b3_spanid $sent_http_x_b3_traceid '
- '$sent_http_x_b3_parentspanid $sent_http_x_b3_sampled';
- */
-
-morgan.token(
-  'host',
-  req =>
-    req.headers.host
-);
-
-morgan.token(
-  'real-ip',
-  req =>
-    req.headers['x-real-ip'] ||
-    req.headers['x-forwarded-for'] ||
-    req.ip ||
-    (req.connection && req.connection.remoteAddress)
-);
-
-morgan.token(
-  'port',
-  req =>
-    (req.headers.host && req.headers.host.split(':')[1]) || -1
-);
-
-const hostname = os.hostname();
-morgan.token('hostname', () => hostname);
-
-morgan.token(
-  'tokens',
-  (req, res) =>
-    [
-      res.getHeader('X-Uid') || '-',
-      res.getHeader('X-Token') || '-'
-    ].join(' ')
-);
-
-morgan.token(
-  'tracer',
-  (req, res) =>
-    [
-      res.getHeader('X-Service-Name') || '-',
-      res.getHeader('X-B3-SpanId') || '-',
-      res.getHeader('X-B3-TraceId') || '-',
-      res.getHeader('X-B3-ParentSpanId') || '-',
-      res.getHeader('X-B3-Sampled') || '-'
-    ].join(' ')
-);
-
-
-/**
- * @param logger {Logger}
- * @returns {function()}
- * @constructor
- */
-function DebugMiddleware(logger) {
-  return () =>
-    morgan(
-      ':real-ip - :remote-user [:date[clf]] ":method :url HTTP/:http-version" :status :res[content-length] ":referrer" ":user-agent" ' +
-      '":remote-addr" :host :response-time - :http-version :port :hostname - :tokens :tracer %s',
-      {
-        stream: {
-          write: (message) => {
-            logger.info(message);
-          }
-        }
-      }
-    );
-}
-
-constitute.Dependencies(Logger)(DebugMiddleware);
-export default DebugMiddleware;

package/src/middlewares/providers.js

@@ -1,73 +0,0 @@
-import SessionMiddleware from '../middlewares/session.js';
-import AuthMiddleware from '../middlewares/auth.js';
-import AuthKongMiddleware from '../middlewares/auth_kong.js';
-import DebugMiddleware from '../middlewares/debug.js';
-import TraceMiddleware from '../middlewares/trace.js';
-import ViewCacheMiddleware from '../middlewares/view_cache.js';
-import ValidatorMiddleware from '../middlewares/validator.js';
-import DI from '../di.js';
-import { ServiceProvider } from '../services/providers.js';
-
-export class SessionMiddlewareProvider extends ServiceProvider {
-  get name() {
-    return 'session';
-  }
-
-  register() {
-    DI.bindMethod(this.name, SessionMiddleware);
-  }
-}
-
-export class AuthMiddlewareProvider extends ServiceProvider {
-  get name() {
-    return 'auth';
-  }
-
-  register() {
-    if (DI.get('config').get('token.provider') === 'kong') {
-      DI.bindMethod(this.name, AuthKongMiddleware);
-    } else {
-      DI.bindMethod(this.name, AuthMiddleware);
-    }
-  }
-}
-
-export class DebugMiddlewareProvider extends ServiceProvider {
-  get name() {
-    return 'debug';
-  }
-
-  register() {
-    DI.bindMethod(this.name, DebugMiddleware);
-  }
-}
-
-export class ViewCacheMiddlewareProvider extends ServiceProvider {
-  get name() {
-    return 'view_cache';
-  }
-
-  register() {
-    DI.bindMethod(this.name, ViewCacheMiddleware);
-  }
-}
-
-export class TraceMiddlewareProvider extends ServiceProvider {
-  get name() {
-    return 'trace';
-  }
-
-  register() {
-    DI.bindMethod(this.name, TraceMiddleware);
-  }
-}
-
-export class ValidatorMiddlewareProvider extends ServiceProvider {
-  get name() {
-    return 'validator';
-  }
-
-  register() {
-    DI.bindMethod(this.name, ValidatorMiddleware);
-  }
-}

package/src/middlewares/session.js

@@ -1,63 +0,0 @@
-import session from 'express-session';
-import { RedisStore } from 'connect-redis';
-import constitute from 'constitute';
-import DI from '../di.js';
-import Config from '../services/config.js';
-import Redis from '../services/redis.js';
-import Namespace from '../services/namespace.js';
-
-let middleware = null;
-
-//Fix issue https://github.com/othiym23/node-continuation-local-storage/issues/29
-const clsifyMiddleware = (fn, ns) =>
-  (req, res, next) =>
-    fn.call(this, req, res, ns.bind(next));
-
-/**
- * @param _config {Config}
- * @param redis {Redis}
- * @param namespace {Namespace}
- * @returns {function()}
- * @constructor
- */
-function SessionMiddleware(_config, redis, namespace) {
-  return () => {
-    if (middleware) {
-      return middleware;
-    }
-    const Store = RedisStore;
-    let store = null;
-    const config = _config.get().session;
-
-    if (config.store) {
-      const RedisClient = new Store(Object.assign({}, config.store, {
-        client: config.store.client || redis.getInstance()
-      }));
-      RedisClient.client.on('error', (err) => {
-        try {
-          DI.get('logger').error('Session Redis store error:', err);
-        } catch {
-          console.error('Session Redis store error:', err);
-        }
-      });
-      store = RedisClient;
-    } else {
-      store = new Store(Object.assign({}, { client: redis.getInstance() }));
-    }
-
-    middleware = session({
-      store,
-      cookie: Object.assign({}, _config.get().cookie),
-      secret: config.secret,
-      resave: config.resave,
-      saveUninitialized: config.saveUninitialized
-    });
-
-    return namespace.isEnabled() ?
-      clsifyMiddleware(middleware, namespace.use().getContext()) :
-      middleware;
-  };
-}
-constitute.Dependencies(Config, Redis, Namespace)(SessionMiddleware);
-
-export default SessionMiddleware;

package/src/middlewares/trace.js

@@ -1,254 +0,0 @@
-import constitute from 'constitute';
-import { randomString, getHostFullUrl, getHostPort, getHostIp, getMicroTimestamp } from '../utils/index.js';
-import Namespace from '../services/namespace.js';
-import Config from '../services/config.js';
-import Logger from '../services/logger.js';
-import HttpClient from '../services/http_client.js';
-
-const hostIp = getHostIp();
-
-/**
- * Execute a listener when a response is about to write headers.
- * Inlined from the on-headers package (MIT), limited to the behavior trace middleware needs.
- * @param {object} res
- * @param {function} listener
- */
-const onHeaders = (res, listener) => {
-  if (!res) {
-    throw new TypeError('argument res is required');
-  }
-  if (typeof listener !== 'function') {
-    throw new TypeError('argument listener must be a function');
-  }
-
-  const prevWriteHead = res.writeHead;
-  let fired = false;
-
-  res.writeHead = function writeHead() {
-    if (!fired) {
-      fired = true;
-      listener.call(this);
-    }
-    return prevWriteHead.apply(this, arguments);
-  };
-};
-
-export const tracerToZipkins = (tracer) => {
-  if (!tracer) {
-    return false;
-  }
-  const {
-    url,
-    method,
-    serviceName,
-    spanId: id,
-    traceId,
-    parentId,
-    timestamp,
-    duration,
-    statusCode,
-    port,
-    queries
-  } = tracer;
-
-  const name = `${statusCode} ${method} ${url}`;
-  const endpoint = {
-    serviceName,
-    ipv4: hostIp,
-    port
-  };
-  const zipkin = {
-    id,
-    traceId,
-    name,
-    timestamp,
-    duration,
-    annotations: [
-      {
-        endpoint,
-        timestamp,
-        value: 'sr'
-      },
-      {
-        endpoint,
-        timestamp: timestamp + duration,
-        value: 'ss'
-      }
-    ],
-    binaryAnnotations: [
-      {
-        key: 'traceId',
-        value: traceId
-      },
-      {
-        key: 'spanId',
-        value: id
-      },
-      {
-        key: 'method',
-        value: method
-      },
-      {
-        key: 'url',
-        value: url
-      },
-      {
-        key: 'port',
-        value: port.toString()
-      },
-      {
-        key: 'statusCode',
-        value: statusCode.toString()
-      }
-    ]
-  };
-
-  if (parentId) {
-    zipkin.parentId = parentId;
-  }
-
-  const zipkins = [zipkin];
-  if (queries && queries.length > 0) {
-    queries.forEach((element) => {
-      const { query, cost, finishedAt } = element;
-      zipkins.push({
-        id: randomString(),
-        parentId: id,
-        traceId,
-        name: 'sequelize',
-        timestamp: finishedAt - cost,
-        duration: cost,
-        annotations: [
-          {
-            endpoint,
-            timestamp: finishedAt - cost,
-            value: 'cs'
-          },
-          {
-            endpoint,
-            timestamp: finishedAt,
-            value: 'cr'
-          }
-        ],
-        binaryAnnotations: [{
-          key: 'query',
-          value: query
-        }]
-      });
-    });
-  }
-  return zipkins;
-};
-
-
-function TraceMiddleware(ns, config, logger, client) {
-  const enabled = config.get('trace.enable');
-  return name => (req, res, next) => {
-    const spanId = randomString();
-    const traceId = req.get('X-B3-TraceId') || spanId;
-    const parentId = req.get('X-B3-SpanId') || '';
-    const startedAt = process.hrtime();
-    const timestamp = getMicroTimestamp();
-    const serviceName = name || config.get('app.name');
-    //目前默认全部采样
-    let sampled = enabled ? 1 : 0;
-    //只有service为第二级, 且通过参数关闭时才禁止采样
-    if (sampled && parseInt(req.get('X-B3-Sampled'), 10) < 1 && parentId > 0) {
-      sampled = 0;
-    }
-    const tracer = {
-      serviceName,
-      method: req.method,
-      url: getHostFullUrl(req),
-      port: getHostPort(req),
-      spanId,
-      traceId,
-      parentId,
-      sampled,
-      timestamp,
-      duration: null,
-      statusCode: null,
-      queries: [],
-      debug: {}
-    };
-
-    res.set({
-      'X-Service-Name': serviceName,
-      'X-Requested-At': timestamp,
-      'X-B3-SpanId': spanId,
-      'X-B3-TraceId': traceId,
-      'X-B3-ParentSpanId': parentId,
-      'X-B3-Sampled': sampled
-    });
-
-    if (sampled < 1) {
-      onHeaders(res, () => {
-        const [seconds, nanoseconds] = process.hrtime(startedAt);
-        const duration = ((seconds * 1e3) + (nanoseconds * 1e-6));
-        res.set('X-Response-Milliseconds', parseInt(duration, 10));
-      });
-      next();
-      return;
-    }
-
-    onHeaders(res, () => {
-      const [seconds, nanoseconds] = process.hrtime(startedAt);
-      const duration = ((seconds * 1e3) + (nanoseconds * 1e-6)) * 1000;
-      tracer.duration = parseInt(duration, 10);
-      tracer.statusCode = res.statusCode;
-      res.set('X-Response-Milliseconds', tracer.duration / 1000);
-
-      const useHeader = config.get('trace.header');
-      if (!useHeader) {
-        return;
-      }
-      const zipkins = tracerToZipkins(tracer);
-      if (!zipkins) {
-        logger.warn('Tracer not send by no data for request %s', spanId);
-      } else {
-        res.set(`X-Debug-${spanId}`, JSON.stringify(zipkins));
-      }
-
-      if (Object.keys(tracer.debug).length > 0) {
-        Object.entries(tracer.debug).forEach(([key, value]) => {
-          res.set(key.replace('x-debug', 'X-Debug'), value);
-        });
-      }
-    });
-
-    const recordZipkin = () => {
-      const api = config.get('trace.api');
-      if (!api) {
-        return;
-      }
-      logger.debug('Tracer prepare to send for request %s', spanId);
-      const zipkins = tracerToZipkins(ns.get('tracer'));
-      if (!zipkins) {
-        logger.warn('Tracer not send by no data for request %s', spanId);
-        return;
-      }
-      client.request({
-        url: api,
-        method: 'POST',
-        json: zipkins
-      }).catch((e) => {
-        logger.error('Error happened on sending tracing data: %o', e);
-      });
-    };
-
-    res.on('finish', recordZipkin);
-    res.on('error', recordZipkin);
-
-    ns.bindEmitter(req);
-    ns.bindEmitter(res);
-    ns.run(() => {
-      // logger.debug('Tracer settled for request %s, tracer: %j', spanId, tracer);
-      ns.set('tracer', tracer);
-      next();
-    });
-  };
-}
-
-constitute.Dependencies(Namespace, Config, Logger, HttpClient)(TraceMiddleware);
-
-export default TraceMiddleware;

package/src/middlewares/validator.js

@@ -1,50 +0,0 @@
-import Joi from 'joi';
-import constitute from 'constitute';
-import wrapper from '../utils/wrapper.js';
-import { FormInvalidateException } from '../exceptions/index.js';
-import ValidatorBase from '../services/joi.js';
-
-const validate = (data, schema, options) => {
-  const validationOptions = Object.assign(
-    { abortEarly: false, allowUnknown: true },
-    options
-  );
-  if (schema && typeof schema.validateAsync === 'function') {
-    return schema.validateAsync(data, validationOptions);
-  }
-  return new Promise((resolve, reject) => {
-    Joi.validate(data, schema, validationOptions, (err, value) => {
-      if (err) reject(err);
-      else resolve(value);
-    });
-  });
-};
-
-/**
- * @returns {function()}
- * @constructor
- */
-function ValidatorMiddleware(validatorBase) {
-  return (getSchema, options, validator) =>
-    wrapper(async (req, res, next) => {
-      const { query, body, path } = getSchema(validator || validatorBase.getJoi());
-      try {
-        if (query) {
-          await validate(req.query, query, options);
-        }
-        if (body) {
-          await validate(req.body, body, options);
-        }
-        if (path) {
-          await validate(req.params, path, options);
-        }
-        return next();
-      } catch (e) {
-        throw new FormInvalidateException(e);
-      }
-    });
-}
-
-constitute.Dependencies(ValidatorBase)(ValidatorMiddleware);
-
-export default ValidatorMiddleware;

package/src/middlewares/view_cache.js

@@ -1,127 +0,0 @@
-import constitute from 'constitute';
-import crypto from 'crypto';
-import moment from 'moment-timezone';
-import Logger from '../services/logger.js';
-import Cache from '../services/cache.js';
-import wrapper from '../utils/wrapper.js';
-import { RuntimeException } from '../exceptions/index.js';
-
-export const defaultHashStrategy = obj => obj;
-
-export const defaultHeadersFilter = (res) => {
-  const headers = [];
-  ['Content-Type'].forEach((key) => {
-    const value = res.get(key);
-    if (value) {
-      headers.push([key, value]);
-    }
-  });
-  return headers;
-};
-
-export const requestToCacheKey = (req, hashStrategy) => {
-  const {
-    method,
-    originalUrl,
-    query: originQuery,
-    route
-  } = req;
-  //Prefer uid resolved by auth middleware, keep req.uid as custom rule fallback
-  const uid = (req.auth && req.auth.uid) || req.uid || null;
-  const query = { ...originQuery };
-  delete query.flush;
-  if (hashStrategy && typeof hashStrategy !== 'function') {
-    throw new RuntimeException(`View cache hash strategy must be a function for ${originalUrl}`);
-  }
-  if (!route) {
-    throw new RuntimeException(`View cache middleware require route for ${originalUrl}`);
-  }
-  if (method.toLowerCase() !== 'get') {
-    throw new RuntimeException(`View cache middleware only support GET method of http request for ${originalUrl}`);
-  }
-  const { host = 'unknown' } = req.headers;
-  const [urlPath = ''] = originalUrl.split('?');
-  const key = [method, `/${host}`, urlPath].join('').replace(/:/g, '_').toLowerCase();
-  const strategy = hashStrategy || defaultHashStrategy;
-  const hash = crypto
-    .createHash('md5')
-    .update(JSON
-      .stringify(strategy({
-        method,
-        urlPath,
-        query,
-        uid
-      })))
-    .digest('hex');
-  return [key, hash].join(':');
-};
-
-
-/**
- * @param {Cache} cache
- * @param {Logger} logger
- * @returns {function(*=)}
- * @constructor
- */
-function ViewCacheMiddleware(cache, logger) {
-  return (options = {}) => {
-    if (options === null || typeof options !== 'object') {
-      options = {
-        ttl: options
-      };
-    }
-    const {
-      ttl,
-      headersFilter,
-      namespace,
-      hashStrategy
-    } = Object.assign({
-      ttl: 60,
-      headersFilter: defaultHeadersFilter,
-      hashStrategy: defaultHashStrategy,
-      namespace: 'view'
-    }, options);
-    return wrapper(async (req, res, next) => {
-      const cacheKey = requestToCacheKey(req, hashStrategy);
-      const {
-        headers: cachedHeaders = [],
-        body: cachedBody
-      } = await cache.namespace(namespace).get(cacheKey)
-      || {
-        headers: [],
-        body: null
-      };
-      if (req.query.flush !== 'true' && cachedBody) {
-        logger.debug('View cache hit by key %s', cacheKey);
-        if (cachedHeaders.length > 0) {
-          cachedHeaders.forEach(([key, value]) => {
-            res.setHeader(key, value);
-          });
-        }
-        res.setHeader('X-View-Cache-Hit', cacheKey);
-        res.send(cachedBody);
-        return;
-      }
-      res.realSend = res.send;
-      res.send = (body) => {
-        logger.debug('View cache missed by key %s, creating...', cacheKey);
-        res.setHeader('X-View-Cache-Miss', cacheKey);
-        res.setHeader('X-View-Cache-Expire-At', moment().add(ttl, 'minute').format('YYYY-MM-DD HH:mm:ss Z'));
-        res.setHeader('X-View-Cache-Created-At', moment().format('YYYY-MM-DD HH:mm:ss Z'));
-        res.realSend(body);
-        const headers = headersFilter && typeof headersFilter === 'function' ?
-          headersFilter(res) : defaultHeadersFilter(res);
-        if (res.statusCode <= 500) {
-          cache.namespace(namespace).set(cacheKey, { headers, body }, ttl).catch((e) => {
-            logger.error('View cache set failed for %s: %o', cacheKey, e);
-          });
-        }
-      };
-      next();
-    });
-  };
-}
-
-constitute.Dependencies(Cache, Logger)(ViewCacheMiddleware);
-
-export default ViewCacheMiddleware;