chore: standardize exception capturing

Co-authored-by: sakovic.fx <[email protected]>

Author: cursoragent

products/endpoints/backend/api.py

@@ -25,10 +25,13 @@
     QueryRequest,
     QueryStatus,
     QueryStatusResponse,
+    RefreshType,
 )
 
+from posthog.hogql import ast
 from posthog.hogql.constants import LimitContext
 from posthog.hogql.errors import ExposedHogQLError, ResolutionError
+from posthog.hogql.property import property_to_expr
 
 from posthog.api.documentation import extend_schema
 from posthog.api.mixins import PydanticModelMixin
@@ -219,9 +222,15 @@ def create(self, request: Request, *args, **kwargs) -> Response:
 
             return Response(self._serialize_endpoint(endpoint), status=status.HTTP_201_CREATED)
 
-        # We should expose if the query name is duplicate
         except Exception as e:
-            capture_exception(e)
+            capture_exception(
+                e,
+                {
+                    "product": Product.ENDPOINTS,
+                    "team_id": self.team_id,
+                    "endpoint_name": data.name,
+                },
+            )
             raise ValidationError("Failed to create endpoint.")
 
     def validate_update_request(
@@ -316,7 +325,15 @@ def update(self, request: Request, name: str | None = None, *args, **kwargs) ->
             return Response(self._serialize_endpoint(endpoint))
 
         except Exception as e:
-            capture_exception(e)
+            capture_exception(
+                e,
+                {
+                    "product": Product.ENDPOINTS,
+                    "team_id": self.team_id,
+                    "endpoint_id": endpoint.id,
+                    "saved_query_id": endpoint.saved_query.id if endpoint.saved_query else None,
+                },
+            )
             raise ValidationError("Failed to update endpoint.")
 
     def _enable_materialization(
@@ -451,49 +468,61 @@ def _execute_materialized_endpoint(
         self, endpoint: Endpoint, data: EndpointRunRequest, request: Request
     ) -> Response:
         """Execute against a materialized table in S3."""
-        from posthog.schema import RefreshType
-
-        from posthog.hogql import ast
-        from posthog.hogql.property import property_to_expr
+        try:
+            saved_query = endpoint.saved_query
+            if not saved_query:
+                raise ValidationError("No materialized query found for this endpoint")
 
-        saved_query = endpoint.saved_query
-        if not saved_query:
-            raise ValidationError("No materialized query found for this endpoint")
+            select_query = ast.SelectQuery(
+                select=[ast.Field(chain=["*"])],
+                select_from=ast.JoinExpr(table=ast.Field(chain=[saved_query.name])),
+            )
 
-        # Build AST for SELECT * FROM table
-        select_query = ast.SelectQuery(
-            select=[ast.Field(chain=["*"])],
-            select_from=ast.JoinExpr(table=ast.Field(chain=[saved_query.name])),
-        )
+            if data.filters_override and data.filters_override.properties:
+                try:
+                    property_expr = property_to_expr(data.filters_override.properties, self.team)
+                    select_query.where = property_expr
+                except Exception:
+                    raise ValidationError("Failed to apply property filters.")
 
-        if data.filters_override and data.filters_override.properties:
-            try:
-                property_expr = property_to_expr(data.filters_override.properties, self.team)
-                select_query.where = property_expr
-            except Exception as e:
-                capture_exception(e)
-                raise ValidationError(f"Failed to apply property filters.")
-
-        materialized_hogql_query = HogQLQuery(
-            query=select_query.to_hogql(), modifiers=HogQLQueryModifiers(useMaterializedViews=True)
-        )
+            materialized_hogql_query = HogQLQuery(
+                query=select_query.to_hogql(), modifiers=HogQLQueryModifiers(useMaterializedViews=True)
+            )
 
-        query_request_data = {
-            "client_query_id": data.client_query_id,
-            "name": f"{endpoint.name}_materialized",
-            "refresh": data.refresh or RefreshType.BLOCKING,
-            "query": materialized_hogql_query.model_dump(),
-        }
+            query_request_data = {
+                "client_query_id": data.client_query_id,
+                "name": f"{endpoint.name}_materialized",
+                "refresh": data.refresh or RefreshType.BLOCKING,
+                "query": materialized_hogql_query.model_dump(),
+            }
 
-        extra_fields = {
-            "endpoint_materialized": True,
-            "endpoint_materialized_at": saved_query.last_run_at.isoformat() if saved_query.last_run_at else None,
-        }
-        tag_queries(workload=Workload.ENDPOINTS, warehouse_query=True)
+            extra_fields = {
+                "endpoint_materialized": True,
+                "endpoint_materialized_at": saved_query.last_run_at.isoformat() if saved_query.last_run_at else None,
+            }
+            tag_queries(workload=Workload.ENDPOINTS, warehouse_query=True)
 
-        return self._execute_query_and_respond(
-            query_request_data, data.client_query_id, request, extra_result_fields=extra_fields
-        )
+            return self._execute_query_and_respond(
+                query_request_data, data.client_query_id, request, extra_result_fields=extra_fields
+            )
+        except (ExposedHogQLError, ExposedCHQueryError, HogVMException) as e:
+            raise ValidationError(str(e), getattr(e, "code_name", None))
+        except ResolutionError as e:
+            raise ValidationError(str(e))
+        except ConcurrencyLimitExceeded as c:
+            raise Throttled(detail=str(c))
+        except Exception as e:
+            capture_exception(
+                e,
+                {
+                    "product": Product.ENDPOINTS,
+                    "team_id": self.team_id,
+                    "endpoint_name": endpoint.name,
+                    "materialized": True,
+                    "saved_query_id": saved_query.id if saved_query else None,
+                },
+            )
+            raise
 
     def _parse_variables(self, query: dict[str, dict], variables: dict[str, str]) -> dict[str, dict] | None:
         query_variables = query.get("variables", None)
@@ -550,7 +579,14 @@ def _execute_inline_endpoint(
             raise Throttled(detail=str(c))
         except Exception as e:
             self.handle_column_ch_error(e)
-            capture_exception(e)
+            capture_exception(
+                e,
+                {
+                    "product": Product.ENDPOINTS,
+                    "team_id": self.team_id,
+                    "endpoint_name": endpoint.name,
+                },
+            )
             raise
 
     @extend_schema(
@@ -655,7 +691,7 @@ def get_endpoints_last_execution_times(self, request: Request, *args, **kwargs)
         except ConcurrencyLimitExceeded as c:
             raise Throttled(detail=str(c))
         except Exception as e:
-            capture_exception(e)
+            capture_exception(e, {"product": Product.ENDPOINTS, "team_id": self.team_id})
             raise
 
     def handle_column_ch_error(self, error):