feat: medusa-telemetry (#328)

* feat: adds a telemetry package to collect anonymous usage data

* fix: update telemetry host

* fix: adds medusa telemetry --disable

* fix: add tracking of link,login,new

* fix: interactively collect db credentials

* fix: require seed file

* fix: removes tracking from reporter

packages/medusa/src/commands/seed.js

@@ -4,6 +4,7 @@ import express from "express"
 import { createConnection } from "typeorm"
 import { sync as existsSync } from "fs-exists-cached"
 import { getConfigFile } from "medusa-core-utils"
+import { track } from "medusa-telemetry"
 
 import Logger from "../loaders/logger"
 import loaders from "../loaders"
@@ -11,6 +12,7 @@ import loaders from "../loaders"
 import getMigrations from "./utils/get-migrations"
 
 const t = async function({ directory, migrate, seedFile }) {
+  track("CLI_SEED")
   let resolvedPath = seedFile
 
   // If we are already given an absolute path we can skip resolution step
@@ -138,6 +140,8 @@ const t = async function({ directory, migrate, seedFile }) {
       }
     }
   })
+
+  track("CLI_SEED_COMPLETED")
 }
 
 export default t

packages/medusa/src/commands/start.js

@@ -2,12 +2,15 @@ import "core-js/stable"
 import "regenerator-runtime/runtime"
 
 import express from "express"
+import { track } from "medusa-telemetry"
 
 import loaders from "../loaders"
 import Logger from "../loaders/logger"
 
 export default async function({ port, directory }) {
   async function start() {
+    track("CLI_START")
+
     const app = express()
 
     const { dbConnection } = await loaders({ directory, expressApp: app })
@@ -17,6 +20,7 @@ export default async function({ port, directory }) {
         return
       }
       Logger.success(serverActivity, `Server is ready on port: ${port}`)
+      track("CLI_START_COMPLETED")
     })
 
     return { dbConnection, server }

packages/medusa/src/commands/user.js

@@ -6,6 +6,7 @@ import express from "express"
 import loaders from "../loaders"
 
 export default async function({ directory, id, email, password, keepAlive }) {
+  track("CLI_USER", { with_id: !!id })
   const app = express()
   try {
     const { container } = await loaders({
@@ -20,6 +21,8 @@ export default async function({ directory, id, email, password, keepAlive }) {
     process.exit(1)
   }
 
+  track("CLI_USER_COMPLETED", { with_id: !!id })
+
   if (!keepAlive) {
     process.exit()
   }

packages/medusa/src/loaders/index.js

@@ -1,7 +1,9 @@
 import { createContainer, asValue } from "awilix"
 import Redis from "ioredis"
-import { getConfigFile } from "medusa-core-utils"
 import requestIp from "request-ip"
+import { getManager } from "typeorm"
+import { getConfigFile } from "medusa-core-utils"
+import { track } from "medusa-telemetry"
 
 import expressLoader from "./express"
 import databaseLoader from "./database"
@@ -14,7 +16,6 @@ import passportLoader from "./passport"
 import pluginsLoader, { registerPluginModels } from "./plugins"
 import defaultsLoader from "./defaults"
 import Logger from "./logger"
-import { getManager } from "typeorm"
 
 export default async ({ directory: rootDirectory, expressApp }) => {
   const { configModule, configFilePath } = getConfigFile(
@@ -62,53 +63,67 @@ export default async ({ directory: rootDirectory, expressApp }) => {
   })
 
   const modelsActivity = Logger.activity("Initializing models")
-  await modelsLoader({ container, activityId: modelsActivity })
-  Logger.success(modelsActivity, "Models initialized")
+  track("MODELS_INIT_STARTED")
+  modelsLoader({ container, activityId: modelsActivity })
+  const mAct = Logger.success(modelsActivity, "Models initialized") || {}
+  track("MODELS_INIT_COMPLETED", { duration: mAct.duration })
 
   const pmActivity = Logger.activity("Initializing plugin models")
+  track("PLUGIN_MODELS_INIT_STARTED")
   await registerPluginModels({
     rootDirectory,
     container,
     activityId: pmActivity,
   })
-  Logger.success(pmActivity, "Plugin models initialized")
+  const pmAct = Logger.success(pmActivity, "Plugin models initialized") || {}
+  track("PLUGIN_MODELS_INIT_COMPLETED", { duration: pmAct.duration })
 
   const repoActivity = Logger.activity("Initializing repositories")
-  await repositoriesLoader({ container, activityId: repoActivity })
-  Logger.success(repoActivity, "Repositories initialized")
+  track("REPOSITORIES_INIT_STARTED")
+  repositoriesLoader({ container, activityId: repoActivity }) || {}
+  const rAct = Logger.success(repoActivity, "Repositories initialized") || {}
+  track("REPOSITORIES_INIT_COMPLETED", { duration: rAct.duration })
 
   const dbActivity = Logger.activity("Initializing database")
+  track("DATABASE_INIT_STARTED")
   const dbConnection = await databaseLoader({
     container,
     configModule,
     activityId: dbActivity,
   })
-  Logger.success(dbActivity, "Database initialized")
+  const dbAct = Logger.success(dbActivity, "Database initialized") || {}
+  track("DATABASE_INIT_COMPLETED", { duration: dbAct.duration })
 
   container.register({
     manager: asValue(dbConnection.manager),
   })
 
   const servicesActivity = Logger.activity("Initializing services")
-  await servicesLoader({
+  track("SERVICES_INIT_STARTED")
+  servicesLoader({
     container,
     configModule,
     activityId: servicesActivity,
   })
-  Logger.success(servicesActivity, "Services initialized")
+  const servAct = Logger.success(servicesActivity, "Services initialized") || {}
+  track("SERVICES_INIT_COMPLETED", { duration: servAct.duration })
 
   const subActivity = Logger.activity("Initializing subscribers")
-  await subscribersLoader({ container, activityId: subActivity })
-  Logger.success(subActivity, "Subscribers initialized")
+  track("SUBSCRIBERS_INIT_STARTED")
+  subscribersLoader({ container, activityId: subActivity })
+  const subAct = Logger.success(subActivity, "Subscribers initialized") || {}
+  track("SUBSCRIBERS_INIT_COMPLETED", { duration: subAct.duration })
 
   const expActivity = Logger.activity("Initializing express")
+  track("EXPRESS_INIT_STARTED")
   await expressLoader({
     app: expressApp,
     configModule,
     activityId: expActivity,
   })
   await passportLoader({ app: expressApp, container, activityId: expActivity })
-  Logger.success(expActivity, "Express intialized")
+  const exAct = Logger.success(expActivity, "Express intialized") || {}
+  track("EXPRESS_INIT_COMPLETED", { duration: exAct.duration })
 
   // Add the registered services to the request scope
   expressApp.use((req, res, next) => {
@@ -120,26 +135,32 @@ export default async ({ directory: rootDirectory, expressApp }) => {
   })
 
   const pluginsActivity = Logger.activity("Initializing plugins")
+  track("PLUGINS_INIT_STARTED")
   await pluginsLoader({
     container,
     rootDirectory,
     app: expressApp,
     activityId: pluginsActivity,
   })
-  Logger.success(pluginsActivity, "Plugins intialized")
+  const pAct = Logger.success(pluginsActivity, "Plugins intialized") || {}
+  track("PLUGINS_INIT_COMPLETED", { duration: pAct.duration })
 
   const apiActivity = Logger.activity("Initializing API")
+  track("API_INIT_STARTED")
   await apiLoader({
     container,
     rootDirectory,
     app: expressApp,
     activityId: apiActivity,
   })
-  Logger.success(apiActivity, "API initialized")
+  const apiAct = Logger.success(apiActivity, "API initialized") || {}
+  track("API_INIT_COMPLETED", { duration: apiAct.duration })
 
   const defaultsActivity = Logger.activity("Initializing defaults")
+  track("DEFAULTS_INIT_STARTED")
   await defaultsLoader({ container, activityId: defaultsActivity })
-  Logger.success(defaultsActivity, "Defaults initialized")
+  const dAct = Logger.success(defaultsActivity, "Defaults initialized") || {}
+  track("DEFAULTS_INIT_COMPLETED", { duration: dAct.duration })
 
   return { container, dbConnection, app: expressApp }
 }