flow-debugger 1.0.2 → 1.2.0

package/python-sdk/flow_debugger_core.py

@@ -0,0 +1,83 @@
+import time
+import uuid
+from typing import List, Dict, Any, Optional, Union
+from datetime import datetime
+
+class TraceStep:
+    def __init__(self, name: str, service: str = 'internal', status: str = 'success'):
+        self.name = name
+        self.service = service
+        self.status = status
+        self.classification = 'INFO'
+        self.start_time = time.time() * 1000  # ms
+        self.end_time = 0
+        self.duration = 0
+        self.offset = 0
+        self.error = None
+        self.metadata = {}
+
+    def end(self):
+        self.end_time = time.time() * 1000
+        self.duration = self.end_time - self.start_time
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'name': self.name,
+            'service': self.service,
+            'status': self.status,
+            'classification': self.classification,
+            'startTime': self.start_time,
+            'endTime': self.end_time,
+            'duration': self.duration,
+            'offset': self.offset,
+            'error': self.error,
+            'metadata': self.metadata
+        }
+
+class RequestTracer:
+    def __init__(self, endpoint: str, method: str, trace_id: str = None):
+        self.trace_id = trace_id or f"py_{uuid.uuid4().hex[:12]}"
+        self.endpoint = endpoint
+        self.method = method
+        self.start_time = time.time() * 1000
+        self.steps: List[TraceStep] = []
+        self.ended = False
+        self.total_duration = 0
+        self.status_code = None
+
+    def step(self, name: str, service: str = 'internal'):
+        new_step = TraceStep(name, service)
+        new_step.offset = new_step.start_time - self.start_time
+        self.steps.append(new_step)
+        return new_step
+
+    def end(self, status_code: int = 200):
+        if self.ended:
+            return
+        self.ended = True
+        self.status_code = status_code
+        end_time = time.time() * 1000
+        self.total_duration = end_time - self.start_time
+        
+        # Build final trace object
+        return self.to_dict()
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'traceId': self.trace_id,
+            'endpoint': self.endpoint,
+            'method': self.method,
+            'statusCode': self.status_code,
+            'steps': [s.to_dict() for s in self.steps],
+            'totalDuration': self.total_duration,
+            'classification': self._classify_trace(),
+            'timestamp': datetime.now().isoformat(),
+            'language': 'python'
+        }
+
+    def _classify_trace(self) -> str:
+        if any(s.status != 'success' for s in self.steps):
+            return 'ERROR'
+        if self.total_duration > 500:
+            return 'WARN'
+        return 'INFO'

package/python-sdk/middleware.py

@@ -0,0 +1,32 @@
+import requests
+import time
+from .flow_debugger_core import RequestTracer
+
+class FlowDebuggerFlask:
+    def __init__(self, app=None, debugger_url="http://localhost:3500/__debugger"):
+        self.debugger_url = debugger_url
+        if app is not None:
+            self.init_app(app)
+
+    def init_app(self, app):
+        @app.before_request
+        def before_request():
+            import flask
+            # Start trace
+            tracer = RequestTracer(endpoint=flask.request.path, method=flask.request.method)
+            flask.g.tracer = tracer
+
+        @app.after_request
+        def after_request(response):
+            import flask
+            tracer = getattr(flask.g, 'tracer', None)
+            if tracer:
+                trace_data = tracer.end(status_code=response.status_code)
+                # Send to Node.js dashboard API in background (sync for simple version)
+                try:
+                    # In a real version, this would be buffered or async
+                    # For this demo/SDK, we send it directly to the local debugger
+                    requests.post(self.debugger_url, json=trace_data, timeout=0.1)
+                except:
+                    pass
+            return response