more language-agnostic API: instead of python_version -> lang+lang_version [still only python supported]

Also corresponding changes in frontend

Author: HardMax71

backend/app/api/routes/execution.py

@@ -29,23 +29,26 @@ async def create_execution(
     logger.info(
         "Received script execution request",
         extra={
-            "python_version": execution.python_version,
+            "lang": execution.lang,
+            "lang_version": execution.lang_version,
             "script_length": len(execution.script),
             "client_ip": get_remote_address(request),
             "endpoint": "/execute",
         },
     )
 
-    try:
-        python_version = execution.python_version or "3.11"
+    lang_and_version: str = execution.lang + "-" + execution.lang_version
 
-        with EXECUTION_DURATION.labels(python_version=python_version).time():
+    try:
+        with EXECUTION_DURATION.labels(lang_and_version=lang_and_version).time():
             result = await execution_service.execute_script(
-                execution.script, python_version
+                script=execution.script,
+                lang=execution.lang,
+                lang_version=execution.lang_version
             )
 
         SCRIPT_EXECUTIONS.labels(
-            status="success", python_version=python_version
+            status="success", lang_and_version=lang_and_version
         ).inc()
 
         logger.info(
@@ -56,7 +59,7 @@ async def create_execution(
 
     except IntegrationException as e:
         SCRIPT_EXECUTIONS.labels(
-            status="integration_error", python_version=execution.python_version or "3.11"
+            status="integration_error", lang_and_version=lang_and_version
         ).inc()
 
         logger.error(
@@ -65,22 +68,22 @@ async def create_execution(
                 "error_type": "IntegrationException",
                 "status_code": e.status_code,
                 "error_detail": e.detail,
-                "python_version": execution.python_version,
+                "lang_and_version": lang_and_version,
             },
         )
         raise HTTPException(status_code=e.status_code, detail=e.detail) from e
 
     except Exception as e:
         SCRIPT_EXECUTIONS.labels(
-            status="error", python_version=execution.python_version or "3.11"
+            status="error", lang_and_version=lang_and_version
         ).inc()
 
         logger.error(
             "Unexpected error during script execution",
             extra={
                 "error_type": type(e).__name__,
                 "error_detail": str(e),
-                "python_version": execution.python_version,
+                "lang_and_version": lang_and_version,
             },
         )
         raise HTTPException(status_code=400, detail=f"Error during execution: {str(e)}") from e
@@ -117,7 +120,8 @@ async def get_result(
         extra={
             "execution_id": result.id,
             "status": result.status,
-            "python_version": result.python_version,
+            "lang": result.lang,
+            "lang_version": result.lang_version,
             "has_errors": bool(result.errors),
             "resource_usage": result.resource_usage,
         },
@@ -133,7 +137,8 @@ async def get_result(
         status=result.status,
         output=result.output,
         errors=result.errors,
-        python_version=result.python_version,
+        lang=result.lang,
+        lang_version=result.lang_version,
         resource_usage=resource_usage_obj,
     )
 

backend/app/config.py

@@ -23,7 +23,11 @@ class Settings(BaseSettings):
     K8S_POD_CPU_REQUEST: str = "100m"
     K8S_POD_MEMORY_REQUEST: str = "128Mi"
     K8S_POD_EXECUTION_TIMEOUT: int = 5  # in seconds
-    SUPPORTED_PYTHON_VERSIONS: list[str] = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+
+    SUPPORTED_RUNTIMES: dict[str, list[str]] = {
+        "python": ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+    }
+
     PROMETHEUS_URL: str = "http://prometheus:9090"
 
     TESTING: bool = False

backend/app/core/metrics.py

@@ -11,11 +11,6 @@
 class BoundedLabelsCounter(Counter):
     def labels(self, *args: Any, **kwargs: Any) -> 'BoundedLabelsCounter':
         # Validate labels before creating new time series
-        if (
-                "python_version" in kwargs
-                and kwargs["python_version"] not in get_settings().SUPPORTED_PYTHON_VERSIONS
-        ):
-            kwargs["python_version"] = "unknown"
         if "status" in kwargs and kwargs["status"] not in ALLOWED_STATUSES:
             kwargs["status"] = "unknown"
         return super().labels(*args, **kwargs)
@@ -25,13 +20,13 @@ def labels(self, *args: Any, **kwargs: Any) -> 'BoundedLabelsCounter':
 SCRIPT_EXECUTIONS = BoundedLabelsCounter(
     "script_executions_total",
     "Total number of script executions",
-    ["status", "python_version"],
+    ["status", "lang_and_version"],
 )
 
 EXECUTION_DURATION = Histogram(
     "script_execution_duration_seconds",
     "Time spent executing scripts",
-    ["python_version"],
+    ["lang_and_version"],
     buckets=[0.1, 0.5, 1.0, 2.0, 5.0, 10.0, 30.0, 60.0],  # Define specific buckets
 )
 
@@ -41,7 +36,7 @@ def labels(self, *args: Any, **kwargs: Any) -> 'BoundedLabelsCounter':
 
 # Resource usage metrics
 MEMORY_USAGE = Gauge(
-    "script_memory_usage_bytes", "Memory usage per script execution", ["python_version"]
+    "script_memory_usage_bytes", "Memory usage per script execution", ["lang_and_version"]
 )
 
 ERROR_COUNTER = Counter(

backend/app/schemas/execution.py

@@ -14,7 +14,8 @@ class ExecutionBase(BaseModel):
     status: str = "queued"
     output: Optional[str] = None
     errors: Optional[str] = None
-    python_version: str = "3.11"
+    lang: str = "python"
+    lang_version: str = "3.11"
 
 
 class ExecutionCreate(ExecutionBase):
@@ -56,8 +57,11 @@ class ResourceUsage(BaseModel):
 
 class ExecutionRequest(BaseModel):
     script: str
-    python_version: Optional[str] = Field(
-        default="3.11", description="Python version to use for execution"
+    lang: str = Field(
+        default="python", description="Language name"
+    ),
+    lang_version: Optional[str] = Field(
+        default="3.11", description="Language version to use for execution"
     )
 
 
@@ -74,7 +78,8 @@ class ExecutionResult(BaseModel):
     status: str
     output: Optional[str] = None
     errors: Optional[str] = None
-    python_version: str
+    lang: str
+    lang_version: str
     resource_usage: Optional[ResourceUsage] = None
 
     class Config:
@@ -87,4 +92,4 @@ class K8SResourceLimits(BaseModel):
     cpu_request: str
     memory_request: str
     execution_timeout: int
-    supported_python_versions: List[str]
+    supported_runtimes: dict[str, list[str]]

backend/app/services/execution_service.py

@@ -48,15 +48,20 @@ async def get_k8s_resource_limits(self) -> Dict[str, Any]:
             "cpu_request": self.settings.K8S_POD_CPU_REQUEST,
             "memory_request": self.settings.K8S_POD_MEMORY_REQUEST,
             "execution_timeout": self.settings.K8S_POD_EXECUTION_TIMEOUT,
-            "supported_python_versions": self.settings.SUPPORTED_PYTHON_VERSIONS,
+            "supported_runtimes": self.settings.SUPPORTED_RUNTIMES,
         }
 
     async def _start_k8s_execution(
-            self, execution_id_str: str, script: str, python_version: str
+            self, execution_id_str: str,
+            script: str,
+            lang: str,
+            lang_version: str
     ) -> None:
         try:
             # Python-specific configuration
-            image = f"python:{python_version}-slim"
+            image = f"{lang}:{lang_version}-slim"
+
+            # TODO: decouple from file format smh
             command = ["python", "/scripts/script.py"]
             config_map_data = {
                 "script.py": script
@@ -169,36 +174,44 @@ async def _try_finalize_execution(self, execution: ExecutionInDB) -> Optional[Ex
             raise IntegrationException(status_code=500, detail="Failed to retrieve execution after update.")
 
         status_label = "success" if updated_execution.status == ExecutionStatus.COMPLETED else "error"
-        SCRIPT_EXECUTIONS.labels(status=status_label, python_version=updated_execution.python_version).inc()
+        SCRIPT_EXECUTIONS.labels(status=status_label,
+                                 lang_and_version=execution.lang + "-" + execution.lang_version).inc()
         if status_label == "error":
             ERROR_COUNTER.labels(error_type="ScriptExecutionError").inc()
 
         return updated_execution
 
     async def execute_script(
-            self, script: str, python_version: str = "3.11"
+            self, script: str,
+            lang: str = "python",
+            lang_version: str = "3.11"
     ) -> ExecutionInDB:
         ACTIVE_EXECUTIONS.inc()
         start_time = time()
         inserted_oid = None
 
         try:
-            if python_version not in self.settings.SUPPORTED_PYTHON_VERSIONS:
-                raise IntegrationException(status_code=400, detail=f"Unsupported Python version: {python_version}")
+            if lang not in self.settings.SUPPORTED_RUNTIMES.keys():
+                raise IntegrationException(status_code=400, detail=f"Language '{lang}' not supported.")
+
+            if lang_version not in self.settings.SUPPORTED_RUNTIMES[lang]:
+                raise IntegrationException(status_code=400, detail=f"Language version '{lang_version}' not supported.")
 
             execution_create = ExecutionCreate(
                 script=script,
-                python_version=python_version,
+                lang=lang,
+                lang_version=lang_version,
                 status=ExecutionStatus.QUEUED,
             )
             execution_to_insert = ExecutionInDB(**execution_create.model_dump())
             inserted_oid = await self.execution_repo.create_execution(execution_to_insert)
             logger.info(f"Created execution record {inserted_oid} with status QUEUED.")
 
             await self._start_k8s_execution(
-                inserted_oid, script, python_version
+                execution_id_str=inserted_oid, script=script,
+                lang=lang, lang_version=lang_version
             )
-            SCRIPT_EXECUTIONS.labels(status="initiated", python_version=python_version).inc()
+            SCRIPT_EXECUTIONS.labels(status="initiated", lang_and_version=lang + "-" + lang_version).inc()
             await asyncio.sleep(0.1)
 
             final_execution_state = await self.execution_repo.get_execution(inserted_oid)
@@ -218,7 +231,7 @@ async def execute_script(
                                        detail=f"Internal server error during script execution request: "
                                               f"{str(e)}") from e
         finally:
-            EXECUTION_DURATION.labels(python_version=python_version).observe(time() - start_time)
+            EXECUTION_DURATION.labels(lang_and_version=lang + "-" + lang_version).observe(time() - start_time)
             ACTIVE_EXECUTIONS.dec()
 
     async def get_execution_result(self, execution_id: str) -> ExecutionInDB:

backend/grafana/provisioning/dashboards/integr8scode.json

@@ -67,7 +67,7 @@
           "editorMode": "code",
           "expr": "floor(increase(script_executions_total[5m]))",
           "instant": false,
-          "legendFormat": "{{python_version}} {{status}}",
+          "legendFormat": "{{lang_and_version}} {{status}}",
           "range": true,
           "refId": "A"
         }

backend/prometheus/prometheus.yml

@@ -10,8 +10,8 @@ scrape_configs:
     static_configs:
       - targets: ['backend:443']
     metric_relabel_configs:
-      - source_labels: [ python_version ]
-        regex: '3\.(7|8|9|10|11|12)'
+      - source_labels: [ lang_and_version ]
+        regex: '(.+)-(.+)'
         action: keep
       - source_labels: [ status ]
         regex: '(success|error|timeout|invalid_input|unknown)'

backend/tests/integration/test_execution_api.py

@@ -50,7 +50,8 @@ async def test_execute_script_success_workflow(self) -> None:
         script_content = "import time\nimport sys\nprint('Hello from integration test')\nsys.stdout.flush()\ntime.sleep(1)\nprint('Execution complete')"
         execution_request = {
             "script": script_content,
-            "python_version": "3.11",  # Ensure this version is supported by your setup
+            "lang": "python",
+            "lang_version": "3.11",
         }
 
         # 1. Execute Script
@@ -87,7 +88,7 @@ async def test_execute_script_success_workflow(self) -> None:
         assert "Hello from integration test" in result_data.get("output", "")
         assert "Execution complete" in result_data.get("output", "")
         assert result_data.get("errors") is None or result_data.get("errors") == ""
-        assert result_data.get("python_version") == execution_request["python_version"]
+        assert result_data.get("lang_version") == execution_request["lang_version"]
 
     @pytest.mark.asyncio
     async def test_execute_script_with_error(self) -> None:
@@ -137,9 +138,9 @@ async def test_k8s_resource_limits(self) -> None:
         assert response.status_code == 200
         limits = response.json()
         expected_keys = ["cpu_limit", "memory_limit", "cpu_request", "memory_request", "execution_timeout",
-                         "supported_python_versions"]
+                         "supported_runtimes"]
         assert all(key in limits for key in expected_keys)
-        assert isinstance(limits["supported_python_versions"], list)
+        assert isinstance(limits["supported_runtimes"], dict)
 
     @pytest.mark.asyncio
     async def test_execute_endpoint_without_auth(self) -> None:

backend/tests/load/locustfile.py

@@ -47,7 +47,8 @@ def execute_script(self) -> None:
 
         execution_data = {
             "script": script,
-            "python_version": random.choice(["3.9", "3.10", "3.11"]),
+            "lang": "python",
+            "lang_version": random.choice(["3.9", "3.10", "3.11"]),
         }
 
         # Execute script

frontend/src/components/Footer.svelte

@@ -14,7 +14,7 @@
                     Integr8sCode
                 </h2>
                 <p class="text-base text-fg-muted dark:text-dark-fg-muted">
-                    Run Python scripts online with ease and security, powered by Kubernetes.
+                    Run code online with ease and security, powered by Kubernetes.
                 </p>
             </div>