@sellout/service 0.0.1

package/src/Tracer.ts

@@ -0,0 +1,55 @@
+import { initTracer, Span, SpanContext } from 'jaeger-client';
+const JAEGER_AGENT_HOST = process.env.JAEGER_AGENT_HOST;
+
+console.log(`Jaeger Agent Host: ${JAEGER_AGENT_HOST}`);
+
+export default class Tracer {
+
+  serviceName: string;
+  logger: any;
+  tracer: any;
+
+  constructor(serviceName: string, logger: any = console, verbose: boolean = true) {
+    this.serviceName = serviceName;
+    this.logger = logger ? logger : console;
+    this.tracer = initTracer(this.config(verbose), this.options());
+  }
+
+  config(verbose: boolean) {
+    return {
+      serviceName: this.serviceName,
+      sampler: {
+        type: "const",
+        param: 1
+      },
+      reporter: {
+        // agentHost: 'jaeger-agent',
+        agentHost: JAEGER_AGENT_HOST,
+        // agentHost: 'foobar',
+        // collectorEndpoint: "http://localhost:14268/api/traces",
+        logSpans: verbose
+      }
+    };
+  }
+
+  options() {
+    const options = {
+      logger: this.logger,
+    };
+
+    return options;
+  }
+
+  startSpan(name: string, parentSpan?: (Span | SpanContext | string)) {
+    let childOf;
+
+    if (typeof parentSpan === 'string') {
+      childOf = SpanContext.fromString(parentSpan);
+    } else if (parentSpan instanceof Span) {
+      childOf = parentSpan.context();
+    } else if (parentSpan instanceof SpanContext) {
+      childOf = parentSpan;
+    }
+    return this.tracer.startSpan(name, { childOf });
+  }
+}

package/src/TracerExpress.ts

@@ -0,0 +1,36 @@
+import Tracer from './Tracer';
+import * as url from 'url';
+
+const traceHTTP = (req, res, tracer): void => {
+  const pathname = url.parse(req.url).pathname;
+  const span = tracer.startSpan(<string>pathname);
+  span.logEvent('request_recieved');
+  span.setTag('span.kind', 'server');
+  span.setTag('http.method', req.method);
+  span.setTag('http.url', req.url);
+  
+  res.setHeader('uver-trace-id', span.context().toString());
+  
+  req.span = span;
+  req.tracer = tracer;
+
+  const finish = () => {
+    span.logEvent('request_finished');
+    span.setTag('http.status_code', res.statusCode);
+    if(res.statusCode >= 500) {
+      span.setTag('error', true);
+      span.setTag('sampling.priority', 1);
+    }
+    span.finish();
+  };
+  
+  res.on("finish", finish);
+};
+
+export const tracerExpress = (serviceName: string) => {
+  const tracer = new Tracer(serviceName);
+  return async (req, res, next): Promise<void> => {
+    traceHTTP(req, res, tracer);
+    next();
+  }
+};

package/src/build/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compileOnSave": true,
+  "compilerOptions": {
+    "inlineSourceMap": true,
+    "baseUrl": ".",
+    "moduleResolution": "node",
+    "target": "es6",
+    "esModuleInterop": true,
+    "lib": ["es6", "dom", "esnext.asynciterable"],
+    "module": "commonjs",
+    "outDir": "./.dist/",
+    "declaration": true,
+    // "sourceMap": true,
+    // "strictNullChecks": true,
+    "noUnusedLocals": true,
+    "paths": {},
+    "types": [
+      "node",
+      "long",
+      "mocha"
+    ]
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/templates",
+  ],
+  "exclude": [
+    "node_modules",
+    "test/*",
+    "dist/*"
+  ]
+}

package/src/build/tslint.json

@@ -0,0 +1,17 @@
+{
+  "extends": "tslint-config-airbnb",
+  "rules": {
+     "quotemark": [
+       true,
+       "single"
+    ],
+    "import-name": false,
+    "variable-name": false,
+    "max-line-length": false,
+    "no-console": false,
+    "ban": false
+  },
+  "jsRules": {
+    "max-line-length": false
+  }
+}

package/src/env.ts

@@ -0,0 +1,5 @@
+export const DISABLE_PROMETHEUS = process.env.DISABLE_PROMETHEUS || false;
+export const LOAD_TEST_ENABLED = process.env.LOAD_TEST_ENABLED === '1';
+export const SEGMENT_IO_WRITE_KEY = process.env.SEGMENT_IO_WRITE_KEY;
+export const SENTRY_DSN = process.env.SENTRY_DSN;
+export const NODE_ENV = process.env.NODE_ENV || 'development';

package/src/interfaces.ts

@@ -0,0 +1,47 @@
+export interface ISubscriptionRoutes {
+  [routeName: string]: IMessageHandler;
+}
+
+export interface IConnectionManager {
+  connect();
+  close();
+  on(event: string, cb: (...args: any[]) => void);
+  send(
+    serviceId: string,
+    method: string,
+    req: Buffer,
+    cb: (error, reply) => void,
+    timeout?: number
+  );
+  sendAsync(
+    serviceId: string,
+    method: string,
+    req: Buffer,
+    cb: (error, reply) => void,
+    timeout?: number
+  );
+  sendBroadcast(messageId: string, req: Buffer, cb: (error, reply) => void);
+  subscribe(serviceId: string, queue: string, routes: ISubscriptionRoutes);
+  subscribeBroadcast(serviceId: string, routes: ISubscriptionRoutes);
+}
+
+export interface ILogManager {
+  info(msg: string, ...params: string[]): void;
+  warn(msg: string, ...params: string[]): void;
+  error(msg: string, ...params: string[]): void;
+}
+
+export interface ILogManagerOpts {
+  serviceName: string;
+}
+
+export interface IMessageHandler {
+  process(req: Buffer): Promise<Buffer>;
+}
+
+export interface IServiceOpts {
+  serviceName: string;
+  connectionMgr: IConnectionManager;
+  logManager: ILogManager;
+  storageManager?: any;
+}

package/src/joiToErrors.ts

@@ -0,0 +1,48 @@
+/*
+ * Converts Joi error objects to a { key, message } type object (pb.Error, Object, etc.)
+ */
+const joiToErrors = (joiErrors, errorClass) => {
+  const errors = joiErrors.details.map(detail => {
+    const key = detail.path[0];
+    const type = detail.type;
+
+    // Note, these messages eventually need to be symbolic, and also localized / translated.
+    // Right now, we're mainly using the English strings returned by the Joi validators.
+    const defaultMessage = detail.message;
+    const message = publicErrorMessage(key, type, defaultMessage);
+
+    return new errorClass({ key, message });
+  }, {});
+
+  return errors;
+};
+
+/*
+ * Override default Joi messages, which aren't always safe to show to our users.
+ */
+const publicErrorMessage = (key, type, defaultMessage) => {
+  let message = defaultMessage;
+
+  switch (type) {
+    case "string.regex.base": {
+      // regex errors echo back the value, which is dangerous for passwords
+      message = `"${key}" does not meet the requirements`;
+    }
+  }
+
+  return message;
+};
+
+/*
+ * Function used for more detailed key info and custom error messages
+ */
+export const joiToErrorMessages = (joiErrors, errorClass) => {
+  const errors = joiErrors.details.map(detail => {
+    const key = detail.context.label;
+    const message = detail.message;
+    return new errorClass({ key, message });
+  }, {});
+  return errors;
+};
+
+export default joiToErrors;

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compileOnSave": true,
+  "compilerOptions": {
+    "baseUrl": ".",
+    "moduleResolution": "node",
+    "target": "es6",
+    "module": "commonjs",
+    "outDir": "./.dist/",
+    "declaration": true,
+    "sourceMap": true,
+    "strictNullChecks": true,
+    "noUnusedLocals": true,
+    "paths": {},
+    "types": [
+      "node",
+      "long"
+    ]
+  },
+  "typeRoots": [
+    "node_modules/@types"
+  ],
+  "include": [
+    "./src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/tslint.json

@@ -0,0 +1,21 @@
+{
+  "extends": "tslint-config-airbnb",
+  "rules": {
+    "max-line-length": {
+      "options": [120]
+    },
+    "no-console": false,
+    "ban": [
+      true,
+      {
+        "name": ["Math", "random"],
+        "message": "Use a better RNG, perhaps UUID?"
+      }
+    ]
+  },
+  "jsRules": {
+    "max-line-length": {
+      "options": [120]
+    }
+  }
+}