Merge remote-tracking branch 'origin/main' into sshin/uv

Author: suejung-sentry

graphql_api/tests/test_commit.py

@@ -3256,3 +3256,70 @@ def test_bundle_analysis_report_size_filtered_no_value(self, get_storage_service
                 "bundleDataFiltered": {"size": {"gzip": 20, "uncompress": 20}},
             },
         }
+
+    @patch("graphql_api.dataloader.bundle_analysis.get_appropriate_storage_service")
+    def test_bundle_analysis_asset_routes(self, get_storage_service):
+        storage = MemoryStorageService({})
+        get_storage_service.return_value = storage
+
+        head_commit_report = CommitReportFactory(
+            commit=self.commit, report_type=CommitReport.ReportType.BUNDLE_ANALYSIS
+        )
+
+        with open(
+            "./services/tests/samples/bundle_with_assets_and_modules.sqlite", "rb"
+        ) as f:
+            storage_path = StoragePaths.bundle_report.path(
+                repo_key=ArchiveService.get_archive_hash(self.repo),
+                report_key=head_commit_report.external_id,
+            )
+            storage.write_file(get_bucket_name(), storage_path, f)
+
+        query = """
+            query FetchCommit($org: String!, $repo: String!, $commit: String!) {
+                owner(username: $org) {
+                    repository(name: $repo) {
+                        ... on Repository {
+                            commit(id: $commit) {
+                                bundleAnalysis {
+                                    bundleAnalysisReport {
+                                        __typename
+                                        ... on BundleAnalysisReport {
+                                            bundle(name: "b5") {
+                                                asset(name: "assets/LazyComponent-fcbb0922.js") {
+                                                    name
+                                                    normalizedName
+                                                    routes
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        """
+
+        variables = {
+            "org": self.org.username,
+            "repo": self.repo.name,
+            "commit": self.commit.commitid,
+        }
+        data = self.gql_request(query, variables=variables)
+        commit = data["owner"]["repository"]["commit"]
+
+        asset_report = commit["bundleAnalysis"]["bundleAnalysisReport"]["bundle"][
+            "asset"
+        ]
+
+        assert asset_report is not None
+        assert asset_report["name"] == "assets/LazyComponent-fcbb0922.js"
+        assert asset_report["normalizedName"] == "assets/LazyComponent-*.js"
+        assert asset_report["routes"] == [
+            "/",
+            "/about",
+            "/login",
+            "/super/long/url/path",
+        ]

graphql_api/tests/test_views.py

@@ -1,7 +1,7 @@
 import json
 from unittest.mock import Mock, patch
 
-from ariadne import ObjectType, make_executable_schema
+from ariadne import ObjectType, gql, make_executable_schema
 from ariadne.validation import cost_directive
 from django.test import RequestFactory, TestCase, override_settings
 from django.urls import ResolverMatch
@@ -39,11 +39,34 @@ def generate_cost_test_schema():
     return make_executable_schema([types, cost_directive], query_bindable)
 
 
+def generate_schema_with_required_variables():
+    types = gql(
+        """
+        type Query {
+            person_exists(name: String!): Boolean
+            stuff: String
+        }
+        """
+    )
+    query_bindable = ObjectType("Query")
+
+    # Add a resolver for the `person_exists` field
+    @query_bindable.field("person_exists")
+    def resolve_person_exists(_, info, name):
+        return name is not None  # Example resolver logic
+
+    return make_executable_schema(types, query_bindable)
+
+
 class AriadneViewTestCase(GraphQLTestHelper, TestCase):
-    async def do_query(self, schema, query="{ failing }"):
+    async def do_query(self, schema, query="{ failing }", variables=None):
         view = AsyncGraphqlView.as_view(schema=schema)
+        data = {"query": query}
+        if variables is not None:
+            data["variables"] = variables
+
         request = RequestFactory().post(
-            "/graphql/gh", {"query": query}, content_type="application/json"
+            "/graphql/gh", data, content_type="application/json"
         )
         match = ResolverMatch(func=lambda: None, args=(), kwargs={"service": "github"})
 
@@ -256,3 +279,33 @@ def test_client_ip_from_remote_addr(self):
 
         result = view.get_client_ip(request)
         assert result == "lol"
+
+    async def test_required_variable_present(self):
+        schema = generate_schema_with_required_variables()
+
+        query = """
+        query ($name: String!) {
+            person_exists(name: $name)
+        }
+        """
+
+        #  Provide the variable
+        data = await self.do_query(schema, query=query, variables={"name": "Bob"})
+
+        assert data is not None
+        assert "data" in data
+        assert data["data"]["person_exists"] is True
+
+    async def test_required_variable_missing(self):
+        schema = generate_schema_with_required_variables()
+
+        query = """
+        query ($name: String!) {
+            person_exists(name: $name)
+        }
+        """
+
+        # Don't provide the variable
+        data = await self.do_query(schema, query=query, variables={})
+
+        assert data == {"detail": "Missing required variables: name", "status": 400}

graphql_api/types/bundle_analysis/base.graphql

@@ -55,6 +55,7 @@ type BundleAsset {
     after: DateTime
     branch: String
   ): BundleAnalysisMeasurements
+  routes: [String!]
 }
 
 type BundleReport {

graphql_api/types/bundle_analysis/base.py

@@ -158,6 +158,13 @@ def resolve_asset_report_measurements(
     return bundle_analysis_measurements.compute_asset(bundle_asset)
 
 
+@bundle_asset_bindable.field("routes")
+def resolve_routes(
+    bundle_asset: AssetReport, info: GraphQLResolveInfo
+) -> Optional[List[str]]:
+    return ["/", "/about", "/login", "/super/long/url/path"]
+
+
 # ============= Bundle Report Bindable =============
 
 

graphql_api/validation.py

@@ -1,10 +1,59 @@
-from typing import Any, Type
+from typing import Any, Dict, Type
 
 from graphql import GraphQLError, ValidationRule
-from graphql.language.ast import DocumentNode, FieldNode, OperationDefinitionNode
+from graphql.language.ast import (
+    DocumentNode,
+    FieldNode,
+    OperationDefinitionNode,
+    VariableDefinitionNode,
+)
 from graphql.validation import ValidationContext
 
 
+class MissingVariablesError(Exception):
+    """
+    Custom error class to represent errors where required variables defined in the query does
+    not have a matching definition in the variables part of the request. Normally when this
+    scenario occurs it would raise a GraphQLError type but that would cause a uncaught
+    exception for some reason. The aim of this is to surface the error in the response clearly
+    and to prevent internal server errors when it occurs.
+    """
+
+    pass
+
+
+def create_required_variables_rule(variables: Dict) -> Type[ValidationRule]:
+    class RequiredVariablesValidationRule(ValidationRule):
+        def __init__(self, context: ValidationContext) -> None:
+            super().__init__(context)
+            self.variables = variables
+
+        def enter_operation_definition(
+            self, node: OperationDefinitionNode, *_args: Any
+        ) -> None:
+            # Get variable definitions
+            variable_definitions = node.variable_definitions or []
+
+            # Extract variables marked as Non Null
+            required_variables = [
+                var_def.variable.name.value
+                for var_def in variable_definitions
+                if isinstance(var_def, VariableDefinitionNode)
+                and var_def.type.kind == "non_null_type"
+            ]
+
+            # Check if these required variables are provided
+            missing_variables = [
+                var for var in required_variables if var not in self.variables
+            ]
+            if missing_variables:
+                raise MissingVariablesError(
+                    f"Missing required variables: {', '.join(missing_variables)}",
+                )
+
+    return RequiredVariablesValidationRule
+
+
 def create_max_depth_rule(max_depth: int) -> Type[ValidationRule]:
     class MaxDepthRule(ValidationRule):
         def __init__(self, context: ValidationContext) -> None:

graphql_api/views.py

@@ -28,7 +28,12 @@
 from services.redis_configuration import get_redis_connection
 
 from .schema import schema
-from .validation import create_max_aliases_rule, create_max_depth_rule
+from .validation import (
+    MissingVariablesError,
+    create_max_aliases_rule,
+    create_max_depth_rule,
+    create_required_variables_rule,
+)
 
 log = logging.getLogger(__name__)
 
@@ -198,6 +203,7 @@ def get_validation_rules(
         data: dict,
     ) -> Optional[Collection]:
         return [
+            create_required_variables_rule(variables=data.get("variables")),
             create_max_aliases_rule(max_aliases=settings.GRAPHQL_MAX_ALIASES),
             create_max_depth_rule(max_depth=settings.GRAPHQL_MAX_DEPTH),
             cost_validator(
@@ -259,7 +265,16 @@ async def post(self, request, *args, **kwargs):
             )
 
         with RequestFinalizer(request):
-            response = await super().post(request, *args, **kwargs)
+            try:
+                response = await super().post(request, *args, **kwargs)
+            except MissingVariablesError as e:
+                return JsonResponse(
+                    data={
+                        "status": 400,
+                        "detail": str(e),
+                    },
+                    status=400,
+                )
 
             content = response.content.decode("utf-8")
             data = json.loads(content)

gunicorn.conf.py

@@ -1,8 +1,48 @@
+import logging
 import os
 
+from gunicorn.glogging import Logger
 from prometheus_client import multiprocess
 
 
 def child_exit(server, worker):
     if worker and worker.pid and "PROMETHEUS_MULTIPROC_DIR" in os.environ:
         multiprocess.mark_process_dead(worker.pid)
+
+
+class CustomGunicornLogger(Logger):
+    """
+    A custom class for logging gunicorn startup logs, these are for the logging that takes
+    place before the Django app starts and takes over with its own defined logging formats.
+    This class ensures the gunicorn minimum log level to be INFO instead of the default ERROR.
+    """
+
+    def setup(self, cfg):
+        super().setup(cfg)
+        custom_format = "[%(levelname)s] [%(process)d] [%(asctime)s] %(message)s "
+        date_format = "%Y-%m-%d %H:%M:%S %z"
+        formatter = logging.Formatter(fmt=custom_format, datefmt=date_format)
+
+        # Update handlers with the custom formatter
+        for handler in self.error_log.handlers:
+            handler.setFormatter(formatter)
+        for handler in self.access_log.handlers:
+            handler.setFormatter(formatter)
+
+
+logconfig_dict = {
+    "loggers": {
+        "gunicorn.error": {
+            "level": "INFO",
+            "handlers": ["console"],
+            "propagate": False,
+        },
+        "gunicorn.access": {
+            "level": "INFO",
+            "handlers": ["console"],
+            "propagate": False,
+        },
+    }
+}
+
+logger_class = CustomGunicornLogger

requirements.in

@@ -0,0 +1,61 @@
+aiodataloader
+ariadne==0.23
+ariadne_django==0.3.0
+celery>=5.3.6
+cerberus
+ddtrace
+Django>=4.2.16
+django-cors-headers
+django-csp
+django-dynamic-fixture
+django-filter
+django-model-utils
+django-postgres-extra>=2.0.8
+django-prometheus
+djangorestframework==3.15.2
+drf-spectacular
+drf-spectacular-sidecar
+elastic-apm
+factory-boy
+fakeredis
+freezegun
+https://github.com/codecov/opentelem-python/archive/refs/tags/v0.0.4a1.tar.gz#egg=codecovopentelem
+https://github.com/codecov/shared/archive/f96b72f47583a083e0c78ec7c7ff4da5d3ad6a19.tar.gz#egg=shared
+google-cloud-pubsub
+gunicorn>=22.0.0
+https://github.com/photocrowd/django-cursor-pagination/archive/f560902696b0c8509e4d95c10ba0d62700181d84.tar.gz
+idna>=3.7
+minio
+oauth2==1.9.0.post1
+opentelemetry-instrumentation-django>=0.45b0
+opentelemetry-sdk>=1.24.0
+opentracing
+polars==1.12.0
+pre-commit
+psycopg2
+PyJWT
+pydantic
+pytest>=7.2.0
+pytest-cov
+pytest-django
+pytest-mock
+pytest-asyncio
+python-dateutil
+python-json-logger
+python-redis-lock
+pytz
+redis
+regex
+requests
+sentry-sdk>=2.13.0
+sentry-sdk[celery]
+setproctitle
+simplejson
+starlette==0.40.0
+stripe>=9.6.0
+urllib3>=1.26.19
+vcrpy
+whitenoise
+django-autocomplete-light
+django-better-admin-arrayfield
+certifi>=2024.07.04