insomnia/packages/insomnia-app/app/common/analytics.js

// @flow
import { buildQueryStringFromParams, joinUrlAndQueryString } from 'insomnia-url';
import * as electron from 'electron';
import * as models from '../models/index';
import * as db from '../common/database';
import uuid from 'uuid';
import {
  getAppId,
  getAppName,
  getAppPlatform,
  getAppVersion,
  getGoogleAnalyticsId,
  getGoogleAnalyticsLocation,
  isDevelopment,
} from './constants';
import type { RequestParameter } from '../models/request';
import { getScreenResolution, getUserLanguage, getViewportSize } from './misc';

const DIMENSION_PLATFORM = 1;
const DIMENSION_VERSION = 2;

const KEY_TRACKING_ID = 'tid';
const KEY_VERSION = 'v';
const KEY_CLIENT_ID = 'cid';
const KEY_HIT_TYPE = 't';
const KEY_LOCATION = 'dl';
const KEY_TITLE = 'dt';
const KEY_NON_INTERACTION = 'ni';
const KEY_VIEWPORT_SIZE = 'vp';
const KEY_SCREEN_RESOLUTION = 'sr';
const KEY_USER_LANGUAGE = 'ul';
const KEY_USER_AGENT = 'ua';
const KEY_DOCUMENT_ENCODING = 'de';
const KEY_EVENT_CATEGORY = 'ec';
const KEY_EVENT_ACTION = 'ea';
const KEY_EVENT_LABEL = 'el';
const KEY_EVENT_VALUE = 'ev';
const KEY_ANONYMIZE_IP = 'aip';
const KEY_APPLICATION_NAME = 'an';
const KEY_APPLICATION_ID = 'aid';
const KEY_APPLICATION_VERSION = 'av';

const KEY_CUSTOM_DIMENSION_PREFIX = 'cd';

let _currentLocationPath = '/';

export function trackEvent(category: string, action: string, label: ?string, value: ?string) {
  process.nextTick(async () => {
    await _trackEvent(true, category, action, label, value);
  });
}

export function trackNonInteractiveEvent(
  category: string,
  action: string,
  label: ?string,
  value: ?string,
) {
  process.nextTick(async () => {
    await _trackEvent(false, category, action, label, value, false);
  });
}

/**
 * Tracks an analytics event but queues it for later if analytics are
 * currently disabled. Once analytics setting is enabled, any queued
 * events will be sent automatically.
 *
 * This should be used sparingly!
 *
 * @param category
 * @param action
 * @param label
 * @param value
 */
export function trackNonInteractiveEventQueueable(
  category: string,
  action: string,
  label: ?string,
  value: ?string,
) {
  process.nextTick(async () => {
    await _trackEvent(false, category, action, label, value, true);
  });
}

export function trackPageView(path: string) {
  process.nextTick(async () => {
    await _trackPageView(path);
  });
}

// ~~~~~~~~~~~~~~~~~ //
// Private Functions //
// ~~~~~~~~~~~~~~~~~ //

// Exported for testing
export async function _trackEvent(
  interactive: boolean,
  category: string,
  action: string,
  label: ?string,
  value: ?string,
  queuable: ?boolean,
) {
  const prefix = interactive ? '[ga] Event' : '[ga] Non-interactive';
  console.log(prefix, [category, action, label, value].filter(Boolean).join(', '));

  const params = [
    { name: KEY_HIT_TYPE, value: 'event' },
    { name: KEY_EVENT_CATEGORY, value: category },
    { name: KEY_EVENT_ACTION, value: action },
  ];

  !interactive && params.push({ name: KEY_NON_INTERACTION, value: '1' });
  label && params.push({ name: KEY_EVENT_LABEL, value: label });
  value && params.push({ name: KEY_EVENT_VALUE, value: value });

  await _sendToGoogle(params, !!queuable);
}

export async function _trackPageView(location: string) {
  _currentLocationPath = location;
  console.log('[ga] Page', _currentLocationPath);

  const params = [{ name: KEY_HIT_TYPE, value: 'pageview' }];

  await _sendToGoogle(params, false);
}

async function _getDefaultParams(): Promise<Array<RequestParameter>> {
  const settings = await models.settings.getOrCreate();

  // Migrate old GA ID into settings model
  let { deviceId } = settings;
  if (!deviceId) {
    const oldId = (window && window.localStorage.gaClientId) || null;
    deviceId = oldId || uuid.v4();
    await models.settings.update(settings, { deviceId });
  }

  // Prepping user agent string prior to sending to GA due to Electron base UA not being GA friendly.
  const ua = String(window.navigator.userAgent)
    .replace(new RegExp(`${getAppId()}\\/\\d+\\.\\d+\\.\\d+ `), '')
    .replace(/Electron\/\d+\.\d+\.\d+ /, '');

  const params = [
    { name: KEY_VERSION, value: '1' },
    { name: KEY_TRACKING_ID, value: getGoogleAnalyticsId() },
    { name: KEY_CLIENT_ID, value: deviceId },
    { name: KEY_USER_AGENT, value: ua },
    { name: KEY_LOCATION, value: getGoogleAnalyticsLocation() + _currentLocationPath },
    { name: KEY_SCREEN_RESOLUTION, value: getScreenResolution() },
    { name: KEY_USER_LANGUAGE, value: getUserLanguage() },
    { name: KEY_TITLE, value: `${getAppId()}:${getAppVersion()}` },
    { name: KEY_CUSTOM_DIMENSION_PREFIX + DIMENSION_PLATFORM, value: getAppPlatform() },
    { name: KEY_CUSTOM_DIMENSION_PREFIX + DIMENSION_VERSION, value: getAppVersion() },
    { name: KEY_ANONYMIZE_IP, value: '1' },
    { name: KEY_APPLICATION_NAME, value: getAppName() },
    { name: KEY_APPLICATION_ID, value: getAppId() },
    { name: KEY_APPLICATION_VERSION, value: getAppVersion() },
  ];

  const viewport = getViewportSize();
  viewport && params.push({ name: KEY_VIEWPORT_SIZE, value: viewport });

  global.document &&
  params.push({
    name: KEY_DOCUMENT_ENCODING,
    value: global.document.inputEncoding,
  });

  return params;
}

// Monitor database changes to see if analytics gets enabled. If analytics
// become enabled, flush any queued events.
db.onChange(async changes => {
  for (const change of changes) {
    const [event, doc] = change;
    if (doc.type === models.settings.type && event === 'update') {
      if (doc.enableAnalytics) {
        await _flushQueuedEvents();
      }
    }
  }
});

async function _sendToGoogle(params: Array<RequestParameter>, queueable: boolean) {
  const settings = await models.settings.getOrCreate();
  if (!settings.enableAnalytics) {
    if (queueable) {
      console.log('[ga] Queued event', params);
      _queuedEvents.push(params);
    }
    return;
  }

  const baseParams = await _getDefaultParams();
  const allParams = [...baseParams, ...params];
  const qs = buildQueryStringFromParams(allParams);
  const baseUrl = isDevelopment()
    ? 'https://www.google-analytics.com/debug/collect'
    : 'https://www.google-analytics.com/collect';
  const url = joinUrlAndQueryString(baseUrl, qs);

  const net = (electron.remote || electron).net;
  const request = net.request(url);

  request.once('error', err => {
    console.warn('[ga] Network error', err);
  });

  request.once('response', response => {
    const { statusCode } = response;
    if (statusCode < 200 && statusCode >= 300) {
      console.warn('[ga] Bad status code ' + statusCode);
    }

    const chunks = [];
    const [contentType] = response.headers['content-type'] || [];

    if (contentType !== 'application/json') {
      // Production GA API returns a Gif to use for tracking
      return;
    }

    response.on('end', () => {
      const jsonStr = Buffer.concat(chunks).toString('utf8');
      try {
        const data = JSON.parse(jsonStr);
        const { hitParsingResult } = data;
        if (hitParsingResult.valid) {
          return;
        }

        for (const result of hitParsingResult || []) {
          for (const msg of result.parserMessage || []) {
            console.warn(`[ga] Error ${msg.description}`);
          }
        }
      } catch (err) {
        console.warn('[ga] Failed to parse response', err);
      }
    });

    response.on('data', chunk => {
      chunks.push(chunk);
    });
  });

  request.end();
}

/**
 * Flush any analytics events that were built up when analytics
 * were disabled.
 * @returns {Promise<void>}
 * @private
 */
let _queuedEvents = [];

async function _flushQueuedEvents() {
  console.log(`[ga] Flushing ${_queuedEvents.length} queued events`);

  const tmp = [..._queuedEvents];

  // Clear queue before we even start sending to prevent races
  _queuedEvents = [];

  for (const params of tmp) {
    console.log('[ga] Flushing queued event', params);
    await _sendToGoogle(params, false);
  }
}