serverless/lib/utils/analytics/generatePayload.js

'use strict';

const path = require('path');
const isStandalone = require('../isStandaloneExecutable');
const { triggeredDeprecations } = require('../logDeprecation');

const versions = {
  'serverless': require('../../../package').version,
  '@serverless/enterprise-plugin': require('@serverless/enterprise-plugin/package').version,
};

module.exports = serverless => {
  const { service: serviceConfig, config } = serverless;
  const { provider: providerConfig } = serviceConfig;
  const provider = serverless.getProvider(providerConfig.name);

  const isAwsProvider = providerConfig.name === 'aws';

  const defaultRuntime = isAwsProvider ? provider.getRuntime() : providerConfig.runtime;

  const npmDependencies = (() => {
    if (!config.servicePath) return [];
    const pkgJson = (() => {
      try {
        return require(path.resolve(config.servicePath, 'package.json'));
      } catch (error) {
        return null;
      }
    })();
    if (!pkgJson) return [];
    return Array.from(
      new Set([
        ...Object.keys(pkgJson.dependencies || {}),
        ...Object.keys(pkgJson.optionalDependencies || {}),
        ...Object.keys(pkgJson.devDependencies || {}),
      ])
    );
  })();

  return {
    cliName: 'serverless',
    config: {
      provider: {
        name: providerConfig.name,
        runtime: defaultRuntime,
        stage: isAwsProvider ? provider.getStage() : providerConfig.stage,
        region: isAwsProvider ? provider.getRegion() : providerConfig.region,
      },
      plugins: serviceConfig.plugins ? serviceConfig.plugins.modules || serviceConfig.plugins : [],
      functions: Object.values(serviceConfig.functions).map(functionConfig => ({
        runtime: functionConfig.runtime || defaultRuntime,
        events: functionConfig.events.map(eventConfig => ({
          type: Object.keys(eventConfig)[0] || null,
        })),
      })),
    },
    npmDependencies,
    triggeredDeprecations: Array.from(triggeredDeprecations),
    versions,
    installationType: (() => {
      if (isStandalone) return 'global:standalone';
      if (!serverless.isLocallyInstalled) return 'global:npm';
      if (serverless.isInvokedByGlobalInstallation) return 'local:fallback';
      return 'local:direct';
    })(),
    isDashboardEnabled: Boolean(serverless.enterpriseEnabled),
  };
};