Update insert error

Author: Bojan131

scripts/insert_errors_to_db.py

@@ -56,47 +56,96 @@ def get_db_connection(mainnet=False):
         print(f"❌ Failed to connect to DB: {e}")
         continue
 
-    for ka_label in errors:
-        row = {
-            'node_name': node_name,
-            'blockchain_id': blockchain_name,
-            'ka_label': ka_label,
-            'publish_error': None,
-            'query_error': None,
-            'publisher_get_error': None,
-            'non_publisher_get_error': None,
-            'time_stamp': errors[ka_label].get('time_stamp') if isinstance(errors[ka_label], dict) else None,
-        }
-
-        label = ka_label.lower()
-        if 'publish' in label:
-            row['publish_error'] = ka_label
-        elif 'query' in label:
-            row['query_error'] = ka_label
-        elif 'local get' in label:
-            row['publisher_get_error'] = ka_label
-        elif 'get' in label:
-            row['non_publisher_get_error'] = ka_label
-
-        insert_query = sql.SQL(f"""
-            INSERT INTO {sql.Identifier(table_name).string} (
-                node_name, blockchain_id, ka_label,
-                publish_error, query_error,
-                publisher_get_error, non_publisher_get_error,
-                time_stamp
-            ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
-        """)
-
-        try:
-            cursor.execute(insert_query, (
-                row['node_name'], row['blockchain_id'], row['ka_label'],
-                row['publish_error'], row['query_error'],
-                row['publisher_get_error'], row['non_publisher_get_error'],
-                row['time_stamp']
-            ))
-            print(f"✅ Inserted KA {ka_label} for {node_name}")
-        except Exception as e:
-            print(f"❌ Failed to insert KA {ka_label}: {e}")
+    for attempt_key, attempt_data in errors.items():
+        # Handle both old and new error formats
+        if isinstance(attempt_data, dict) and 'ka_label' in attempt_data:
+            # New format with structured error data per attempt
+            ka_label = attempt_data.get('ka_label', 'Unknown KA')
+            attempt_number = attempt_data.get('attempt', 1)
+            publish_error = attempt_data.get('publish_error')
+            query_error = attempt_data.get('query_error')
+            publisher_get_error = attempt_data.get('publisher_get_error')
+            non_publisher_get_error = attempt_data.get('non_publisher_get_error')
+            time_stamp = attempt_data.get('time_stamp')
+            
+            # Only insert if there's at least one error
+            if any([publish_error, query_error, publisher_get_error, non_publisher_get_error]):
+                row = {
+                    'node_name': node_name,
+                    'blockchain_id': blockchain_name,
+                    'ka_label': ka_label,
+                    'publish_error': publish_error,
+                    'query_error': query_error,
+                    'publisher_get_error': publisher_get_error,
+                    'non_publisher_get_error': non_publisher_get_error,
+                    'time_stamp': time_stamp,
+                }
+
+                insert_query = sql.SQL(f"""
+                    INSERT INTO {sql.Identifier(table_name).string} (
+                        node_name, blockchain_id, ka_label,
+                        publish_error, query_error,
+                        publisher_get_error, non_publisher_get_error,
+                        time_stamp
+                    ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
+                """)
+
+                try:
+                    cursor.execute(insert_query, (
+                        row['node_name'], row['blockchain_id'], row['ka_label'],
+                        row['publish_error'], row['query_error'],
+                        row['publisher_get_error'], row['non_publisher_get_error'],
+                        row['time_stamp']
+                    ))
+                    print(f"✅ Inserted {ka_label} (attempt {attempt_number}) for {node_name}")
+                except Exception as e:
+                    print(f"❌ Failed to insert {ka_label} (attempt {attempt_number}): {e}")
+        else:
+            # Old format - simple count (backward compatibility)
+            ka_label = attempt_key
+            error_message = attempt_data if isinstance(attempt_data, str) else str(attempt_data)
+            
+            row = {
+                'node_name': node_name,
+                'blockchain_id': blockchain_name,
+                'ka_label': ka_label,
+                'publish_error': None,
+                'query_error': None,
+                'publisher_get_error': None,
+                'non_publisher_get_error': None,
+                'time_stamp': None,
+            }
+
+            # Try to determine error type from the key or message
+            label = attempt_key.lower()
+            if 'publish' in label:
+                row['publish_error'] = error_message
+            elif 'query' in label:
+                row['query_error'] = error_message
+            elif 'local get' in label:
+                row['publisher_get_error'] = error_message
+            elif 'get' in label:
+                row['non_publisher_get_error'] = error_message
+
+            insert_query = sql.SQL(f"""
+                INSERT INTO {sql.Identifier(table_name).string} (
+                    node_name, blockchain_id, ka_label,
+                    publish_error, query_error,
+                    publisher_get_error, non_publisher_get_error,
+                    time_stamp
+                ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
+            """)
+
+            try:
+                cursor.execute(insert_query, (
+                    row['node_name'], row['blockchain_id'], row['ka_label'],
+                    row['publish_error'], row['query_error'],
+                    row['publisher_get_error'], row['non_publisher_get_error'],
+                    row['time_stamp']
+                ))
+                print(f"✅ Inserted {ka_label} for {node_name} (old format)")
+            except Exception as e:
+                print(f"❌ Failed to insert {ka_label}: {e}")
 
     try:
         conn.commit()

scripts/print_aggregated_errors.py

@@ -182,8 +182,36 @@ def print_all_errors():
 
         if errors:
             print(f"🔧 {node_name}")
-            for error_key, count in errors.items():
-                print(f"  • {count}x {error_key}")
+            for attempt_key, attempt_data in errors.items():
+                # Handle both old and new error formats
+                if isinstance(attempt_data, dict) and 'ka_label' in attempt_data:
+                    # New format with structured error data per attempt
+                    ka_label = attempt_data.get('ka_label', 'Unknown KA')
+                    attempt_number = attempt_data.get('attempt', 1)
+                    publish_error = attempt_data.get('publish_error')
+                    query_error = attempt_data.get('query_error')
+                    publisher_get_error = attempt_data.get('publisher_get_error')
+                    non_publisher_get_error = attempt_data.get('non_publisher_get_error')
+                    
+                    # Show which errors occurred for this attempt
+                    error_types = []
+                    if publish_error:
+                        error_types.append("publish")
+                    if query_error:
+                        error_types.append("query")
+                    if publisher_get_error:
+                        error_types.append("local get")
+                    if non_publisher_get_error:
+                        error_types.append("remote get")
+                    
+                    if error_types:
+                        print(f"  • {ka_label} (attempt {attempt_number}): {', '.join(error_types)} errors")
+                    else:
+                        print(f"  • {ka_label} (attempt {attempt_number}): no errors")
+                else:
+                    # Old format - simple count
+                    count = attempt_data if isinstance(attempt_data, int) else 1
+                    print(f"  • {count}x {attempt_key}")
             print()
         else:
             print(f"✅ {node_name}: No errors\n")

tests/mainnet/Base_Mainnet.py

@@ -75,17 +75,23 @@ def get_random_content(node_name):
         }
     }
 
-def log_error(error, node_name, step='unknown', remote_node=None):
-    print(f"\n❌ Error on {node_name} during {step}")
-    print(f"🔺 Type: {type(error).__name__}")
-    print(f"🧵 Message: {str(error)}")
-    tb = traceback.extract_tb(sys.exc_info()[2])
-    user_tb = [entry for entry in tb if "site-packages" not in entry.filename]
-    if user_tb:
-        last = user_tb[-1]
-        print(f"📍 Location: {last.filename}, line {last.lineno}, in {last.name}")
-
-    # Create a cleaner error message for grouping
+def log_error(error, node_name, step='unknown', remote_node=None, ka_number=None, attempt_number=None):
+    # Unique key for each KA attempt
+    attempt_key = f"KA #{ka_number} - attempt {attempt_number}" if ka_number and attempt_number else f"KA #{ka_number}"
+    if node_name not in error_stats:
+        error_stats[node_name] = {}
+    if attempt_key not in error_stats[node_name]:
+        error_stats[node_name][attempt_key] = {
+            "ka_label": f"KA #{ka_number}" if ka_number else "Unknown KA",
+            "attempt": attempt_number,
+            "publish_error": None,
+            "query_error": None,
+            "publisher_get_error": None,
+            "non_publisher_get_error": None,
+            "time_stamp": datetime.utcnow().isoformat()
+        }
+    # Determine which error column to update
+    error_message = str(error)
     if isinstance(error, TimeoutError) or isinstance(error, concurrent.futures.TimeoutError):
         error_message = f"Timeout after 3 minutes during {step}"
     else:
@@ -98,40 +104,27 @@ def log_error(error, node_name, step='unknown', remote_node=None):
                 error_message = str(error)
         except Exception:
             error_message = str(error)
-
     error_message = error_message.splitlines()[0][:100]
-
-    # Create a generic key that groups similar errors
-    if remote_node:
-        key = f"{step} — {type(error).__name__}: {error_message} on {remote_node}"
-    else:
-        key = f"{step} — {type(error).__name__}: {error_message}"
-    
-    # Store errors in the global error_stats for this node
-    if node_name not in error_stats:
-        error_stats[node_name] = {}
-    
-    if key in error_stats[node_name]:
-        error_stats[node_name][key] += 1
-    else:
-        error_stats[node_name][key] = 1
-    
+    if step == "publishing":
+        error_stats[node_name][attempt_key]["publish_error"] = error_message
+    elif step == "querying":
+        error_stats[node_name][attempt_key]["query_error"] = error_message
+    elif step == "local get":
+        error_stats[node_name][attempt_key]["publisher_get_error"] = error_message
+    elif step == "get":
+        error_stats[node_name][attempt_key]["non_publisher_get_error"] = error_message
+    # Always update timestamp to first error for this attempt
+    if not error_stats[node_name][attempt_key]["time_stamp"]:
+        error_stats[node_name][attempt_key]["time_stamp"] = datetime.utcnow().isoformat()
     # Write to individual node error file (parallel-safe)
     node_error_file = f"test_output/errors_{node_name.replace(' ', '_')}.json"
     os.makedirs("test_output", exist_ok=True)
-    
-    # Use the in-memory error_stats as the source of truth for this node
-    # This ensures we only track errors from the current test run
     node_errors = error_stats.get(node_name, {}).copy()
-    
-    # Add blockchain information to the error file for database processing
     error_data = {
         "blockchain_name": BLOCKCHAIN,
         "node_name": node_name,
         "errors": node_errors
     }
-    
-    # Save current state to individual node file
     with open(node_error_file, 'w') as f:
         json.dump(error_data, f, indent=2)
 
@@ -181,7 +174,7 @@ def run_test_for_node(node, index):
             publish_success += 1
             publish_times.append(end - start)
         except Exception as e:
-            log_error(e, name, "publishing")
+            log_error(e, name, "publishing", ka_number=i + 1, attempt_number=i + 1)
             ual = "did:dkg:base:8453/0xc28f310a87f7621a087a603e2ce41c22523f11d7/120278"
             print(f"⚠️ Using fallback UAL: {ual}")
             failed_assets.append(f"KA #{i + 1} (Publish failed — No UAL)")
@@ -203,7 +196,7 @@ def run_test_for_node(node, index):
             query_success += 1
             query_times.append(end - start)
         except Exception as e:
-            log_error(e, name, "querying")
+            log_error(e, name, "querying", ka_number=i + 1, attempt_number=i + 1)
             query_fail += 1
             failed_assets.append(f"KA #{i + 1} (Query failed — UAL: {ual})")
 
@@ -216,7 +209,7 @@ def run_test_for_node(node, index):
             local_get_success += 1
             local_get_times.append(end - start)
         except Exception as e:
-            log_error(e, name, "local get")
+            log_error(e, name, "local get", ka_number=i + 1, attempt_number=i + 1)
             local_get_fail += 1
             failed_assets.append(f"KA #{i + 1} (Local Get failed — UAL: {ual})")
 
@@ -247,7 +240,7 @@ def run_test_for_node(node, index):
             remote_get_success += 1
             remote_get_times.append(end - start)
         except Exception as e:
-            log_error(e, name, "get", remote_name)
+            log_error(e, name, "get", remote_name, ka_number=i + 1, attempt_number=i + 1)
             remote_get_fail += 1
             failed_assets.append(f"KA #{i + 1} (Get failed — UAL: {ual})")