Fix test ID collision with nanosecond precision

Changed test ID generation from microsecond to nanosecond timestamps
to prevent collisions when tests start concurrently. Added better error
handling and logging in concurrent test.

User request: "are all of these changes actually tested? let's move through the PRs and run local tests to validate the PR, then check the CI and respond to any code review"

Co-Authored-By: Claude <noreply@anthropic.com>

Author: jrepp

cmd/prism-loadtest/server/integration_test.go

@@ -298,6 +298,8 @@ func TestIntegrationConcurrentTests(t *testing.T) {
 	numTests := 3
 	testIDs := make([]string, numTests)
 	var wg sync.WaitGroup
+	var mu sync.Mutex
+	startErrors := make([]error, 0)
 
 	for i := 0; i < numTests; i++ {
 		wg.Add(1)
@@ -313,25 +315,45 @@ func TestIntegrationConcurrentTests(t *testing.T) {
 			body, _ := json.Marshal(testConfig)
 			resp, err := http.Post(testServer.URL+"/api/loadtest/start", "application/json", bytes.NewReader(body))
 			if err != nil {
-				t.Errorf("failed to start test %d: %v", index, err)
+				mu.Lock()
+				startErrors = append(startErrors, fmt.Errorf("test %d: %v", index, err))
+				mu.Unlock()
 				return
 			}
 			defer resp.Body.Close()
 
+			if resp.StatusCode != http.StatusCreated {
+				mu.Lock()
+				startErrors = append(startErrors, fmt.Errorf("test %d: unexpected status %d", index, resp.StatusCode))
+				mu.Unlock()
+				return
+			}
+
 			var startResp TestInfo
 			if err := json.NewDecoder(resp.Body).Decode(&startResp); err != nil {
-				t.Errorf("failed to decode response for test %d: %v", index, err)
+				mu.Lock()
+				startErrors = append(startErrors, fmt.Errorf("test %d decode: %v", index, err))
+				mu.Unlock()
 				return
 			}
 
 			testIDs[index] = startResp.TestID
+			t.Logf("Successfully started test %d with ID: %s", index, startResp.TestID)
 		}(i)
 	}
 
 	wg.Wait()
 
-	// Verify all tests are running - check immediately after starting
-	time.Sleep(500 * time.Millisecond)
+	// Check if any starts failed
+	if len(startErrors) > 0 {
+		for _, err := range startErrors {
+			t.Errorf("Start error: %v", err)
+		}
+		t.Fatalf("Failed to start %d test(s)", len(startErrors))
+	}
+
+	// Verify all tests are running - wait a bit to ensure all executor.Run() goroutines have started
+	time.Sleep(1000 * time.Millisecond)
 
 	resp, err := http.Get(testServer.URL + "/api/loadtest/list")
 	if err != nil {

cmd/prism-loadtest/server/server.go

@@ -108,8 +108,8 @@ func (s *Server) handleStartTest(w http.ResponseWriter, r *http.Request) {
 		config.Rate = 100
 	}
 
-	// Generate test ID with microsecond precision to avoid collisions
-	testID := fmt.Sprintf("test-%s", time.Now().Format("20060102-150405.000000"))
+	// Generate test ID with nanosecond precision to avoid collisions
+	testID := fmt.Sprintf("test-%d", time.Now().UnixNano())
 
 	// Create test executor
 	executor := NewTestExecutor(testID, config, s.backendConfig)