Fix recording service schema mismatch and missing field errors

This commit fixes multiple issues with the recording API:

1. **Recording Service Schema Update**: Updated recording service to use
   the new channel schema with class_name, channel number, and method_name
   fields instead of the old 'parameter' field.

2. **CSV Export Fix**: Updated CSV export to use correct channel key format:
   device_id_class_name_channel_method_name

3. **Total Duration Calculation**: Fixed AttributeError by calculating
   total_duration_seconds dynamically from start_time, end_time, and
   pause_duration_seconds instead of accessing non-existent model field.

4. **Query Method Calls**: Fixed recording service to pass channel number
   as parameter when calling driver query methods (e.g., query_voltage(1)).

The recording API now properly:
- Creates recordings with new schema
- Collects data from multi-channel devices
- Exports CSV with correct headers
- Returns proper duration calculations

Fixes: 500 Internal Server Error on /recordings endpoint
Fixes: KeyError 'parameter' in recording service background task

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: MarkoVcode

benchmesh-serial-service/src/benchmesh_service/api_recording.py

@@ -175,24 +175,32 @@ async def list_recordings(db: Session = Depends(get_db)):
             RecordingSeries.start_time.desc()
         ).all()
 
-        return {
-            "recordings": [
-                {
-                    "id": s.id,
-                    "name": s.name,
-                    "description": s.description,
-                    "start_time": s.start_time.isoformat(),
-                    "end_time": s.end_time.isoformat() if s.end_time else None,
-                    "interval_seconds": s.interval_seconds,
-                    "channels": json.loads(s.channels),
-                    "total_duration_seconds": s.total_duration_seconds,
-                    "pause_duration_seconds": s.pause_duration_seconds,
-                    "paused_at": s.paused_at.isoformat() if s.paused_at else None,
-                    "status": "paused" if s.paused_at else ("stopped" if s.end_time else "recording")
-                }
-                for s in series_list
-            ]
-        }
+        # Calculate total duration for each recording
+        recordings = []
+        for s in series_list:
+            # Calculate total duration (excluding pauses)
+            if s.end_time:
+                # Recording stopped: use actual duration
+                total_duration = (s.end_time - s.start_time).total_seconds() - s.pause_duration_seconds
+            else:
+                # Recording active: use current time
+                total_duration = (datetime.utcnow() - s.start_time).total_seconds() - s.pause_duration_seconds
+
+            recordings.append({
+                "id": s.id,
+                "name": s.name,
+                "description": s.description,
+                "start_time": s.start_time.isoformat(),
+                "end_time": s.end_time.isoformat() if s.end_time else None,
+                "interval_seconds": s.interval_seconds,
+                "channels": json.loads(s.channels),
+                "total_duration_seconds": max(0, total_duration),  # Ensure non-negative
+                "pause_duration_seconds": s.pause_duration_seconds,
+                "paused_at": s.paused_at.isoformat() if s.paused_at else None,
+                "status": "paused" if s.paused_at else ("stopped" if s.end_time else "recording")
+            })
+
+        return {"recordings": recordings}
 
     @router.get("/{series_id}")
     async def get_recording(series_id: int, db: Session = Depends(get_db)):
@@ -318,7 +326,7 @@ async def export_recording(series_id: int, db: Session = Depends(get_db)):
             # Empty CSV with just headers
             channels = json.loads(series.channels)
             fieldnames = ["timestamp"] + [
-                f"{ch['device_id']}.{ch['parameter']}" for ch in channels
+                f"{ch['device_id']}_{ch['class_name']}_{ch['channel']}_{ch['method_name']}" for ch in channels
             ]
             writer = csv.DictWriter(output, fieldnames=fieldnames)
             writer.writeheader()

benchmesh-serial-service/src/benchmesh_service/services/recording_service.py

@@ -50,7 +50,7 @@ async def start_recording(
         Args:
             db: Database session
             name: Unique name for the recording
-            channels: List of channel definitions with device_id, parameter, label
+            channels: List of channel definitions with device_id, class_name, channel, method_name, label
             interval_seconds: Data collection interval in seconds
             description: Optional description
 
@@ -294,21 +294,26 @@ async def _recording_loop(
 
                 for channel in channels:
                     device_id = channel["device_id"]
-                    parameter = channel["parameter"]
-                    key = f"{device_id}.{parameter}"
+                    class_name = channel["class_name"]
+                    channel_num = channel["channel"]
+                    method_name = channel["method_name"]
+
+                    # Key format matches frontend: device_id_class_name_channel_method_name
+                    key = f"{device_id}_{class_name}_{channel_num}_{method_name}"
 
                     try:
-                        # Get driver and query parameter
+                        # Get driver and query method
                         if self.serial_manager:
                             driver = self.serial_manager.get_driver(device_id)
                             if driver:
-                                method_name = f"query_{parameter}"
-                                if hasattr(driver, method_name):
-                                    value = getattr(driver, method_name)()
+                                query_method = f"query_{method_name}"
+                                if hasattr(driver, query_method):
+                                    # Call the method with channel number as parameter
+                                    value = getattr(driver, query_method)(channel_num)
                                     measurements[key] = value
                     except Exception as e:
                         logger.warning(
-                            f"Error reading {parameter} from {device_id}: {e}"
+                            f"Error reading {method_name} from {device_id} channel {channel_num}: {e}"
                         )
 
                 # Store data point if we got any measurements