@jambonz/time-series 0.1.12 → 0.2.1

package/index.js

@@ -11,9 +11,12 @@ const AlertType = {
   TTS_FAILURE: 'tts-failure',
   STT_FAILURE: 'stt-failure',
   CARRIER_NOT_PROVISIONED: 'no-carrier',
-  CALL_LIMIT: 'call-limit',
-  DEVICE_LIMIT: 'device-limit',
-  API_LIMIT: 'api-limit',
+  ACCOUNT_CALL_LIMIT: 'account-call-limit',
+  ACCOUNT_DEVICE_LIMIT: 'account-device-limit',
+  ACCOUNT_API_LIMIT: 'account-api-limit',
+  SP_CALL_LIMIT: 'service-provider-call-limit',
+  SP_DEVICE_LIMIT: 'service-provider-device-limit',
+  SP_API_LIMIT: 'service-provider-api-limit',
   ACCOUNT_INACTIVE: 'account is inactive or suspended'
 };
 
@@ -33,6 +36,7 @@ const schemas = {
       trace_id: Influx.FieldType.STRING
     },
     tags: [
+      'service_provider_sid',
       'account_sid',
       'host',
       'trunk',
@@ -47,6 +51,7 @@ const schemas = {
       detail: Influx.FieldType.STRING,
     },
     tags: [
+      'service_provider_sid',
       'account_sid',
       'alert_type'
     ]
@@ -57,8 +62,18 @@ const schemas = {
       calls_in_progress: Influx.FieldType.INTEGER,
     },
     tags: [
+      'service_provider_sid',
       'account_sid'
     ]
+  },
+  sp_call_counts: {
+    measurement: 'sp_call_counts',
+    fields: {
+      calls_in_progress: Influx.FieldType.INTEGER,
+    },
+    tags: [
+      'service_provider_sid'
+    ]
   }
 };
 
@@ -80,6 +95,31 @@ const writeData = async(client) => {
   }
 };
 
+/* for Service Provider */
+const createCallCountsQuerySP = ({page, page_size, days, start, end}) => {
+  let sql = 'SELECT * from sp_call_counts WHERE service_provider_sid = $service_provider_sid ';
+  if (days) sql += 'AND time > $timestamp ';
+  else {
+    if (start) sql += 'AND time >= $start ';
+    if (end) sql += 'AND time <= $end ';
+  }
+  sql += ' ORDER BY time DESC';
+  if (page_size) sql += ' LIMIT $page_size';
+  if (page) sql += ' OFFSET $offset';
+  return sql;
+};
+
+const createCallCountsCountQuerySP = ({days, start, end}) => {
+  let sql = 'SELECT COUNT(calls_in_progress) from sp_call_counts WHERE service_provider_sid = $service_provider_sid ';
+  if (days) sql += 'AND time > $timestamp ';
+  else {
+    if (start) sql += 'AND time >= $start ';
+    if (end) sql += 'AND time <= $end ';
+  }
+  return sql;
+};
+
+/* for Account */
 const createCallCountsQuery = ({page, page_size, days, start, end}) => {
   let sql = 'SELECT * from call_counts WHERE account_sid = $account_sid ';
   if (days) sql += 'AND time > $timestamp ';
@@ -103,6 +143,36 @@ const createCallCountsCountQuery = ({days, start, end}) => {
   return sql;
 };
 
+/* for Service Provider */
+const createCdrQuerySP = ({page, page_size, trunk, direction, answered, days, start, end}) => {
+  let sql = 'SELECT * from cdrs WHERE service_provider_sid = $service_provider_sid ';
+  if (trunk) sql += 'AND trunk = $trunk ';
+  if (direction) sql += 'AND direction = $direction ';
+  if (['true', 'false'].includes(answered)) sql += 'AND answered = $answered ';
+  if (days) sql += 'AND time > $timestamp ';
+  else {
+    if (start) sql += 'AND time >= $start ';
+    if (end) sql += 'AND time <= $end ';
+  }
+  sql += ' ORDER BY time DESC';
+  if (page_size) sql += ' LIMIT $page_size';
+  if (page) sql += ' OFFSET $offset';
+  return sql;
+};
+const createCdrCountQuerySP = ({trunk, direction, answered, days, start, end}) => {
+  let sql = 'SELECT COUNT(sip_callid) from cdrs WHERE service_provider_sid = $service_provider_sid ';
+  if (trunk) sql += 'AND trunk = $trunk ';
+  if (direction) sql += 'AND direction = $direction ';
+  if (['true', 'false'].includes(answered)) sql += 'AND answered = $answered ';
+  if (days) sql += 'AND time > $timestamp ';
+  else {
+    if (start) sql += 'AND time >= $start ';
+    if (end) sql += 'AND time <= $end ';
+  }
+  return sql;
+};
+
+/* for Account */
 const createCdrQuery = ({page, page_size, trunk, direction, answered, days, start, end}) => {
   let sql = 'SELECT * from cdrs WHERE account_sid = $account_sid ';
   if (trunk) sql += 'AND trunk = $trunk ';
@@ -131,6 +201,36 @@ const createCdrCountQuery = ({trunk, direction, answered, days, start, end}) =>
   return sql;
 };
 
+/* for Service Provider */
+const createAlertsQuerySP = ({target_sid, alert_type, page, page_size, days, start, end}) => {
+  // eslint-disable-next-line max-len
+  let sql = 'SELECT service_provider_sid, message, detail FROM alerts WHERE service_provider_sid = $service_provider_sid ';
+  if (target_sid) sql += 'AND target_sid = $target_sid ';
+  if (alert_type) sql += 'AND alert_type = $alert_type ';
+  if (days) sql += 'AND time > $timestamp ';
+  else {
+    if (start) sql += 'AND time >= $start ';
+    if (end) sql += 'AND time <= $end ';
+  }
+  sql += ' ORDER BY time DESC';
+  if (page_size) sql += ' LIMIT $page_size';
+  if (page) sql += ' OFFSET $offset';
+  return sql;
+};
+
+const createAlertsCountQuerySP = ({target_sid, alert_type, days, start, end}) => {
+  let sql = 'SELECT COUNT(message) FROM alerts WHERE service_provider_sid = $service_provider_sid ';
+  if (target_sid) sql += 'AND target_sid = $target_sid ';
+  if (alert_type) sql += 'AND alert_type = $alert_type ';
+  if (days) sql += 'AND time > $timestamp ';
+  else {
+    if (start) sql += 'AND time >= $start ';
+    if (end) sql += 'AND time <= $end ';
+  }
+  return sql;
+};
+
+/* for Account */
 const createAlertsQuery = ({target_sid, alert_type, page, page_size, days, start, end}) => {
   let sql = 'SELECT * FROM alerts WHERE account_sid = $account_sid ';
   if (target_sid) sql += 'AND target_sid = $target_sid ';
@@ -168,11 +268,12 @@ const initDatabase = async(client, dbName) => {
 
 const writeCallCount = async(client, count) => {
   if (!client.locals.initialized) await initDatabase(client, 'call_counts');
-  const {account_sid, ...fields} = count;
+  const {service_provider_sid, account_sid, ...fields} = count;
   const data = {
     measurement: 'call_counts',
     fields,
     tags: {
+      service_provider_sid,
       account_sid
     }
   };
@@ -183,6 +284,58 @@ const writeCallCount = async(client, count) => {
   return;
 };
 
+const writeCallCountSP = async(client, count) => {
+  if (!client.locals.initialized) await initDatabase(client, 'sp_call_counts');
+  const {service_provider_sid, ...fields} = count;
+  const data = {
+    measurement: 'sp_call_counts',
+    fields,
+    tags: {
+      service_provider_sid
+    }
+  };
+  client.locals.data = [...client.locals.data, ...[data]];
+  if (client.locals.data.length >= client.locals.commitSize) {
+    await writeData(client);
+  }
+  return;
+};
+
+const queryCallCountsSP = async(client, opts) => {
+  if (!client.locals.initialized) await initDatabase(client, 'sp_call_counts');
+  const response = {
+    total: 0,
+    page_size: opts.page_size,
+    page: opts.page,
+    data: []
+  };
+  const params = generateBindParameters(opts);
+  const sqlTotal = createCallCountsCountQuerySP(opts);
+  const obj = await client.queryRaw(sqlTotal, { placeholders: params});
+  //console.log(`sqlTotal: ${sqlTotal}, results: ${JSON.stringify(obj)}`);
+  if (!obj.results || !obj.results[0].series) return response;
+  response.total = obj.results[0].series[0].values[0][1];
+
+  const sql = createCallCountsQuerySP(opts);
+  const res = await client.queryRaw(sql, { placeholders: params});
+  //console.log(`sql: ${sqlTotal}, results: ${JSON.stringify(res)}`);
+  if (res.results[0].series && res.results[0].series.length) {
+    const {columns, values} = res.results[0].series[0];
+    const data = values.map((v) => {
+      const obj = {};
+      v.forEach((val, idx) => {
+        v.forEach((val, idx) => {
+          const key = columns[idx];
+          obj[key] = val;
+        });
+      });
+      return obj;
+    });
+    response.data = data;
+  }
+  return response;
+};
+
 const queryCallCounts = async(client, opts) => {
   if (!client.locals.initialized) await initDatabase(client, 'call_counts');
   const response = {
@@ -222,7 +375,7 @@ const writeCdrs = async(client, cdrs) => {
   if (!client.locals.initialized) await initDatabase(client, 'cdrs');
   cdrs = (Array.isArray(cdrs) ? cdrs : [cdrs])
     .map((cdr) => {
-      const {direction, host, trunk, account_sid, answered, attempted_at, ...fields} = cdr;
+      const {direction, host, trunk, service_provider_sid, account_sid, answered, attempted_at, ...fields} = cdr;
       return {
         measurement: 'cdrs',
         timestamp: new Date(attempted_at),
@@ -231,6 +384,7 @@ const writeCdrs = async(client, cdrs) => {
           direction,
           host,
           trunk,
+          service_provider_sid,
           account_sid,
           answered
         }
@@ -244,6 +398,41 @@ const writeCdrs = async(client, cdrs) => {
   return;
 };
 
+const queryCdrsSP = async(client, opts) => {
+  if (!client.locals.initialized) await initDatabase(client, 'cdrs');
+  const response = {
+    total: 0,
+    page_size: opts.page_size,
+    page: opts.page,
+    data: []
+  };
+  const params = generateBindParameters(opts);
+  const sqlTotal = createCdrCountQuerySP(opts);
+  const obj = await client.queryRaw(sqlTotal, { placeholders: params});
+  //console.log(`sql: ${sqlTotal}, results: ${JSON.stringify(obj)}`);
+  if (!obj.results || !obj.results[0].series) return response;
+  response.total = obj.results[0].series[0].values[0][1];
+
+  const sql = createCdrQuerySP(opts);
+  const res = await client.queryRaw(sql, { placeholders: params});
+  if (res.results[0].series && res.results[0].series.length) {
+    const {columns, values} = res.results[0].series[0];
+    const data = values.map((v) => {
+      const obj = {};
+      v.forEach((val, idx) => {
+        const key = 'time' === columns[idx] ? 'attempted_at' : columns[idx];
+        let retvalue = val;
+        if (['answered_at', 'terminated_at'].includes(key)) retvalue = new Date(val);
+        if (key === 'answered') retvalue = 'true' === val ? true : false;
+        obj[key] = retvalue;
+      });
+      return obj;
+    });
+    response.data = data;
+  }
+  return response;
+};
+
 const queryCdrs = async(client, opts) => {
   if (!client.locals.initialized) await initDatabase(client, 'cdrs');
   const response = {
@@ -283,7 +472,18 @@ const writeAlerts = async(client, alerts) => {
   if (!client.locals.initialized) await initDatabase(client, 'alerts');
   alerts = (Array.isArray(alerts) ? alerts : [alerts])
     .map((alert) => {
-      const {alert_type, account_sid, target_sid, url, status, vendor, count, detail, timestamp} = alert;
+      const {
+        alert_type,
+        service_provider_sid,
+        account_sid,
+        target_sid,
+        url,
+        status,
+        vendor,
+        count,
+        detail,
+        timestamp
+      } = alert;
       let message = alert.message;
       if (!message) {
         switch (alert_type) {
@@ -317,15 +517,29 @@ const writeAlerts = async(client, alerts) => {
           case AlertType.CARRIER_NOT_PROVISIONED:
             message = 'outbound call failure: no carriers have been provisioned';
             break;
-          case AlertType.CALL_LIMIT:
-            message = `you have exceeded your provisioned call limit of ${count}; please consider upgrading your plan`;
+          case AlertType.ACCOUNT_CALL_LIMIT:
+            message = `you have exceeded your account call limit of ${count}; please consider upgrading your plan`;
+            break;
+          case AlertType.ACCOUNT_DEVICE_LIMIT:
+            message =
+              // eslint-disable-next-line max-len
+              `you have exceeded your account limit of ${count} registered devices; please consider upgrading your plan`;
+            break;
+          case AlertType.ACCOUNT_API_LIMIT:
+            message = `you have exceeded your account api limit of ${count}; please consider upgrading your plan`;
+            break;
+          case AlertType.SP_CALL_LIMIT:
+            // eslint-disable-next-line max-len
+            message = `you have exceeded your service provider call limit of ${count}; please consider upgrading your plan`;
             break;
-          case AlertType.DEVICE_LIMIT:
+          case AlertType.SP_DEVICE_LIMIT:
             message =
-              `you have exceeded your device registration limit of ${count}; please consider upgrading your plan`;
+              // eslint-disable-next-line max-len
+              `you have exceeded your service provider limit of ${count} registered devices; please consider upgrading your plan`;
             break;
-          case AlertType.API_LIMIT:
-            message = `you have exceeded your api limit of ${count}; please consider upgrading your plan`;
+          case AlertType.SP_API_LIMIT:
+            // eslint-disable-next-line max-len
+            message = `you have exceeded your service provider api limit of ${count}; please consider upgrading your plan`;
             break;
           default:
             break;
@@ -333,7 +547,7 @@ const writeAlerts = async(client, alerts) => {
       }
       let fields =  { message };
       if (target_sid) fields = Object.assign(fields, {target_sid});
-      const obj = {measurement: 'alerts', fields: fields, tags: { alert_type, account_sid }};
+      const obj = {measurement: 'alerts', fields: fields, tags: { alert_type, service_provider_sid, account_sid }};
       if (timestamp) obj.timestamp = timestamp;
       if (detail) obj.fields.detail = detail;
       return obj;
@@ -354,6 +568,38 @@ const generateBindParameters = (opts) => {
   return params;
 };
 
+const queryAlertsSP = async(client, opts) => {
+  if (!client.locals.initialized) await initDatabase(client, 'alerts');
+  const response = {
+    total: 0,
+    page_size: opts.page_size,
+    page: opts.page,
+    data: []
+  };
+  const params = generateBindParameters(opts);
+  const sqlTotal = createAlertsCountQuerySP(opts);
+  const obj = await client.queryRaw(sqlTotal, { placeholders: params});
+  //console.log(`query total alerts: ${sqlTotal}: ${JSON.stringify(obj)}`);
+  if (!obj.results || !obj.results[0].series) return response;
+  response.total = obj.results[0].series[0].values[0][1];
+
+  const sql = createAlertsQuerySP(opts);
+  const res = await client.queryRaw(sql, { placeholders: params});
+  if (res.results[0].series && res.results[0].series.length) {
+    const {columns, values} = res.results[0].series[0];
+    const data = values.map((v) => {
+      const obj = {};
+      v.forEach((val, idx) => {
+        const key = columns[idx];
+        obj[key] = val;
+      });
+      return obj;
+    });
+    response.data = data;
+  }
+  return response;
+};
+
 const queryAlerts = async(client, opts) => {
   if (!client.locals.initialized) await initDatabase(client, 'alerts');
   const response = {
@@ -393,6 +639,7 @@ module.exports = (logger, opts) => {
   const cdrClient = new Influx.InfluxDB({database: 'cdrs', schemas: schemas.cdr, ...opts});
   const alertClient = new Influx.InfluxDB({database: 'alerts', schemas: schemas.alerts, ...opts});
   const callCountClient = new Influx.InfluxDB({database: 'call_counts', schemas: schemas.call_counts, ...opts});
+  const callCountSPClient = new Influx.InfluxDB({database: 'sp_call_counts', schemas: schemas.sp_call_counts, ...opts});
 
   cdrClient.locals = {
     db: 'cdrs',
@@ -410,6 +657,14 @@ module.exports = (logger, opts) => {
     commitInterval: opts.commitInterval || 10,
     data: []
   };
+  callCountSPClient.locals = {
+    db: 'sp_call_counts',
+    initialized: false,
+    writing: false,
+    commitSize: opts.commitSize || 1,
+    commitInterval: opts.commitInterval || 10,
+    data: []
+  };
   callCountClient.locals = {
     db: 'call_counts',
     initialized: false,
@@ -427,11 +682,15 @@ module.exports = (logger, opts) => {
 
   return {
     writeCallCount: writeCallCount.bind(null, callCountClient),
+    writeCallCountSP: writeCallCountSP.bind(null, callCountSPClient),
     queryCallCounts: queryCallCounts.bind(null, callCountClient),
+    queryCallCountsSP: queryCallCountsSP.bind(null, callCountSPClient),
     writeCdrs: writeCdrs.bind(null, cdrClient),
+    queryCdrsSP: queryCdrsSP.bind(null, cdrClient),
     queryCdrs: queryCdrs.bind(null, cdrClient),
     writeAlerts: writeAlerts.bind(null, alertClient),
     queryAlerts: queryAlerts.bind(null, alertClient),
+    queryAlertsSP: queryAlertsSP.bind(null, alertClient),
     AlertType: { ...AlertType }
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jambonz/time-series",
-  "version": "0.1.12",
+  "version": "0.2.1",
   "description": "write and query data to time series daetabase",
   "main": "index.js",
   "scripts": {

package/test/unit-tests.js

@@ -4,11 +4,15 @@ const consoleLogger = {error: console.error, info: console.log, debug: console.l
 
 const {
   writeCallCount,
+  writeCallCountSP,
   queryCallCounts,
+  queryCallCountsSP,
   writeCdrs,
   queryCdrs,
+  queryCdrsSP,
   writeAlerts,
   queryAlerts,
+  queryAlertsSP,
   AlertType
 } = require('..')(consoleLogger, '127.0.0.1', {commitSize: 1});
 
@@ -27,6 +31,7 @@ test('write timeseries data', async(t) => {
     host: '10.10.100.1',
     remote_host: '10.10.100.8',
     trunk: 'device',
+    service_provider_sid: 'zzzzz',
     account_sid: 'xxxx',
     call_sid: 'foo'
   },
@@ -44,6 +49,7 @@ test('write timeseries data', async(t) => {
     host: '10.10.100.1',
     remote_host: '10.10.100.8',
     trunk: 'twilio',
+    service_provider_sid: 'zzzzz',
     account_sid: 'yyyy',
     call_sid: 'bar'
   }]);
@@ -51,72 +57,102 @@ test('write timeseries data', async(t) => {
 
   result = await queryCdrs({account_sid: 'xxxx', page: 1, page_size:25});
   //npm tesconsole.log(JSON.stringify(result));
-  t.ok(result.data.length === 1, 'queried cdrs')
+  t.ok(result.data.length === 1, 'queried cdrs by account sid')
 
   result = await queryCdrs({account_sid: 'yyyy', trunk: 'twilio', page: 1, page_size:25});
   t.ok(result.data.length === 1, 'queried cdrs by trunk')
 
+  result = await queryCdrsSP({service_provider_sid: 'zzzzz', page: 1, page_size:25});
+  t.ok(result.data.length === 2, 'queried cdrs by service provider sid')
+
   result = await writeAlerts([
     {
       alert_type: AlertType.WEBHOOK_STATUS_FAILURE,
+      service_provider_sid: 'zzzzz',
       account_sid: 'yyyy',
       url: 'http://foo.bar',
       status: 404
     },
     {
       alert_type: AlertType.WEBHOOK_CONNECTION_FAILURE,
+      service_provider_sid: 'zzzzz',
       account_sid: 'yyyy',
       url: 'http://foo.bar'
     },
     {
       alert_type: AlertType.WEBHOOK_AUTH_FAILURE,
+      service_provider_sid: 'zzzzz',
       account_sid: 'yyyy',
       url: 'http://foo.bar'
     },
     {
       alert_type: AlertType.INVALID_APP_PAYLOAD,
+      service_provider_sid: 'zzzzz',
       account_sid: 'yyyy',
       target_sid: 'zzzz',
       message: 'invalid app payload'
     },
     {
       alert_type: AlertType.TTS_NOT_PROVISIONED,
+      service_provider_sid: 'zzzzz',
       account_sid: 'yyyy',
       vendor: 'google'
     },
     {
       alert_type: AlertType.STT_NOT_PROVISIONED,
+      service_provider_sid: 'zzzzz',
       account_sid: 'yyyy',
       vendor: 'google'
     },
     {
       alert_type: AlertType.TTS_FAILURE,
+      service_provider_sid: 'zzzzz',
       account_sid: 'yyyy',
       vendor: 'google'
     },
     {
       alert_type: AlertType.STT_FAILURE,
+      service_provider_sid: 'zzzzz',
       account_sid: 'yyyy',
       vendor: 'google'
     },
     {
       alert_type: AlertType.CARRIER_NOT_PROVISIONED,
+      service_provider_sid: 'zzzzz',
       account_sid: 'yyyy',
     },
     {
-      alert_type: AlertType.CALL_LIMIT,
+      alert_type: AlertType.SP_CALL_LIMIT,
+      service_provider_sid: 'zzzzz',
+      count: 50,
+    },
+    {
+      alert_type: AlertType.ACCOUNT_CALL_LIMIT,
+      service_provider_sid: 'zzzzz',
       account_sid: 'yyyy',
       count: 50,
     },
     {
-      alert_type: AlertType.DEVICE_LIMIT,
+      alert_type: AlertType.SP_DEVICE_LIMIT,
+      service_provider_sid: 'zzzzz',
+      count: 500,
+    },
+    {
+      alert_type: AlertType.ACCOUNT_DEVICE_LIMIT,
+      service_provider_sid: 'zzzzz',
       account_sid: 'yyyy',
       count: 250,
     },
     {
-      alert_type: AlertType.API_LIMIT,
+      alert_type: AlertType.ACCOUNT_API_LIMIT,
+      service_provider_sid: 'zzzzz',
       account_sid: 'yyyy',
       count: 120,
+    },
+    {
+      alert_type: AlertType.SP_API_LIMIT,
+      service_provider_sid: 'zzzzz',
+      count: 300,
     }
   ]);
   t.pass('wrote alerts');
@@ -137,20 +173,41 @@ test('write timeseries data', async(t) => {
   t.ok(result.data.length === 1, 'queried alerts by target_sid');
   t.ok(result.data[0].target_sid === 'zzzz')
 
+  result = await queryAlertsSP({service_provider_sid: 'zzzzz', page: 1, page_size: 25, days: 7});
+  //console.log(result);
+  t.ok(result.data.length === 15, 'queried alerts by service_provider_sid');
+
   result = await writeCallCount(
     {
       calls_in_progress: 49,
+      service_provider_sid: 'zzzzz',
       account_sid: 'yyyy'
     });
   result = await writeCallCount(
     {
       calls_in_progress: 50,
+      service_provider_sid: 'zzzzz',
       account_sid: 'yyyy'
     });
-  t.pass('wrote call counts');
+  t.pass('wrote call counts for account');
 
-  result = await queryCallCounts({account_sid: 'yyyy', page: 1, page_size: 25, days: 7});
+  result = await writeCallCountSP(
+    {
+      calls_in_progress: 500,
+      service_provider_sid: 'zzzzz'
+    });
+  result = await writeCallCountSP(
+    {
+      calls_in_progress: 501,
+      service_provider_sid: 'zzzzz'
+    });
+  t.pass('wrote call counts for service provider');
+
+  result = await queryCallCountsSP({service_provider_sid: 'zzzzz', page: 1, page_size: 25, days: 7});
   //console.log(JSON.stringify(result));
-  t.ok(result.data.length === 2, 'queried call counts');
+  t.ok(result.data.length === 2, 'queried call counts by service provider sid');
 
+  result = await queryCallCounts({account_sid: 'yyyy', page: 1, page_size: 25, days: 7});
+  //console.log(JSON.stringify(result));
+  t.ok(result.data.length === 2, 'queried call counts by account_sid');
 });