agent-starter-pack 0.3.3__py3-none-any.whl → 0.21.0__py3-none-any.whl

agents/live_api/tests/load_test/load_test.py

@@ -1,40 +0,0 @@
-# Copyright 2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import time
-
-from locust import HttpUser, between, task
-
-
-class DummyUser(HttpUser):
-    """Simulates a user for testing purposes."""
-
-    wait_time = between(1, 3)  # Wait 1-3 seconds between tasks
-
-    @task
-    def dummy_task(self) -> None:
-        """A dummy task that simulates work without making actual requests."""
-        # Simulate some processing time
-        time.sleep(0.1)
-
-        # Record a successful dummy request
-        self.environment.events.request.fire(
-            request_type="POST",
-            name="dummy_endpoint",
-            response_time=100,
-            response_length=1024,
-            response=None,
-            context={},
-            exception=None,
-        )

agents/live_api/tests/unit/test_server.py

@@ -1,143 +0,0 @@
-# Copyright 2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import json
-import logging
-import os
-from collections.abc import Generator
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-from fastapi.testclient import TestClient
-from google.auth.credentials import Credentials
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-@pytest.fixture(autouse=True)
-def mock_google_cloud_credentials() -> Generator[None, None, None]:
-    """Mock Google Cloud credentials for testing."""
-    with patch.dict(
-        os.environ,
-        {
-            "GOOGLE_APPLICATION_CREDENTIALS": "/path/to/mock/credentials.json",
-            "GOOGLE_CLOUD_PROJECT_ID": "mock-project-id",
-        },
-    ):
-        yield
-
-
-@pytest.fixture(autouse=True)
-def mock_google_auth_default() -> Generator[None, None, None]:
-    """Mock the google.auth.default function for testing."""
-    mock_credentials = MagicMock(spec=Credentials)
-    mock_project = "mock-project-id"
-
-    with patch("google.auth.default", return_value=(mock_credentials, mock_project)):
-        yield
-
-
-@pytest.fixture(autouse=True)
-def mock_dependencies() -> Generator[None, None, None]:
-    """
-    Mock Vertex AI dependencies for testing.
-    Patches genai client and tool functions.
-    """
-    with (
-        patch("app.server.genai_client") as mock_genai,
-        patch("app.server.tool_functions") as mock_tools,
-    ):
-        mock_genai.aio.live.connect = AsyncMock()
-        mock_tools.return_value = {}
-        yield
-
-
-@pytest.mark.asyncio
-async def test_websocket_endpoint() -> None:
-    """
-    Test the websocket endpoint to ensure it correctly handles
-    websocket connections and messages.
-    """
-    from app.server import app
-
-    mock_session = AsyncMock()
-    mock_session._ws = AsyncMock()
-    # Configure mock to return proper response format and close after one message
-    mock_session._ws.recv.side_effect = [
-        json.dumps(
-            {
-                "serverContent": {
-                    "modelTurn": {
-                        "role": "model",
-                        "parts": [{"text": "Hello, how can I help you?"}],
-                    }
-                }
-            }
-        ).encode(),  # Encode as bytes since recv(decode=False) is used
-        None,  # Add None to trigger StopAsyncIteration after first message
-    ]
-
-    with patch("app.server.genai_client") as mock_genai:
-        mock_genai.aio.live.connect.return_value.__aenter__.return_value = mock_session
-        client = TestClient(app)
-        with client.websocket_connect("/ws") as websocket:
-            # Test initial connection message
-            data = websocket.receive_json()
-            assert data["status"] == "Backend is ready for conversation"
-
-            # Test sending a message
-            websocket.send_json(
-                {"setup": {"run_id": "test-run", "user_id": "test-user"}}
-            )
-
-            # Test sending audio stream
-            dummy_audio = bytes([0] * 1024)  # 1KB of silence
-            websocket.send_json(
-                {
-                    "realtimeInput": {
-                        "mediaChunks": [
-                            {
-                                "mimeType": "audio/pcm;rate=16000",
-                                "data": dummy_audio.hex(),
-                            }
-                        ]
-                    }
-                }
-            )
-
-            # Receive response as bytes
-            response = websocket.receive_bytes()
-            response_data = json.loads(response.decode())
-            assert "serverContent" in response_data
-
-            # Verify mock interactions
-            mock_genai.aio.live.connect.assert_called_once()
-            assert mock_session._ws.recv.called
-
-
-@pytest.mark.asyncio
-async def test_websocket_error_handling() -> None:
-    """Test websocket error handling."""
-    from app.server import app
-
-    with patch("app.server.genai_client") as mock_genai:
-        mock_genai.aio.live.connect.side_effect = Exception("Connection failed")
-
-        client = TestClient(app)
-        with pytest.raises(Exception) as exc:
-            with client.websocket_connect("/ws"):
-                pass
-        assert str(exc.value) == "Connection failed"

src/base_template/Makefile

@@ -1,72 +0,0 @@
-install:
-	@command -v uv >/dev/null 2>&1 || { echo "uv is not installed. Installing uv..."; curl -LsSf https://astral.sh/uv/0.6.12/install.sh | sh; source ~/.bashrc; }
-	uv sync --dev{% if cookiecutter.agent_name != 'live_api' and "adk" not in cookiecutter.tags %} --extra streamlit{%- endif %} --extra jupyter --frozen{% if cookiecutter.agent_name == 'live_api' %} && npm --prefix frontend install{%- endif %}
-
-test:
-	uv run pytest tests/unit && uv run pytest tests/integration
-
-playground:
-{%- if "adk" in cookiecutter.tags %}
-	@echo "+-----------------------------------------------------------------------------+"
-	@echo "| Starting ADK Web Server via 'adk web' command.                              |"
-	@echo "|                                                                             |"
-	@echo "| Please select the app folder to start interacting with your agent.          |"
-	@echo "+-----------------------------------------------------------------------------+"
-	uv run adk web
-{%- else %}
-{%- if cookiecutter.deployment_target == 'cloud_run' %}
-	uv run uvicorn app.server:app --host 0.0.0.0 --port 8000 --reload &
-{%- endif %}
-{%- if cookiecutter.agent_name == 'live_api' %}
-	npm --prefix frontend start
-{%- else %}
-	{% if cookiecutter.deployment_target == 'agent_engine' %}PYTHONPATH=. {% endif %}uv run streamlit run frontend/streamlit_app.py --browser.serverAddress=localhost --server.enableCORS=false --server.enableXsrfProtection=false
-{%- endif %}
-{%- endif %}
-
-backend:
-{%- if cookiecutter.deployment_target == 'cloud_run' %}
-	uv run uvicorn app.server:app --host 0.0.0.0 --port 8000 --reload
-{%- elif cookiecutter.deployment_target == 'agent_engine' %}
-	# Export dependencies to requirements file using uv export (preferred method), otherwise fall back to uv pip freeze
-	uv export --no-hashes --no-sources --no-header --no-dev --no-emit-project --no-annotate --frozen > .requirements.txt 2>/dev/null || \
-	uv pip freeze --exclude-editable > .requirements.txt && uv run app/agent_engine_app.py
-{%- endif %}
-
-{% if cookiecutter.deployment_target == 'cloud_run' -%}
-ui:
-{%- if cookiecutter.agent_name == 'live_api' %}
-	npm --prefix frontend start
-{%- else %}
-	uv run streamlit run streamlit/streamlit_app.py --browser.serverAddress=localhost --server.enableCORS=false --server.enableXsrfProtection=false
-{%- endif %}
-{%- endif %}
-
-setup-dev-env:
-	@if [ -z "$$PROJECT_ID" ]; then echo "Error: PROJECT_ID environment variable is not set"; exit 1; fi
-	(cd deployment/terraform/dev && terraform init && terraform apply --var-file vars/env.tfvars --var dev_project_id=$$PROJECT_ID --auto-approve)
-{% if cookiecutter.data_ingestion %}
-data-ingestion:
-	@if [ -z "$$PROJECT_ID" ]; then echo "Error: PROJECT_ID environment variable is not set"; exit 1; fi
-	$(MAKE) install
-	(cd data_ingestion && uv run data_ingestion_pipeline/submit_pipeline.py \
-		--project-id=$$PROJECT_ID \
-		--region="us-central1" \
-{%- if cookiecutter.datastore_type == "vertex_ai_search" %}
-		--data-store-id="{{cookiecutter.project_name}}-datastore" \
-		--data-store-region="us" \
-{%- elif cookiecutter.datastore_type == "vertex_ai_vector_search" %}
-		--vector-search-index="{{cookiecutter.project_name}}-vector-search" \
-		--vector-search-index-endpoint="{{cookiecutter.project_name}}-vector-search-endpoint" \
-		--vector-search-data-bucket-name="$$PROJECT_ID-{{cookiecutter.project_name}}-vs" \
-{%- endif %}
-		--service-account="{{cookiecutter.project_name}}-rag@$$PROJECT_ID.iam.gserviceaccount.com" \
-		--pipeline-root="gs://$$PROJECT_ID-{{cookiecutter.project_name}}-rag" \
-		--pipeline-name="data-ingestion-pipeline")
-{%- endif %}
-
-lint:
-	uv run codespell
-	uv run ruff check . --diff
-	uv run ruff format . --check --diff
-	uv run mypy .

src/base_template/README.md

@@ -1,208 +0,0 @@
-# {{cookiecutter.project_name}}
-
-{{cookiecutter.agent_description}}
-Agent generated with [`googleCloudPlatform/agent-starter-pack`](https://github.com/GoogleCloudPlatform/agent-starter-pack) version `{{ cookiecutter.package_version }}`
-
-## Project Structure
-
-This project is organized as follows:
-
-```
-{{cookiecutter.project_name}}/
-├── app/                 # Core application code
-│   ├── agent.py         # Main agent logic
-{%- if cookiecutter.deployment_target == 'cloud_run' %}
-│   ├── server.py        # FastAPI Backend server
-{%- elif cookiecutter.deployment_target == 'agent_engine' %}
-│   ├── agent_engine_app.py # Agent Engine application logic
-{%- endif %}
-│   └── utils/           # Utility functions and helpers
-├── deployment/          # Infrastructure and deployment scripts
-├── notebooks/           # Jupyter notebooks for prototyping and evaluation
-├── tests/               # Unit, integration, and load tests
-├── Makefile             # Makefile for common commands
-└── pyproject.toml       # Project dependencies and configuration
-```
-
-## Requirements
-
-Before you begin, ensure you have:
-- **uv**: Python package manager - [Install](https://docs.astral.sh/uv/getting-started/installation/)
-- **Google Cloud SDK**: For GCP services - [Install](https://cloud.google.com/sdk/docs/install)
-- **Terraform**: For infrastructure deployment - [Install](https://developer.hashicorp.com/terraform/downloads)
-- **make**: Build automation tool - [Install](https://www.gnu.org/software/make/) (pre-installed on most Unix-based systems)
-
-
-## Quick Start (Local Testing)
-
-Install required packages and launch the local development environment:
-
-```bash
-make install && make playground
-```
-
-## Commands
-
-| Command              | Description                                                                                 |
-| -------------------- | ------------------------------------------------------------------------------------------- |
-| `make install`       | Install all required dependencies using uv                                                  |
-{%- if cookiecutter.deployment_target == 'cloud_run' %}
-| `make playground`    | Launch local development environment with backend and frontend{%- if "adk" in cookiecutter.tags %} - leveraging `adk web` command. {%- endif %}|
-| `make backend`       | Start backend server only |
-| `make ui`            | Launch Streamlit frontend without local backend |
-{%- elif cookiecutter.deployment_target == 'agent_engine' %}
-| `make playground`    | Launch Streamlit interface for testing agent locally and remotely |
-| `make backend`       | Deploy agent to Agent Engine service |
-{%- endif %}
-| `make test`          | Run unit and integration tests                                                              |
-| `make lint`          | Run code quality checks (codespell, ruff, mypy)                                             |
-| `make setup-dev-env` | Set up development environment resources using Terraform                                    |
-{%- if cookiecutter.data_ingestion %}
-| `make data-ingestion`| Run data ingestion pipeline in the Dev environment                                           |
-{%- endif %}
-| `uv run jupyter lab` | Launch Jupyter notebook                                                                     |
-
-For full command options and usage, refer to the [Makefile](Makefile).
-
-{% if cookiecutter.agent_name == 'live_api' %}
-## Usage
-
-This template follows a "bring your own agent" approach - you focus on your business logic in `app/agent.py`, and the template handles the surrounding components (UI, infrastructure, deployment, monitoring).
-
-Here’s the recommended workflow for local development:
-
-1.  **Install Dependencies (if needed):**
-    ```bash
-    make install
-    ```
-
-2.  **Start the Backend Server:**
-    Open a terminal and run:
-    ```bash
-    make backend
-    ```
-    The backend is ready when you see `INFO:     Application startup complete.` Wait for this message before starting the frontend.
-
-    <details>
-    <summary><b>Optional: Use AI Studio / API Key instead of Vertex AI</b></summary>
-
-    By default, the backend uses Vertex AI and Application Default Credentials. If you prefer to use Google AI Studio and an API key:
-
-    ```bash
-    export VERTEXAI=false
-    export GOOGLE_API_KEY="your-google-api-key" # Replace with your actual key
-    make backend
-    ```
-    Ensure `GOOGLE_API_KEY` is set correctly in your environment.
-    </details>
-    <br>
-
-3.  **Start the Frontend UI:**
-    Open *another* terminal and run:
-    ```bash
-    make ui
-    ```
-    This launches the Streamlit application, which connects to the backend server (by default at `http://localhost:8000`).
-
-4.  **Interact and Iterate:**
-    *   Open the Streamlit UI in your browser (usually `http://localhost:3000` or `http://localhost:3001`).
-    *   Click the play button in the UI to connect to the backend.
-    *   Interact with the agent! Try prompts like: *"Using the tool you have, define Governance in the context MLOPs"*
-    *   Modify the agent logic in `app/agent.py`. The backend server (FastAPI with `uvicorn --reload`) should automatically restart when you save changes. Refresh the frontend if needed to see behavioral changes.
-
-<details>
-<summary><b>Cloud Shell Usage</b></summary>
-
-To run the agent using Google Cloud Shell:
-
-1.  **Start the Frontend:**
-    In a Cloud Shell tab, run:
-    ```bash
-    make ui
-    ```
-    Accept prompts to use a different port if 3000 is busy. Click the `localhost:PORT` link for the web preview.
-
-2.  **Start the Backend:**
-    Open a *new* Cloud Shell tab. Set your project: `gcloud config set project [PROJECT_ID]`. Then run:
-    ```bash
-    make backend
-    ```
-
-3.  **Configure Backend Web Preview:**
-    Use the Cloud Shell Web Preview feature to expose port 8000. Change the default port from 8080 to 8000. See [Cloud Shell Web Preview documentation](https://cloud.google.com/shell/docs/using-web-preview#preview_the_application).
-
-4.  **Connect Frontend to Backend:**
-    *   Copy the URL generated by the backend web preview (e.g., `https://8000-cs-....cloudshell.dev/`).
-    *   Paste this URL into the "Server URL" field in the frontend UI settings (in the first tab).
-    *   Click the "Play button" to connect.
-
-*   **Note:** The feedback feature in the frontend might not work reliably in Cloud Shell due to cross-origin issues between the preview URLs.
-</details>
-
-</details>
-{%- else %}
-## Usage
-
-This template follows a "bring your own agent" approach - you focus on your business logic, and the template handles everything else (UI, infrastructure, deployment, monitoring).
-
-1. **Prototype:** Build your Generative AI Agent using the intro notebooks in `notebooks/` for guidance. Use Vertex AI Evaluation to assess performance.
-2. **Integrate:** Import your agent into the app by editing `app/agent.py`.
-3. **Test:** Explore your agent functionality using the Streamlit playground with `make playground`. The playground offers features like chat history, user feedback, and various input types, and automatically reloads your agent on code changes.
-4. **Deploy:** Set up and initiate the CI/CD pipelines, customizing tests as necessary. Refer to the [deployment section](#deployment) for comprehensive instructions. For streamlined infrastructure deployment, simply run `agent-starter-pack setup-cicd`. Check out the [`agent-starter-pack setup-cicd` CLI command](https://github.com/GoogleCloudPlatform/agent-starter-pack/blob/main/docs/cli/setup_cicd.md). Currently only supporting Github.
-5. **Monitor:** Track performance and gather insights using Cloud Logging, Tracing, and the Looker Studio dashboard to iterate on your application.
-{% endif %}
-
-## Deployment
-
-> **Note:** For a streamlined one-command deployment of the entire CI/CD pipeline and infrastructure using Terraform, you can use the [`agent-starter-pack setup-cicd` CLI command](https://github.com/GoogleCloudPlatform/agent-starter-pack/blob/main/docs/cli/setup_cicd.md). Currently only supporting Github.
-
-### Dev Environment
-
-{%- if cookiecutter.deployment_target == 'agent_engine' %}
-You can test deployment towards a Dev Environment using the following command:
-
-```bash
-gcloud config set project <your-dev-project-id>
-make backend
-```
-{%- elif cookiecutter.deployment_target == 'cloud_run' %}
-Deploy the application directly to Cloud Run from your source code using the following `gcloud` command:
-
-```bash
-gcloud run deploy genai-app-sample \
-  --source . \
-  --project YOUR_PROJECT_ID \
-  --region YOUR_GCP_REGION \
-  --memory "4Gi" \
-```
-Replace `YOUR_PROJECT_ID` with your Google Cloud project ID and `YOUR_GCP_REGION` with the desired region (e.g., `us-central1`). Adjust memory and other flags as needed for your environment.
-{% if cookiecutter.agent_name == 'live_api' %}
-**Accessing the Deployed Backend Locally:**
-
-To connect your local frontend (`make ui`) to the backend deployed on Cloud Run, use the `gcloud` proxy:
-
-1.  **Start the proxy:**
-    ```bash
-    # Replace with your actual service name, project, and region
-    gcloud run services proxy gemini-agent-service --port 8000 --project $PROJECT_ID --region $REGION
-    ```
-    Keep this terminal running.
-
-2.  **Connect Frontend:** Your deployed backend is now accessible locally at `http://localhost:8000`. Point your Streamlit UI to this address.
-{%- endif %}
-{%- endif %}
-
-The repository includes a Terraform configuration for the setup of the Dev Google Cloud project.
-See [deployment/README.md](deployment/README.md) for instructions.
-
-### Production Deployment
-
-The repository includes a Terraform configuration for the setup of a production Google Cloud project. Refer to [deployment/README.md](deployment/README.md) for detailed instructions on how to deploy the infrastructure and application.
-
-{% if cookiecutter.agent_name != 'live_api' %}
-## Monitoring and Observability
-
-> You can use [this Looker Studio dashboard](https://lookerstudio.google.com/c/reporting/fa742264-4b4b-4c56-81e6-a667dd0f853f/page/tEnnC) template for visualizing events being logged in BigQuery. See the "Setup Instructions" tab to getting started.
-
-The application uses OpenTelemetry for comprehensive observability with all events being sent to Google Cloud Trace and Logging for monitoring and to BigQuery for long term storage. 
-{%- endif %}

src/base_template/app/__init__.py

@@ -1,3 +0,0 @@
-from app.agent import root_agent
-
-__all__ = ["root_agent"]

src/base_template/app/utils/tracing.py

@@ -1,155 +0,0 @@
-# Copyright 2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import json
-import logging
-from collections.abc import Sequence
-from typing import Any
-
-import google.cloud.storage as storage
-from google.cloud import logging as google_cloud_logging
-from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter
-from opentelemetry.sdk.trace import ReadableSpan
-from opentelemetry.sdk.trace.export import SpanExportResult
-
-
-class CloudTraceLoggingSpanExporter(CloudTraceSpanExporter):
-    """
-    An extended version of CloudTraceSpanExporter that logs span data to Google Cloud Logging
-    and handles large attribute values by storing them in Google Cloud Storage.
-
-    This class helps bypass the 256 character limit of Cloud Trace for attribute values
-    by leveraging Cloud Logging (which has a 256KB limit) and Cloud Storage for larger payloads.
-    """
-
-    def __init__(
-        self,
-        logging_client: google_cloud_logging.Client | None = None,
-        storage_client: storage.Client | None = None,
-        bucket_name: str | None = None,
-        debug: bool = False,
-        **kwargs: Any,
-    ) -> None:
-        """
-        Initialize the exporter with Google Cloud clients and configuration.
-
-        :param logging_client: Google Cloud Logging client
-        :param storage_client: Google Cloud Storage client
-        :param bucket_name: Name of the GCS bucket to store large payloads
-        :param debug: Enable debug mode for additional logging
-        :param kwargs: Additional arguments to pass to the parent class
-        """
-        super().__init__(**kwargs)
-        self.debug = debug
-        self.logging_client = logging_client or google_cloud_logging.Client(
-            project=self.project_id
-        )
-        self.logger = self.logging_client.logger(__name__)
-        self.storage_client = storage_client or storage.Client(project=self.project_id)
-        self.bucket_name = (
-            bucket_name or f"{self.project_id}-{{cookiecutter.project_name}}-logs-data"
-        )
-        self.bucket = self.storage_client.bucket(self.bucket_name)
-
-    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
-        """
-        Export the spans to Google Cloud Logging and Cloud Trace.
-
-        :param spans: A sequence of spans to export
-        :return: The result of the export operation
-        """
-        for span in spans:
-            span_context = span.get_span_context()
-            trace_id = format(span_context.trace_id, "x")
-            span_id = format(span_context.span_id, "x")
-            span_dict = json.loads(span.to_json())
-
-            span_dict["trace"] = f"projects/{self.project_id}/traces/{trace_id}"
-            span_dict["span_id"] = span_id
-
-            span_dict = self._process_large_attributes(
-                span_dict=span_dict, span_id=span_id
-            )
-
-            if self.debug:
-                print(span_dict)
-
-            # Log the span data to Google Cloud Logging
-{%- if "adk" in cookiecutter.tags %}
-            self.logger.log_struct(
-                span_dict,
-                labels={
-                    "type": "agent_telemetry",
-                    "service_name": "{{cookiecutter.project_name}}",
-                },
-                severity="INFO",
-            )
-{%- else %}
-            self.logger.log_struct(span_dict, severity="INFO")
-{%- endif %}
-        # Export spans to Google Cloud Trace using the parent class method
-        return super().export(spans)
-
-    def store_in_gcs(self, content: str, span_id: str) -> str:
-        """
-        Initiate storing large content in Google Cloud Storage/
-
-        :param content: The content to store
-        :param span_id: The ID of the span
-        :return: The  GCS URI of the stored content
-        """
-        if not self.storage_client.bucket(self.bucket_name).exists():
-            logging.warning(
-                f"Bucket {self.bucket_name} not found. "
-                "Unable to store span attributes in GCS."
-            )
-            return "GCS bucket not found"
-
-        blob_name = f"spans/{span_id}.json"
-        blob = self.bucket.blob(blob_name)
-
-        blob.upload_from_string(content, "application/json")
-        return f"gs://{self.bucket_name}/{blob_name}"
-
-    def _process_large_attributes(self, span_dict: dict, span_id: str) -> dict:
-        """
-        Process large attribute values by storing them in GCS if they exceed the size
-        limit of Google Cloud Logging.
-
-        :param span_dict: The span data dictionary
-        :param trace_id: The trace ID
-        :param span_id: The span ID
-        :return: The updated span dictionary
-        """
-        attributes = span_dict["attributes"]
-        if len(json.dumps(attributes).encode()) > 255 * 1024:  # 250 KB
-            # Separate large payload from other attributes
-            attributes_payload = dict(attributes.items())
-            attributes_retain = dict(attributes.items())
-
-            # Store large payload in GCS
-            gcs_uri = self.store_in_gcs(json.dumps(attributes_payload), span_id)
-            attributes_retain["uri_payload"] = gcs_uri
-            attributes_retain["url_payload"] = (
-                f"https://storage.mtls.cloud.google.com/"
-                f"{self.bucket_name}/spans/{span_id}.json"
-            )
-
-            span_dict["attributes"] = attributes_retain
-            logging.info(
-                "Length of payload span above 250 KB, storing attributes in GCS "
-                "to avoid large log entry errors"
-            )
-
-        return span_dict