crashes.js

import Router from 'koa-router';
import moment from 'moment';
import {
  standardDeviation,
  geometricMean,
  mean,
} from 'simple-statistics';
import {
  uniq,
  flatten,
  sumBy,
  zipObject,
  without,
  countBy,
  sortBy,
  toPairs,
  find,
} from 'lodash';
import qs from 'qs';
import { parse as parseVersion } from './meta/version';
import fetchJson from './fetch/json';
import fetchRedash from './fetch/redash';
import { getHistory } from './release/history';

const dateBlacklist = [
  '2016-05-01',
  '2016-05-03',
  '2016-05-04',
  '2016-05-07',
  '2016-05-08',
  '2016-06-03',
  '2016-07-04',
];

export const router = new Router();

const bandwidth = 7;
const weeklyAverage = (result, idx, results) => {
  if (idx < bandwidth) {
    return result;
  }
  const weekRate = results
    .slice(idx - bandwidth, idx + bandwidth).map(past => past.dirty);
  const avg = mean(weekRate);
  result.rate = avg;
  return result;
};

router
  .get('/', async (ctx) => {
    const raw = await fetchRedash(331);
    const reduced = raw.query_result.data.rows
      .map(row => ({
        date: row.activity_date,
        dirty: row.main_crash_rate,
      }))
      .filter(({ date }) => dateBlacklist.indexOf(date) < 0)
      .map(weeklyAverage);
    ctx.body = reduced;
  })

  .get('/beta', async (ctx) => {
    const raw = await fetchRedash(475);
    const results = raw.query_result.data.rows.map(row => ({
      date: row.activity_date,
      rate: row.main_crash_rate,
    }));
    ctx.body = results;
  })

  .get('/xp', async (ctx) => {
    const nonXpRates = await fetchRedash(689);
    const xpRates = await fetchRedash(690);
    const raw = await fetchRedash(331);
    ctx.body = [
      nonXpRates.query_result.data.rows
        .map(row => ({
          date: row.activity_date,
          rate: row.main_crash_rate,
        }))
        .filter(({ date }) => dateBlacklist.indexOf(date) < 0),
      xpRates.query_result.data.rows
        .map(row => ({
          date: row.activity_date,
          rate: row.main_crash_rate,
        }))
        .filter(({ date }) => dateBlacklist.indexOf(date) < 0),
      raw.query_result.data.rows
        .map(row => ({
          date: row.activity_date,
          rate: row.main_crash_rate,
        }))
        .filter(({ rate, date }) => rate > 3 && dateBlacklist.indexOf(date) < 0),
    ];
  })

  .get('/beta/builds', async (ctx) => {
    const history = await getHistory({
      channel: 'beta',
      tailVersion: 5,
    });
    const betaRaw = (await fetchRedash(2856)).query_result.data.rows;
    const builds = betaRaw.reduce((lookup, row) => {
      const buildDate = moment(row.build_id, 'YYYYMMDD');
      const release = find(history, ({ date }) => {
        const diff = moment(date, 'YYYY MM DD').diff(buildDate, 'day');
        return diff >= 0 && diff <= 2;
      });
      const result = {
        date: buildDate.format('YYYY-MM-DD'),
        release: release && release.date,
        candidate: release
          ? parseVersion(release.version).candidate
          : 'rc',
        build: row.build_id,
        version: row.build_version,
        hours: row.usage_kilohours,
        rate: row.main_crash_rate,
        contentRate: row.content_crash_rate,
        dates: [],
      };
      lookup.push(result);
      return lookup;
    }, []);

    const releases = builds.reduce((lookup, result) => {
      let entry = find(lookup, ({ version }) => version === result.version);
      if (!entry) {
        entry = {
          version: result.version,
          builds: [],
        };
        lookup.push(entry);
      }
      entry.builds.push(result);
      return lookup;
    }, []);
    releases.forEach((release) => {
      release.hours = sumBy(release.builds, 'hours');
      const rates = release.builds
        .map(({ rate }) => rate)
        .filter(rate => rate > 0);
      const contentRates = release.builds
        .map(({ contentRate }) => contentRate)
        .filter(contentRate => contentRate > 0);
      release.rate = rates.length > 0 ? geometricMean(rates) : 0;
      release.variance = rates.length > 0 ? standardDeviation(rates) : 0;
      release.contentRate = contentRates.length > 0 ? geometricMean(contentRates) : 0;
    });
    ctx.body = releases;
  });