measurement-api 0.1.0__tar.gz

measurement_api-0.1.0/AUTHORS.md

@@ -0,0 +1,6 @@
+# Authors
+
+## Lead Developer
+* **Andrii Bogdanovych**
+    * [bogdanovych.org](https://www.bogdanovych.org/)
+    * ORCID: [0009-0006-9045-5675](https://orcid.org/0009-0006-9045-5675)

measurement_api-0.1.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2026 Andrii Bogdanovych
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

measurement_api-0.1.0/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: measurement-api
+Version: 0.1.0
+Summary: A lightweight asynchronous Python client for the Google Analytics 4 Measurement Protocol
+Author-email: Andrii Bogdanovych <a@bogdanovych.org>
+License-Expression: MIT
+Project-URL: Homepage, https://www.bogdanovych.org
+Project-URL: Repository, https://github.com/BogdanovychA/measurement-api
+Project-URL: Bug Tracker, https://github.com/BogdanovychA/measurement-api/issues
+Project-URL: AI Agent Skill, https://skills.sh/bogdanovycha/measurement-api/measurement-api
+Keywords: google-analytics,ga4,measurement-protocol,async,asyncio,httpx,analytics
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS.md
+Requires-Dist: httpx>=0.24.0
+Dynamic: license-file
+
+# measurement-api
+
+A lightweight asynchronous Python client for the Google Analytics 4 (GA4) Measurement Protocol.
+
+[![PyPI version](https://img.shields.io/pypi/v/measurement-api.svg)](https://pypi.org/project/measurement-api/)
+[![Python versions](https://img.shields.io/pypi/pyversions/measurement-api.svg)](https://pypi.org/project/measurement-api/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- ⚡ **Asynchronous**: Built on top of `httpx` for efficient, non-blocking requests.
+- 🔄 **Connection Pooling**: Supports async context manager syntax and custom `httpx.AsyncClient` injection to share/reuse TCP connections.
+- 🐛 **Validation Mode**: Integrates with GA4's validation server `/debug/mp/collect` to verify your payloads without logging dummy events in production.
+- 📦 **Complex Event Parameters**: Supports nested structures like lists (e.g. for E-commerce tracking `items`), dictionaries, and primitives.
+
+## Installation
+
+Install using `pip`:
+
+```bash
+pip install measurement-api
+```
+
+Or using `uv`:
+
+```bash
+uv add measurement-api
+```
+
+## Quickstart
+
+### Basic Async Usage
+
+```python
+import asyncio
+from measurement_api import MeasurementAPI
+
+async def main():
+    # Initialize the client
+    api = MeasurementAPI(
+        m10t_id="G-XXXXXXXXXX",
+        secret_key="your_api_secret_key"
+    )
+
+    # Log an event
+    success = await api.log_event(
+        client_id="user_12345",
+        event_name="button_click",
+        button_id="submit_form",
+        page_url="https://example.com"
+    )
+
+    if success:
+        print("Event sent successfully!")
+    else:
+        print("Failed to send event.")
+
+asyncio.run(main())
+```
+
+## Advanced Usage
+
+### Context Manager (Connection Reuse)
+
+When sending multiple events, use the async context manager to reuse the HTTP client's connection pool. This avoids the overhead of establishing a new TCP/TLS connection for every single event.
+
+```python
+import asyncio
+from measurement_api import MeasurementAPI
+
+async def main():
+    async with MeasurementAPI("G-XXXXXXXXXX", "your_secret") as api:
+        # Both events share the same connection pool
+        await api.log_event("user_1", "view_item", item_name="T-Shirt")
+        await api.log_event("user_1", "add_to_cart", item_name="T-Shirt")
+
+asyncio.run(main())
+```
+
+### Passing a Custom `httpx.AsyncClient`
+
+If your application already manages a global HTTP client (e.g. in FastAPI or Sanic), you can inject it directly:
+
+```python
+import httpx
+from measurement_api import MeasurementAPI
+
+async def send_analytics():
+    # Inject your own shared client
+    async with httpx.AsyncClient() as shared_client:
+        api = MeasurementAPI(
+            "G-XXXXXXXXXX",
+            "your_secret",
+            client=shared_client
+        )
+
+        # This will not close the injected client on exit or completion
+        await api.log_event("user_1", "purchase", value=99.99)
+```
+
+### Debug & Validation Mode
+
+To validate your event structure against Google's GA4 validation server, initialize the client with `debug=True`.
+*Note: Events sent to the validation server do not show up in GA4 reports.*
+
+```python
+from measurement_api import MeasurementAPI
+
+api = MeasurementAPI("G-XXXXXXXXXX", "your_secret", debug=True)
+
+# This request goes to https://www.google-analytics.com/debug/mp/collect
+# Returns True if validation passes, False if there are validation warnings/errors
+success = await api.log_event("user_1", "purchase", items=[{"item_id": "SKU_123"}])
+```
+
+## Development & Testing
+
+### Running Tests
+
+We use `pytest` and `respx` to test the client offline without sending actual requests to Google Analytics.
+
+1. Install dependencies:
+   ```bash
+   uv sync --group dev
+   ```
+
+2. Run the test suite:
+   ```bash
+   uv run pytest
+   ```
+
+3. Run linting checks:
+   ```bash
+   uv run ruff check
+   ```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

measurement_api-0.1.0/README.md

@@ -0,0 +1,139 @@
+# measurement-api
+
+A lightweight asynchronous Python client for the Google Analytics 4 (GA4) Measurement Protocol.
+
+[![PyPI version](https://img.shields.io/pypi/v/measurement-api.svg)](https://pypi.org/project/measurement-api/)
+[![Python versions](https://img.shields.io/pypi/pyversions/measurement-api.svg)](https://pypi.org/project/measurement-api/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- ⚡ **Asynchronous**: Built on top of `httpx` for efficient, non-blocking requests.
+- 🔄 **Connection Pooling**: Supports async context manager syntax and custom `httpx.AsyncClient` injection to share/reuse TCP connections.
+- 🐛 **Validation Mode**: Integrates with GA4's validation server `/debug/mp/collect` to verify your payloads without logging dummy events in production.
+- 📦 **Complex Event Parameters**: Supports nested structures like lists (e.g. for E-commerce tracking `items`), dictionaries, and primitives.
+
+## Installation
+
+Install using `pip`:
+
+```bash
+pip install measurement-api
+```
+
+Or using `uv`:
+
+```bash
+uv add measurement-api
+```
+
+## Quickstart
+
+### Basic Async Usage
+
+```python
+import asyncio
+from measurement_api import MeasurementAPI
+
+async def main():
+    # Initialize the client
+    api = MeasurementAPI(
+        m10t_id="G-XXXXXXXXXX",
+        secret_key="your_api_secret_key"
+    )
+
+    # Log an event
+    success = await api.log_event(
+        client_id="user_12345",
+        event_name="button_click",
+        button_id="submit_form",
+        page_url="https://example.com"
+    )
+
+    if success:
+        print("Event sent successfully!")
+    else:
+        print("Failed to send event.")
+
+asyncio.run(main())
+```
+
+## Advanced Usage
+
+### Context Manager (Connection Reuse)
+
+When sending multiple events, use the async context manager to reuse the HTTP client's connection pool. This avoids the overhead of establishing a new TCP/TLS connection for every single event.
+
+```python
+import asyncio
+from measurement_api import MeasurementAPI
+
+async def main():
+    async with MeasurementAPI("G-XXXXXXXXXX", "your_secret") as api:
+        # Both events share the same connection pool
+        await api.log_event("user_1", "view_item", item_name="T-Shirt")
+        await api.log_event("user_1", "add_to_cart", item_name="T-Shirt")
+
+asyncio.run(main())
+```
+
+### Passing a Custom `httpx.AsyncClient`
+
+If your application already manages a global HTTP client (e.g. in FastAPI or Sanic), you can inject it directly:
+
+```python
+import httpx
+from measurement_api import MeasurementAPI
+
+async def send_analytics():
+    # Inject your own shared client
+    async with httpx.AsyncClient() as shared_client:
+        api = MeasurementAPI(
+            "G-XXXXXXXXXX",
+            "your_secret",
+            client=shared_client
+        )
+
+        # This will not close the injected client on exit or completion
+        await api.log_event("user_1", "purchase", value=99.99)
+```
+
+### Debug & Validation Mode
+
+To validate your event structure against Google's GA4 validation server, initialize the client with `debug=True`.
+*Note: Events sent to the validation server do not show up in GA4 reports.*
+
+```python
+from measurement_api import MeasurementAPI
+
+api = MeasurementAPI("G-XXXXXXXXXX", "your_secret", debug=True)
+
+# This request goes to https://www.google-analytics.com/debug/mp/collect
+# Returns True if validation passes, False if there are validation warnings/errors
+success = await api.log_event("user_1", "purchase", items=[{"item_id": "SKU_123"}])
+```
+
+## Development & Testing
+
+### Running Tests
+
+We use `pytest` and `respx` to test the client offline without sending actual requests to Google Analytics.
+
+1. Install dependencies:
+   ```bash
+   uv sync --group dev
+   ```
+
+2. Run the test suite:
+   ```bash
+   uv run pytest
+   ```
+
+3. Run linting checks:
+   ```bash
+   uv run ruff check
+   ```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

measurement_api-0.1.0/pyproject.toml

@@ -0,0 +1,61 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "measurement-api"
+version = "0.1.0"
+authors = [
+    { name = "Andrii Bogdanovych", email = "a@bogdanovych.org" }
+]
+description = "A lightweight asynchronous Python client for the Google Analytics 4 Measurement Protocol"
+readme = "README.md"
+license = "MIT"
+keywords = [
+    "google-analytics",
+    "ga4",
+    "measurement-protocol",
+    "async",
+    "asyncio",
+    "httpx",
+    "analytics",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Framework :: AsyncIO",
+]
+requires-python = ">=3.12"
+dependencies = [
+    "httpx>=0.24.0",
+]
+[dependency-groups]
+dev = [
+    "pre_commit",
+    "twine",
+    "pytest",
+    "pytest-asyncio",
+    "respx",
+    "ruff",
+]
+
+[project.urls]
+"Homepage" = "https://www.bogdanovych.org"
+"Repository" = "https://github.com/BogdanovychA/measurement-api"
+"Bug Tracker" = "https://github.com/BogdanovychA/measurement-api/issues"
+"AI Agent Skill" = "https://skills.sh/bogdanovycha/measurement-api/measurement-api"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py312"
+
+[tool.ruff.format]
+quote-style = "preserve"

measurement_api-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

measurement_api-0.1.0/src/measurement_api/__init__.py

@@ -0,0 +1,3 @@
+from .main import MeasurementAPI
+
+__all__ = ["MeasurementAPI"]

measurement_api-0.1.0/src/measurement_api/main.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+
+import logging
+from types import TracebackType
+from typing import Self
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+class MeasurementAPI:
+    """A client for interacting with the Google Analytics 4 Measurement Protocol."""
+
+    def __init__(
+        self,
+        m10t_id: str,
+        secret_key: str,
+        *,
+        debug: bool = False,
+        client: httpx.AsyncClient | None = None,
+    ) -> None:
+        """Initialize the client for sending events to Google Analytics.
+
+        Args:
+            m10t_id: Measurement ID (GA4 data stream measurement ID).
+            secret_key: API Secret Key.
+            debug: Debug mode (sends validation requests to the GA4 validation server).
+            client: External AsyncClient for connection sharing and pooling.
+        """
+        self.id = m10t_id
+        self.secret_key = secret_key
+        self.debug = debug
+        self.client = client
+        self._owns_client = client is None
+
+    async def __aenter__(self) -> Self:
+        if self.client is None:
+            self.client = httpx.AsyncClient()
+            self._owns_client = True
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        await self.close()
+
+    async def close(self) -> None:
+        """Close the httpx client if it was created internally within the class."""
+        if self._owns_client and self.client is not None:
+            await self.client.aclose()
+            self.client = None
+
+    async def log_event(self, client_id: str, event_name: str, **kwargs) -> bool:
+        """Log an event in Google Analytics.
+
+        Args:
+            client_id: A unique identifier for the client.
+            event_name: The name of the event.
+            **kwargs: Event parameters (supports primitives, lists, and dicts).
+
+        Returns:
+            bool: True if the event was successfully sent/validated, False otherwise.
+        """
+        suffix = "debug/" if self.debug else ""
+        base_url = f"https://www.google-analytics.com/{suffix}mp/collect"
+        query_params = {"measurement_id": self.id, "api_secret": self.secret_key}
+
+        valid_params = {
+            k: v
+            for k, v in kwargs.items()
+            if isinstance(v, (str, int, float, bool, list, dict, tuple))
+        }
+
+        payload = {
+            "client_id": client_id,
+            "events": [
+                {
+                    "name": event_name,
+                    "params": valid_params,
+                }
+            ],
+        }
+
+        client = self.client
+        own_client = False
+        if client is None:
+            client = httpx.AsyncClient()
+            own_client = True
+
+        try:
+            logger.debug(
+                f"Sending GA event '{event_name}' to {base_url} with payload {payload}"
+            )
+            response = await client.post(
+                base_url, params=query_params, json=payload, timeout=5.0
+            )
+
+            if self.debug:
+                if response.status_code != 200:
+                    logger.warning(
+                        f"GA debug unexpected status: {response.status_code}"
+                    )
+                    return False
+
+                debug_result = response.json()
+                validation_messages = debug_result.get("validationMessages", [])
+
+                if validation_messages:
+                    logger.warning(f"GA validation issues: {validation_messages}")
+                    return False
+                else:
+                    logger.debug(f"GA event '{event_name}' validated successfully")
+                    return True
+            else:
+                if response.status_code == 204:
+                    logger.info(f"GA event '{event_name}' sent successfully")
+                    return True
+                else:
+                    logger.warning(
+                        f"GA unexpected status {response.status_code} "
+                        f"for event '{event_name}'"
+                    )
+                    return False
+
+        except httpx.TimeoutException:
+            logger.error("Analytics request timeout")
+            return False
+
+        except httpx.RequestError as e:
+            logger.error(f"Analytics request failed: {e}")
+            return False
+
+        except Exception as e:
+            logger.exception(f"Unexpected analytics error: {e}")
+            return False
+
+        finally:
+            if own_client:
+                await client.aclose()

measurement_api-0.1.0/src/measurement_api.egg-info/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: measurement-api
+Version: 0.1.0
+Summary: A lightweight asynchronous Python client for the Google Analytics 4 Measurement Protocol
+Author-email: Andrii Bogdanovych <a@bogdanovych.org>
+License-Expression: MIT
+Project-URL: Homepage, https://www.bogdanovych.org
+Project-URL: Repository, https://github.com/BogdanovychA/measurement-api
+Project-URL: Bug Tracker, https://github.com/BogdanovychA/measurement-api/issues
+Project-URL: AI Agent Skill, https://skills.sh/bogdanovycha/measurement-api/measurement-api
+Keywords: google-analytics,ga4,measurement-protocol,async,asyncio,httpx,analytics
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS.md
+Requires-Dist: httpx>=0.24.0
+Dynamic: license-file
+
+# measurement-api
+
+A lightweight asynchronous Python client for the Google Analytics 4 (GA4) Measurement Protocol.
+
+[![PyPI version](https://img.shields.io/pypi/v/measurement-api.svg)](https://pypi.org/project/measurement-api/)
+[![Python versions](https://img.shields.io/pypi/pyversions/measurement-api.svg)](https://pypi.org/project/measurement-api/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- ⚡ **Asynchronous**: Built on top of `httpx` for efficient, non-blocking requests.
+- 🔄 **Connection Pooling**: Supports async context manager syntax and custom `httpx.AsyncClient` injection to share/reuse TCP connections.
+- 🐛 **Validation Mode**: Integrates with GA4's validation server `/debug/mp/collect` to verify your payloads without logging dummy events in production.
+- 📦 **Complex Event Parameters**: Supports nested structures like lists (e.g. for E-commerce tracking `items`), dictionaries, and primitives.
+
+## Installation
+
+Install using `pip`:
+
+```bash
+pip install measurement-api
+```
+
+Or using `uv`:
+
+```bash
+uv add measurement-api
+```
+
+## Quickstart
+
+### Basic Async Usage
+
+```python
+import asyncio
+from measurement_api import MeasurementAPI
+
+async def main():
+    # Initialize the client
+    api = MeasurementAPI(
+        m10t_id="G-XXXXXXXXXX",
+        secret_key="your_api_secret_key"
+    )
+
+    # Log an event
+    success = await api.log_event(
+        client_id="user_12345",
+        event_name="button_click",
+        button_id="submit_form",
+        page_url="https://example.com"
+    )
+
+    if success:
+        print("Event sent successfully!")
+    else:
+        print("Failed to send event.")
+
+asyncio.run(main())
+```
+
+## Advanced Usage
+
+### Context Manager (Connection Reuse)
+
+When sending multiple events, use the async context manager to reuse the HTTP client's connection pool. This avoids the overhead of establishing a new TCP/TLS connection for every single event.
+
+```python
+import asyncio
+from measurement_api import MeasurementAPI
+
+async def main():
+    async with MeasurementAPI("G-XXXXXXXXXX", "your_secret") as api:
+        # Both events share the same connection pool
+        await api.log_event("user_1", "view_item", item_name="T-Shirt")
+        await api.log_event("user_1", "add_to_cart", item_name="T-Shirt")
+
+asyncio.run(main())
+```
+
+### Passing a Custom `httpx.AsyncClient`
+
+If your application already manages a global HTTP client (e.g. in FastAPI or Sanic), you can inject it directly:
+
+```python
+import httpx
+from measurement_api import MeasurementAPI
+
+async def send_analytics():
+    # Inject your own shared client
+    async with httpx.AsyncClient() as shared_client:
+        api = MeasurementAPI(
+            "G-XXXXXXXXXX",
+            "your_secret",
+            client=shared_client
+        )
+
+        # This will not close the injected client on exit or completion
+        await api.log_event("user_1", "purchase", value=99.99)
+```
+
+### Debug & Validation Mode
+
+To validate your event structure against Google's GA4 validation server, initialize the client with `debug=True`.
+*Note: Events sent to the validation server do not show up in GA4 reports.*
+
+```python
+from measurement_api import MeasurementAPI
+
+api = MeasurementAPI("G-XXXXXXXXXX", "your_secret", debug=True)
+
+# This request goes to https://www.google-analytics.com/debug/mp/collect
+# Returns True if validation passes, False if there are validation warnings/errors
+success = await api.log_event("user_1", "purchase", items=[{"item_id": "SKU_123"}])
+```
+
+## Development & Testing
+
+### Running Tests
+
+We use `pytest` and `respx` to test the client offline without sending actual requests to Google Analytics.
+
+1. Install dependencies:
+   ```bash
+   uv sync --group dev
+   ```
+
+2. Run the test suite:
+   ```bash
+   uv run pytest
+   ```
+
+3. Run linting checks:
+   ```bash
+   uv run ruff check
+   ```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

measurement_api-0.1.0/src/measurement_api.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+AUTHORS.md
+LICENSE
+README.md
+pyproject.toml
+src/measurement_api/__init__.py
+src/measurement_api/main.py
+src/measurement_api.egg-info/PKG-INFO
+src/measurement_api.egg-info/SOURCES.txt
+src/measurement_api.egg-info/dependency_links.txt
+src/measurement_api.egg-info/requires.txt
+src/measurement_api.egg-info/top_level.txt
+tests/test_measurement_api.py

measurement_api-0.1.0/src/measurement_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

measurement_api-0.1.0/src/measurement_api.egg-info/requires.txt

@@ -0,0 +1 @@
+httpx>=0.24.0

measurement_api-0.1.0/src/measurement_api.egg-info/top_level.txt

@@ -0,0 +1 @@
+measurement_api

measurement_api-0.1.0/tests/test_measurement_api.py

@@ -0,0 +1,201 @@
+# -*- coding: utf-8 -*-
+
+import httpx
+import pytest
+import respx
+
+from measurement_api import MeasurementAPI
+
+pytestmark = pytest.mark.asyncio
+
+
+@respx.mock
+async def test_log_event_success() -> None:
+    api = MeasurementAPI("G-12345", "secret_abc")
+
+    route = respx.post("https://www.google-analytics.com/mp/collect").mock(
+        return_value=httpx.Response(204)
+    )
+
+    result = await api.log_event("client_1", "test_event", param1="value1", num=42)
+
+    assert result is True
+    assert route.called
+    request = route.calls.last.request
+    assert "measurement_id=G-12345" in request.url.query.decode()
+    assert "api_secret=secret_abc" in request.url.query.decode()
+
+    # Verify JSON payload
+    import json
+
+    payload = json.loads(request.content)
+    assert payload["client_id"] == "client_1"
+    assert payload["events"][0]["name"] == "test_event"
+    assert payload["events"][0]["params"] == {"param1": "value1", "num": 42}
+
+
+@respx.mock
+async def test_log_event_debug_validation_success() -> None:
+    api = MeasurementAPI("G-12345", "secret_abc", debug=True)
+
+    route = respx.post("https://www.google-analytics.com/debug/mp/collect").mock(
+        return_value=httpx.Response(200, json={"validationMessages": []})
+    )
+
+    result = await api.log_event("client_1", "test_event")
+
+    assert result is True
+    assert route.called
+
+
+@respx.mock
+async def test_log_event_debug_validation_failure() -> None:
+    api = MeasurementAPI("G-12345", "secret_abc", debug=True)
+
+    route = respx.post("https://www.google-analytics.com/debug/mp/collect").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "validationMessages": [
+                    {
+                        "description": "Measurement ID is invalid",
+                        "validationCode": "VALUE_INVALID",
+                    }
+                ]
+            },
+        )
+    )
+
+    result = await api.log_event("client_1", "test_event")
+
+    assert result is False
+    assert route.called
+
+
+@respx.mock
+async def test_log_event_unexpected_status() -> None:
+    api = MeasurementAPI("G-12345", "secret_abc")
+
+    respx.post("https://www.google-analytics.com/mp/collect").mock(
+        return_value=httpx.Response(500)
+    )
+
+    result = await api.log_event("client_1", "test_event")
+    assert result is False
+
+
+@respx.mock
+async def test_log_event_debug_unexpected_status() -> None:
+    api = MeasurementAPI("G-12345", "secret_abc", debug=True)
+
+    respx.post("https://www.google-analytics.com/debug/mp/collect").mock(
+        return_value=httpx.Response(400)
+    )
+
+    result = await api.log_event("client_1", "test_event")
+    assert result is False
+
+
+@respx.mock
+async def test_log_event_parameter_filtering() -> None:
+    api = MeasurementAPI("G-12345", "secret_abc")
+
+    route = respx.post("https://www.google-analytics.com/mp/collect").mock(
+        return_value=httpx.Response(204)
+    )
+
+    # We send valid parameters (primitives, list, dict, tuple) and an invalid parameter (set)
+    result = await api.log_event(
+        "client_1",
+        "purchase",
+        str_val="ok",
+        int_val=10,
+        float_val=10.5,
+        bool_val=True,
+        list_val=[{"item_id": "1"}],
+        dict_val={"nested": "yes"},
+        tuple_val=(1, 2),
+        invalid_val={1, 2, 3},  # Set is not valid and should be filtered out
+    )
+
+    assert result is True
+    import json
+
+    payload = json.loads(route.calls.last.request.content)
+    params = payload["events"][0]["params"]
+
+    assert params["str_val"] == "ok"
+    assert params["int_val"] == 10
+    assert params["float_val"] == 10.5
+    assert params["bool_val"] is True
+    assert params["list_val"] == [{"item_id": "1"}]
+    assert params["dict_val"] == {"nested": "yes"}
+    assert params["tuple_val"] == [1, 2]  # JSON converts tuple to list
+    assert "invalid_val" not in params
+
+
+@respx.mock
+async def test_shared_client_reuse() -> None:
+    async with httpx.AsyncClient() as shared_client:
+        api = MeasurementAPI("G-12345", "secret_abc", client=shared_client)
+
+        route = respx.post("https://www.google-analytics.com/mp/collect").mock(
+            return_value=httpx.Response(204)
+        )
+
+        result1 = await api.log_event("client_1", "event_1")
+        result2 = await api.log_event("client_1", "event_2")
+
+        assert result1 is True
+        assert result2 is True
+        assert route.call_count == 2
+
+        # Verify client is not closed by the API
+        assert not shared_client.is_closed
+
+    # The block exit closes the client
+    assert shared_client.is_closed
+
+
+@respx.mock
+async def test_context_manager_lifecycle() -> None:
+    api_instance = None
+    async with MeasurementAPI("G-12345", "secret_abc") as api:
+        api_instance = api
+        assert api.client is not None
+        assert not api.client.is_closed
+
+        respx.post("https://www.google-analytics.com/mp/collect").mock(
+            return_value=httpx.Response(204)
+        )
+        result = await api.log_event("client_1", "event_1")
+        assert result is True
+
+    # After exiting the context manager, client should be closed and set to None
+    assert api_instance.client is None
+
+
+@respx.mock
+async def test_exceptions_handling() -> None:
+    api = MeasurementAPI("G-12345", "secret_abc")
+
+    # 1. TimeoutException
+    respx.post("https://www.google-analytics.com/mp/collect").mock(
+        side_effect=httpx.TimeoutException("Timeout")
+    )
+    result = await api.log_event("client_1", "event_1")
+    assert result is False
+
+    # 2. RequestError
+    respx.post("https://www.google-analytics.com/mp/collect").mock(
+        side_effect=httpx.RequestError("Request failed")
+    )
+    result = await api.log_event("client_1", "event_1")
+    assert result is False
+
+    # 3. Generic unexpected exception
+    respx.post("https://www.google-analytics.com/mp/collect").mock(
+        side_effect=ValueError("Unexpected error")
+    )
+    result = await api.log_event("client_1", "event_1")
+    assert result is False