generator.views.events_stream_view

  1"""Class to describe an `events_stream` view."""
  2
  3from __future__ import annotations
  4
  5from copy import deepcopy
  6from typing import Any, Iterator, Optional
  7
  8from . import lookml_utils
  9from .lookml_utils import DEFAULT_MAX_SUGGEST_PERSIST_FOR
 10from .view import View, ViewDict
 11
 12
 13class EventsStreamView(View):
 14    """A view for querying `events_stream` data, with one row per event."""
 15
 16    type: str = "events_stream_view"
 17
 18    default_measures: list[dict[str, str]] = [
 19        {
 20            "name": "event_count",
 21            "type": "count",
 22            "description": "The number of times the event(s) occurred.",
 23        },
 24        # GleanPingViews were previously generated for some `events_stream` views, and those had
 25        # `ping_count` measures, so we generate the same measures here to avoid breaking anything.
 26        # TODO: Remove this once dashboards have been migrated to use the proper `event_count` measures.
 27        {
 28            "name": "ping_count",
 29            "type": "count",
 30            "hidden": "yes",
 31        },
 32    ]
 33
 34    def __init__(self, namespace: str, name: str, tables: list[dict[str, str]]):
 35        """Get an instance of an EventsStreamView."""
 36        super().__init__(namespace, name, EventsStreamView.type, tables)
 37
 38    @classmethod
 39    def from_db_views(
 40        klass,
 41        namespace: str,
 42        is_glean: bool,
 43        channels: list[dict[str, str]],
 44        db_views: dict,
 45    ) -> Iterator[EventsStreamView]:
 46        """Get EventsStreamViews from db views."""
 47        for view_id in db_views[namespace]:
 48            if view_id.endswith("events_stream"):
 49                yield EventsStreamView(
 50                    namespace,
 51                    view_id,
 52                    [{"table": f"mozdata.{namespace}.{view_id}"}],
 53                )
 54
 55    @classmethod
 56    def from_dict(
 57        klass, namespace: str, name: str, _dict: ViewDict
 58    ) -> EventsStreamView:
 59        """Get EventsStreamView from a name and dict definition."""
 60        return EventsStreamView(namespace, name, _dict["tables"])
 61
 62    def to_lookml(self, v1_name: Optional[str], dryrun) -> dict[str, Any]:
 63        """Generate LookML for this view."""
 64        dimensions = lookml_utils._generate_dimensions(
 65            self.tables[0]["table"], dryrun=dryrun
 66        )
 67        for dimension in dimensions:
 68            if dimension["name"] == "event_id":
 69                # `event_id` columns were added in https://github.com/mozilla/bigquery-etl/pull/8596.
 70                dimension["sql"] = "COALESCE(${TABLE}.event_id, GENERATE_UUID())"
 71                dimension["primary_key"] = "yes"
 72            elif dimension["name"] == "experiments":
 73                dimension["sql"] = "JSON_KEYS(${TABLE}.experiments, 1)"
 74
 75        measures = self.get_measures(dimensions)
 76
 77        return {
 78            "views": [
 79                {
 80                    "name": self.name,
 81                    "sql_table_name": f"`{self.tables[0]['table']}`",
 82                    "dimensions": [
 83                        d for d in dimensions if not lookml_utils._is_dimension_group(d)
 84                    ],
 85                    "dimension_groups": [
 86                        d for d in dimensions if lookml_utils._is_dimension_group(d)
 87                    ],
 88                    "measures": measures,
 89                },
 90                {
 91                    "name": f"{self.name}__experiments",
 92                    "dimensions": [
 93                        {
 94                            "name": "id",
 95                            "type": "string",
 96                            "sql": "${TABLE}",
 97                            "suggest_persist_for": DEFAULT_MAX_SUGGEST_PERSIST_FOR,
 98                        },
 99                        {
100                            "name": "branch",
101                            "type": "string",
102                            "sql": "JSON_VALUE(events_stream.experiments[${TABLE}].branch)",
103                            "suggest_persist_for": DEFAULT_MAX_SUGGEST_PERSIST_FOR,
104                        },
105                        {
106                            "name": "enrollment_id",
107                            "type": "string",
108                            "sql": "JSON_VALUE(events_stream.experiments[${TABLE}].extra.enrollment_id)",
109                            "suggest_persist_for": DEFAULT_MAX_SUGGEST_PERSIST_FOR,
110                        },
111                        {
112                            "name": "type",
113                            "type": "string",
114                            "sql": "JSON_VALUE(events_stream.experiments[${TABLE}].extra.type)",
115                            "suggest_persist_for": DEFAULT_MAX_SUGGEST_PERSIST_FOR,
116                        },
117                    ],
118                },
119            ],
120        }
121
122    def get_measures(self, dimensions: list[dict[str, Any]]) -> list[dict[str, str]]:
123        """Get measures for this view."""
124        measures = deepcopy(EventsStreamView.default_measures)
125        if client_id_dimension := self.get_client_id(
126            dimensions, self.tables[0]["table"]
127        ):
128            measures.append(
129                {
130                    "name": "client_count",
131                    "type": "count_distinct",
132                    "sql": f"${{{client_id_dimension}}}",
133                    "description": "The number of clients that completed the event(s).",
134                }
135            )
136            # GleanPingViews were previously generated for some `events_stream` views, and those had
137            # `clients` measures, so we generate the same measures here to avoid breaking anything.
138            # TODO: Remove this once dashboards have been migrated to use the proper `client_count` measures.
139            measures.append(
140                {
141                    "name": "clients",
142                    "type": "count_distinct",
143                    "sql": f"${{{client_id_dimension}}}",
144                    "hidden": "yes",
145                }
146            )
147        return measures