events-saving is also product-aware

Author: Tofel

framework/tracking/dx.go

@@ -51,6 +51,7 @@ func (t *NoOpTracker) Track(event string, metadata map[string]any) error {
 type DxTracker struct {
 	mode     Mode
 	testMode bool
+	product  Product
 
 	logger zerolog.Logger
 
@@ -61,7 +62,7 @@ type DxTracker struct {
 // NewDxTracker initializes a tracker with automatic GitHub CLI integration for authentication.
 // APITokenVariableName is the name of the GitHub repository variable containing the DX API token.
 // Each DX project has its own token for tracking purposes.
-func NewDxTracker(APITokenVariableName, product string) (Tracker, error) {
+func NewDxTracker(APITokenVariableName string, product Product) (Tracker, error) {
 	t := &DxTracker{}
 
 	lvlStr := os.Getenv(EnvVarLogLevel)
@@ -77,7 +78,6 @@ func NewDxTracker(APITokenVariableName, product string) (Tracker, error) {
 
 	if os.Getenv(EnvVarDisableTracking) == "true" {
 		t.logger.Debug().Msg("Tracking disabled by environment variable")
-
 		return &NoOpTracker{}, nil
 	}
 
@@ -94,6 +94,7 @@ func NewDxTracker(APITokenVariableName, product string) (Tracker, error) {
 		return nil, errors.New("product is required. Each DX project has its own token for tracking purposes")
 	}
 	product = strings.ToLower(product)
+	t.product = product
 
 	c, isConfigAvailable, configErr := openConfig()
 	if configErr != nil {
@@ -374,7 +375,7 @@ func openConfig() (*config, bool, error) {
 			GithubUsername: legacyConfig.GithubUsername,
 			APITokens: map[Product]string{
 				// it is the only product that uses tracking at the moment
-				"local_CRE": legacyConfig.DxAPIToken,
+				"local_cre": legacyConfig.DxAPIToken,
 			},
 		}
 
@@ -407,7 +408,7 @@ func saveConfig(c *config) error {
 		return errors.Wrap(pathErr, "failed to get config path")
 	}
 
-	mkdirErr := os.MkdirAll(filepath.Dir(configPath), 0755)
+	mkdirErr := os.MkdirAll(filepath.Dir(configPath), 0o755)
 	if mkdirErr != nil {
 		return errors.Wrap(mkdirErr, "failed to create config directory")
 	}
@@ -442,12 +443,12 @@ type event struct {
 func (t *DxTracker) saveEvent(name string, timestamp int64, metadata map[string]any) error {
 	t.logger.Debug().Msgf("Saving event. Name: %s, Timestamp: %d, Metadata: %v", name, timestamp, metadata)
 
-	storagePath, pathErr := storagePath()
+	storagePath, pathErr := storagePath(t.product)
 	if pathErr != nil {
 		return errors.Wrap(pathErr, "failed to get storage path")
 	}
 
-	mkdirErr := os.MkdirAll(filepath.Dir(storagePath), 0755)
+	mkdirErr := os.MkdirAll(filepath.Dir(storagePath), 0o755)
 	if mkdirErr != nil {
 		return errors.Wrap(mkdirErr, "failed to create storage directory")
 	}
@@ -476,7 +477,7 @@ func (t *DxTracker) saveEvent(name string, timestamp int64, metadata map[string]
 		return errors.Wrap(err, "failed to marshal events to JSON")
 	}
 
-	if err := os.WriteFile(storagePath, jsonData, 0600); err != nil {
+	if err := os.WriteFile(storagePath, jsonData, 0o600); err != nil {
 		return errors.Wrap(err, "failed to write event to storage file")
 	}
 
@@ -485,31 +486,62 @@ func (t *DxTracker) saveEvent(name string, timestamp int64, metadata map[string]
 
 // sendSavedEvents attempts to send all queued events and clears the queue on success.
 func (t *DxTracker) sendSavedEvents() error {
-	storagePath, pathErr := storagePath()
+	storagePath, pathErr := storagePath(t.product)
 	if pathErr != nil {
 		return errors.Wrap(pathErr, "failed to get storage path")
 	}
 
-	stats, statErr := os.Stat(storagePath)
-	if os.IsNotExist(statErr) {
-		return nil
-	}
+	var readEvents = func(path string) ([]event, error) {
+		stats, statErr := os.Stat(path)
+		if os.IsNotExist(statErr) {
+			return nil, nil
+		}
 
-	if stats.Size() == 0 {
-		return nil
+		if stats.Size() == 0 {
+			return nil, nil
+		}
+
+		storageFile, storageErr := os.OpenFile(path, os.O_RDONLY, 0644)
+		if storageErr != nil {
+			return nil, errors.Wrap(storageErr, "failed to open storage file")
+		}
+		defer storageFile.Close()
+
+		var events []event
+
+		decoderErr := json.NewDecoder(storageFile).Decode(&events)
+		if decoderErr != nil {
+			return nil, errors.Wrap(decoderErr, "failed to decode events from storage file")
+		}
+
+		return events, nil
 	}
 
-	storageFile, storageErr := os.OpenFile(storagePath, os.O_RDONLY, 0644)
-	if storageErr != nil {
-		return errors.Wrap(storageErr, "failed to open storage file")
+	events, readErr := readEvents(storagePath)
+	if readErr != nil {
+		return errors.Wrap(readErr, "failed to read saved events")
 	}
-	defer storageFile.Close()
 
-	var events []event
+	// read from legacy storage path if product is local_CRE
+	if t.product == "local_cre" {
+		t.logger.Debug().Msg("Checking for legacy saved events")
 
-	decoderErr := json.NewDecoder(storageFile).Decode(&events)
-	if decoderErr != nil {
-		return errors.Wrap(decoderErr, "failed to decode events from storage file")
+		legacyPath, legacyErr := legacyStoragePath()
+		if legacyErr != nil {
+			return errors.Wrap(legacyErr, "failed to get legacy storage path")
+		}
+
+		legacyEvents, legacyReadErr := readEvents(legacyPath)
+		if legacyReadErr != nil {
+			return errors.Wrap(legacyReadErr, "failed to read legacy saved events")
+		}
+
+		events = append(events, legacyEvents...)
+	}
+
+	if len(events) == 0 {
+		t.logger.Debug().Msg("No saved events to send")
+		return nil
 	}
 
 	t.logger.Debug().Msgf("Sending %d saved events", len(events))
@@ -547,7 +579,7 @@ func (t *DxTracker) sendSavedEvents() error {
 
 // clearSavedEvents removes all queued events after successful transmission.
 func (t *DxTracker) clearSavedEvents() error {
-	storagePath, pathErr := storagePath()
+	storagePath, pathErr := storagePath(t.product)
 	if pathErr != nil {
 		return errors.Wrap(pathErr, "failed to get storage path")
 	}
@@ -579,7 +611,18 @@ func validateEvent(event string, timestamp int64, metadata map[string]any) error
 }
 
 // storagePath returns the path to the events queue file in the user's home directory.
-func storagePath() (string, error) {
+func storagePath(product Product) (string, error) {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return "", errors.Wrap(err, "failed to get user home directory")
+	}
+
+	return filepath.Join(homeDir, ".local", "share", "dx", product+"_events.json"), nil
+}
+
+// legacyStoragePath returns the path to the events queue file in the user's home directory.
+// deprecated: legacyStoragePath is used to read old storage files and migrate them to the new format. Use storagePath instead.
+func legacyStoragePath() (string, error) {
 	homeDir, err := os.UserHomeDir()
 	if err != nil {
 		return "", errors.Wrap(err, "failed to get user home directory")