@learnpack/learnpack 5.0.32 → 5.0.33

package/src/managers/server/routes.ts

@@ -58,7 +58,7 @@ export default async function (
 
   // Added this line to parse the json body
 
-  const jsonBodyParser = bodyParser.json()
+  const jsonBodyParser = bodyParser.json({ limit: "10mb" })
   // Trying to log in from frontend
   app.post(
     "/login",
@@ -172,10 +172,15 @@ export default async function (
     })
   )
 
-  app.get("/telemetry/step/:stepPosition", (req, res) => {
-    const stepPosition = parseInt(req.params.stepPosition)
-    const step = TelemetryManager.getStep(stepPosition)
-    res.json(step)
+  app.get("/telemetry", async (req, res) => {
+    const telemetry = await TelemetryManager.retrieve()
+    res.json(telemetry)
+  })
+
+  app.post("/telemetry", jsonBodyParser, async (req, res) => {
+    const telemetry = req.body
+    await TelemetryManager.save(telemetry)
+    res.json({ message: "Telemetry saved successfully" })
   })
 
   app.get(
@@ -185,12 +190,6 @@ export default async function (
 
       if (payload && payload.rigobot && payload.rigobot.key) {
         res.json({ rigoToken: payload.rigobot.key, payload: payload })
-
-        TelemetryManager.setStudent({
-          user_id: payload.user_id,
-          email: payload.email,
-          token: payload.token,
-        })
       } else {
         res
           .status(400)

package/src/managers/session.ts

@@ -137,11 +137,6 @@ const Session: ISession = {
     if (data) {
       this.start({ token: data.token, payload: data })
 
-      TelemetryManager.setStudent({
-        user_id: data.user_id,
-        email: data.email,
-        token: data.token,
-      })
       return data
     }
   },

package/src/managers/telemetry.ts

@@ -1,5 +1,5 @@
 import { IFile } from "../models/file"
-import API from "../utils/api"
+import { ISocket } from "../models/socket"
 const packageInfo = require("../../package.json")
 import Console from "../utils/console"
 
@@ -107,242 +107,46 @@ type TUser = {
   email: string
 }
 
-interface ITelemetryManager {
-  current: ITelemetryJSONSchema | null
+interface ITelemetryManagerCLI {
   configPath: string | null
-  user: TUser
-  urls: TTelemetryUrls
-  started: boolean
+  socket: ISocket | null
   version: string
-  salute: (message: string) => void
-  start: (
-    agent: string,
-    steps: TStep[],
-    path: string,
-    tutorialSlug: string
-  ) => void
-  prevStep?: number
+  start: (path: string, socket: ISocket) => void
   registerStepEvent: (
     stepPosition: number,
     event: TStepEvent,
     data: any
   ) => void
-  streamEvent: (stepPosition: number, event: string, data: any) => void
-  submit: () => Promise<void>
-  finishWorkoutSession: () => void
-  setStudent: (student: TStudent) => void
-  save: () => void
+  save: (telemetry: ITelemetryJSONSchema) => void
   retrieve: () => Promise<ITelemetryJSONSchema | null>
-  getStep: (stepPosition: number) => TStep | null
 }
 
-const TelemetryManager: ITelemetryManager = {
-  current: null,
-  urls: {},
+const TelemetryManager: ITelemetryManagerCLI = {
   version: packageInfo.version,
-  user: {
-    token: "",
-    id: "",
-    email: "",
-  },
+  socket: null,
+
   configPath: "",
-  started: false,
-  salute: message => {
-    Console.info(message)
-  },
 
-  start: function (agent, steps, path, tutorialSlug) {
+  start: function (path, socket) {
     this.configPath = path
-    if (!this.current) {
-      this.retrieve()
-        .then(data => {
-          const prevTelemetry = data
-          if (prevTelemetry) {
-            this.current = prevTelemetry
-            this.finishWorkoutSession()
-          } else {
-            this.current = {
-              telemetry_id: createUUID(),
-              slug: tutorialSlug,
-              version: `CLI:${this.version}`,
-              user_id: 0,
-              agent,
-              tutorial_started_at: Date.now(),
-              last_interaction_at: Date.now(),
-              steps,
-              workout_session: [
-                {
-                  started_at: Date.now(),
-                },
-              ],
-            }
-          }
-
-          if (this.current.user_id) {
-            this.user.id = this.current.user_id.toString()
-          }
-
-          if (!this.current.version) {
-            this.current.version = `CLI:${this.version}`
-          }
-
-          this.save()
-
-          this.started = true
-          Console.debug("Telemetry started successfully!")
-
-          if (!this.user.id) {
-            Console.debug(
-              "No user ID found, impossible to submit telemetry at start"
-            )
-            return
-          }
-
-          this.submit()
-        })
-        .catch(error => {
-          Console.debug(error)
-          // Delete the telemetry.json if it exists
-          fs.unlinkSync(`${this.configPath}/telemetry.json`)
-          throw new Error(
-            "There was a problem starting, reload LearnPack\nRun\n$ learnpack start"
-          )
-        })
-    }
-  },
-
-  setStudent: function (student) {
-    if (!this.current) {
-      Console.debug("Telemetry has not been started")
-
-      return
-    }
-
-    Console.debug("Setting student", student)
-
-    this.current.user_id = student.user_id
-    this.user.id = student.user_id
-    this.user.token = student.token
-    this.user.email = student.email
-    this.save()
-    this.submit()
-  },
-  finishWorkoutSession: function () {
-    if (!this.current) {
-      return
-    }
-
-    const lastSession =
-      this.current?.workout_session[this.current.workout_session.length - 1]
-    if (
-      lastSession &&
-      !lastSession.ended_at &&
-      this.current?.last_interaction_at
-    ) {
-      lastSession.ended_at = this.current.last_interaction_at
-      this.current.workout_session.push({
-        started_at: Date.now(),
-      })
-    }
+    this.socket = socket
   },
 
   registerStepEvent: function (stepPosition, event, data) {
-    Console.debug(`Registering Event ${event} for user ${this.user.id}`)
-
-    if (!this.current) {
-      // throw new Error("Telemetry has not been started");
-      return
-    }
-
-    const step = this.current.steps[stepPosition]
-    if (!step) {
-      return
-    }
-
-    if (data.source_code) {
-      data.source_code = stringToBase64(data.source_code)
-    }
-
-    if (data.stdout) {
-      data.stdout = stringToBase64(data.stdout)
-    }
-
-    if (data.stderr) {
-      data.stderr = stringToBase64(data.stderr)
-    }
-
-    if (Object.prototype.hasOwnProperty.call(data, "exitCode")) {
-      data.exit_code = data.exitCode
-      data.exitCode = undefined
-    }
-
-    switch (event) {
-      case "compile":
-        if (!step.compilations) {
-          step.compilations = []
-        }
-
-        step.compilations.push(data)
-        this.current.steps[stepPosition] = step
-        break
-      case "test":
-        if (!step.tests) {
-          step.tests = []
-        }
-
-        // data.stdout =
-        step.tests.push(data)
-        if (data.exit_code === 0) {
-          step.completed_at = Date.now()
-        }
-
-        this.current.steps[stepPosition] = step
-        break
-      case "ai_interaction":
-        if (!step.ai_interactions) {
-          step.ai_interactions = []
-        }
-
-        step.ai_interactions.push(data)
-        break
-
-      case "quiz_submission": {
-        if (!step.quiz_submissions) {
-          step.quiz_submissions = []
-        }
-
-        step.quiz_submissions.push(data)
-        break
+    Console.debug(`Registering Telemetry Event ${event}`)
+
+    this.socket?.emit(
+      "telemetry_event",
+      "ready",
+      [`Registering telemetry event ${event}`],
+      [],
+      [],
+      {
+        stepPosition,
+        event,
+        data,
       }
-
-      case "open_step": {
-        const now = Date.now()
-
-        if (!step.opened_at) {
-          step.opened_at = now
-          this.current.steps[stepPosition] = step
-        }
-
-        if (this.prevStep || this.prevStep === 0) {
-          const prevStep = this.current.steps[this.prevStep]
-          if (!prevStep.is_testeable && !prevStep.completed_at) {
-            prevStep.completed_at = now
-            this.current.steps[this.prevStep] = prevStep
-          }
-        }
-
-        this.prevStep = stepPosition
-        this.submit()
-        break
-      }
-
-      default:
-        throw new Error(`Event type ${event} is not supported`)
-    }
-
-    this.current.last_interaction_at = Date.now()
-    this.streamEvent(stepPosition, event, data)
-    this.save()
+    )
   },
   retrieve: function () {
     return new Promise((resolve, reject) => {
@@ -360,8 +164,8 @@ const TelemetryManager: ITelemetryManager = {
           } else {
             try {
               resolve(JSON.parse(data))
-            } catch (error) {
-              reject(error)
+            } catch {
+              resolve(null)
             }
           }
         }
@@ -369,70 +173,16 @@ const TelemetryManager: ITelemetryManager = {
     })
   },
 
-  getStep: function (stepPosition: number) {
-    return this.current?.steps[stepPosition] || null
-  },
-
-  submit: async function () {
-    Console.debug("Submitting telemetry...")
-
-    if (!this.current) {
-      Console.debug("Telemetry has not been started")
-      return Promise.resolve()
-    }
-
-    if (!this.user.id) {
-      Console.debug("User ID not found, skipping batch telemetry delivery")
-      return Promise.resolve()
-    }
-
-    const url = this.urls.batch
-    if (!url) {
-      Console.debug("Batch URL not found, skipping batch telemetry delivery")
-      return Promise.resolve()
-    }
-
-    const body = this.current
-
-    if (!body.user_id) {
-      body.user_id = this.user.id
-    }
-
-    API.sendBatchTelemetry(url, body)
-  },
-  save: function () {
+  save: function (telemetry: ITelemetryJSONSchema) {
     fs.writeFile(
       `${this.configPath}/telemetry.json`,
-      JSON.stringify(this.current),
+      JSON.stringify(telemetry),
       (err: any) => {
         if (err) 
 throw err
       }
     )
   },
-
-  streamEvent: async function (stepPosition, event, data) {
-    if (!this.current) 
-return
-
-    const url = this.urls.streaming
-    if (!url) {
-      return
-    }
-
-    const stepSlug = this.current.steps[stepPosition].slug
-
-    const body = {
-      slug: stepSlug,
-      telemetry_id: this.current.telemetry_id,
-      user_id: this.current.user_id,
-      step_position: stepPosition,
-      event,
-      data,
-    }
-
-    API.sendStreamTelemetry(url, body)
-  },
 }
 
 export default TelemetryManager

package/src/models/action.ts

@@ -1,12 +1,13 @@
-export type TAction =
-  | "test"
-  | "log"
-  | "reload"
-  | "ready"
-  | "clean"
-  | "ask"
-  | "file_change"
-  | "dialog"
-  | "session-refreshed"
-
-export type ICallback = (...agrs: any[]) => any
+export type TAction =
+  | "test"
+  | "log"
+  | "reload"
+  | "ready"
+  | "clean"
+  | "ask"
+  | "file_change"
+  | "dialog"
+  | "session-refreshed"
+  | "telemetry_event"
+
+export type ICallback = (...agrs: any[]) => any

package/src/models/status.ts

@@ -13,4 +13,4 @@ export type TStatus =
   | "open_files"
   | "open_window"
   | "instructions_closed"
-  | "completed";
+  | "completed"