222 lines
8.2 KiB
Python
222 lines
8.2 KiB
Python
import json
|
|
import os
|
|
import logging
|
|
from pathlib import Path
|
|
from typing import Dict, Any, List
|
|
|
|
from google.analytics.data_v1beta import BetaAnalyticsDataClient
|
|
from google.analytics.data_v1beta.types import (
|
|
DateRange,
|
|
Dimension,
|
|
Metric,
|
|
RunReportRequest,
|
|
RunRealtimeReportRequest,
|
|
OrderBy,
|
|
)
|
|
from google.oauth2 import service_account
|
|
from app.core.config.Config import settings
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
CATEGORY_CONFIG = {
|
|
"traffic": {
|
|
"metrics": ["sessions", "activeUsers", "newUsers", "screenPageViews"],
|
|
"dimensions": ["date"],
|
|
},
|
|
"acquisition": {
|
|
"metrics": ["sessions", "newUsers"],
|
|
"dimensions": ["sessionSource", "sessionMedium"],
|
|
},
|
|
"behavior": {
|
|
"metrics": ["screenPageViews", "engagementRate"],
|
|
"dimensions": ["pagePath", "pageTitle"],
|
|
},
|
|
"devices": {
|
|
"metrics": ["sessions", "activeUsers"],
|
|
"dimensions": ["deviceCategory", "browser", "operatingSystem", "screenResolution"],
|
|
},
|
|
"geo": {
|
|
"metrics": ["sessions", "activeUsers"],
|
|
"dimensions": ["country", "region", "city"],
|
|
},
|
|
"demographics": {
|
|
"metrics": ["sessions", "activeUsers", "purchaseRevenue"],
|
|
"dimensions": ["userAgeBracket", "userGender"],
|
|
}
|
|
}
|
|
|
|
def resolve_credentials_path() -> Path:
|
|
raw_path = settings.GA4_CREDENTIALS_JSON_PATH
|
|
p = Path(raw_path)
|
|
if not p.is_absolute():
|
|
backend_root = Path(__file__).resolve().parents[3]
|
|
p = backend_root / raw_path
|
|
return p
|
|
|
|
def get_ga_credentials():
|
|
key_path = resolve_credentials_path()
|
|
if not key_path.exists():
|
|
raise FileNotFoundError(f"GA4 service account JSON not found at: {key_path}")
|
|
with open(key_path, "r") as f:
|
|
service_data = json.load(f)
|
|
return service_account.Credentials.from_service_account_info(service_data)
|
|
|
|
class GoogleAnalyticsService:
|
|
def __init__(self, property_id: str = None):
|
|
self.property_id = property_id or settings.GA4_PROPERTY_ID
|
|
try:
|
|
credentials = get_ga_credentials()
|
|
self.client = BetaAnalyticsDataClient(credentials=credentials)
|
|
self.is_ready = True
|
|
except Exception as e:
|
|
logger.warning(f"Google Analytics Service initialization warning: {e}")
|
|
self.client = None
|
|
self.is_ready = False
|
|
|
|
def get_summary_metrics(self, days: int = 7) -> Dict[str, Any]:
|
|
if not self.is_ready:
|
|
return {"activeUsers": 0, "newUsers": 0, "sessions": 0, "pageViews": 0, "status": "offline_fallback"}
|
|
try:
|
|
request = RunReportRequest(
|
|
property=f"properties/{self.property_id}",
|
|
metrics=[
|
|
Metric(name="activeUsers"),
|
|
Metric(name="newUsers"),
|
|
Metric(name="sessions"),
|
|
Metric(name="screenPageViews"),
|
|
],
|
|
date_ranges=[DateRange(start_date=f"{days}daysAgo", end_date="today")],
|
|
)
|
|
response = self.client.run_report(request)
|
|
if not response.rows:
|
|
return {"activeUsers": 0, "newUsers": 0, "sessions": 0, "pageViews": 0}
|
|
row = response.rows[0]
|
|
return {
|
|
"activeUsers": int(row.metric_values[0].value),
|
|
"newUsers": int(row.metric_values[1].value),
|
|
"sessions": int(row.metric_values[2].value),
|
|
"pageViews": int(row.metric_values[3].value),
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"GA4 get_summary_metrics error: {e}")
|
|
return {"activeUsers": 0, "newUsers": 0, "sessions": 0, "pageViews": 0, "error": str(e)}
|
|
|
|
def get_users_over_time(self, days: int = 7) -> List[Dict[str, Any]]:
|
|
if not self.is_ready:
|
|
return []
|
|
try:
|
|
request = RunReportRequest(
|
|
property=f"properties/{self.property_id}",
|
|
dimensions=[Dimension(name="date")],
|
|
metrics=[Metric(name="activeUsers")],
|
|
date_ranges=[DateRange(start_date=f"{days}daysAgo", end_date="today")],
|
|
order_bys=[OrderBy(dimension=OrderBy.DimensionOrderBy(dimension_name="date"))],
|
|
)
|
|
response = self.client.run_report(request)
|
|
return [
|
|
{
|
|
"date": row.dimension_values[0].value,
|
|
"users": int(row.metric_values[0].value),
|
|
}
|
|
for row in response.rows
|
|
]
|
|
except Exception as e:
|
|
logger.error(f"GA4 get_users_over_time error: {e}")
|
|
return []
|
|
|
|
def get_traffic_sources(self, days: int = 7) -> List[Dict[str, Any]]:
|
|
if not self.is_ready:
|
|
return []
|
|
try:
|
|
request = RunReportRequest(
|
|
property=f"properties/{self.property_id}",
|
|
dimensions=[Dimension(name="sessionSource")],
|
|
metrics=[Metric(name="sessions")],
|
|
date_ranges=[DateRange(start_date=f"{days}daysAgo", end_date="today")],
|
|
limit=10,
|
|
)
|
|
response = self.client.run_report(request)
|
|
return [
|
|
{
|
|
"source": row.dimension_values[0].value,
|
|
"sessions": int(row.metric_values[0].value),
|
|
}
|
|
for row in response.rows
|
|
]
|
|
except Exception as e:
|
|
logger.error(f"GA4 get_traffic_sources error: {e}")
|
|
return []
|
|
|
|
def get_top_pages(self, days: int = 7) -> List[Dict[str, Any]]:
|
|
if not self.is_ready:
|
|
return []
|
|
try:
|
|
request = RunReportRequest(
|
|
property=f"properties/{self.property_id}",
|
|
dimensions=[Dimension(name="pagePathPlusQueryString")],
|
|
metrics=[Metric(name="screenPageViews")],
|
|
date_ranges=[DateRange(start_date=f"{days}daysAgo", end_date="today")],
|
|
limit=15,
|
|
)
|
|
response = self.client.run_report(request)
|
|
return [
|
|
{
|
|
"path": row.dimension_values[0].value,
|
|
"views": int(row.metric_values[0].value),
|
|
}
|
|
for row in response.rows
|
|
]
|
|
except Exception as e:
|
|
logger.error(f"GA4 get_top_pages error: {e}")
|
|
return []
|
|
|
|
def get_realtime_users(self) -> List[Dict[str, Any]]:
|
|
if not self.is_ready:
|
|
return []
|
|
try:
|
|
request = RunRealtimeReportRequest(
|
|
property=f"properties/{self.property_id}",
|
|
metrics=[Metric(name="activeUsers")],
|
|
dimensions=[
|
|
Dimension(name="country"),
|
|
Dimension(name="city"),
|
|
Dimension(name="deviceCategory"),
|
|
],
|
|
limit=50,
|
|
)
|
|
response = self.client.run_realtime_report(request)
|
|
return [
|
|
{
|
|
"country": row.dimension_values[0].value,
|
|
"city": row.dimension_values[1].value,
|
|
"device": row.dimension_values[2].value,
|
|
"active_users": int(row.metric_values[0].value),
|
|
}
|
|
for row in response.rows
|
|
]
|
|
except Exception as e:
|
|
logger.error(f"GA4 get_realtime_users error: {e}")
|
|
return []
|
|
|
|
def get_top_events(self, days: int = 7) -> List[Dict[str, Any]]:
|
|
if not self.is_ready:
|
|
return []
|
|
try:
|
|
request = RunReportRequest(
|
|
property=f"properties/{self.property_id}",
|
|
dimensions=[Dimension(name="eventName")],
|
|
metrics=[Metric(name="eventCount")],
|
|
date_ranges=[DateRange(start_date=f"{days}daysAgo", end_date="today")],
|
|
limit=10,
|
|
)
|
|
response = self.client.run_report(request)
|
|
return [
|
|
{
|
|
"event": row.dimension_values[0].value,
|
|
"count": int(row.metric_values[0].value),
|
|
}
|
|
for row in response.rows
|
|
]
|
|
except Exception as e:
|
|
logger.error(f"GA4 get_top_events error: {e}")
|
|
return []
|