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                dimension["primary_key"] = "yes"
 70            elif dimension["name"] == "experiments":
 71                dimension["sql"] = "JSON_KEYS(${TABLE}.experiments, 1)"
 72
 73        measures = self.get_measures(dimensions)
 74
 75        return {
 76            "views": [
 77                {
 78                    "name": self.name,
 79                    "sql_table_name": f"`{self.tables[0]['table']}`",
 80                    "dimensions": [
 81                        d for d in dimensions if not lookml_utils._is_dimension_group(d)
 82                    ],
 83                    "dimension_groups": [
 84                        d for d in dimensions if lookml_utils._is_dimension_group(d)
 85                    ],
 86                    "measures": measures,
 87                },
 88                {
 89                    "name": f"{self.name}__experiments",
 90                    "dimensions": [
 91                        {
 92                            "name": "id",
 93                            "type": "string",
 94                            "sql": "${TABLE}",
 95                            "suggest_persist_for": DEFAULT_MAX_SUGGEST_PERSIST_FOR,
 96                        },
 97                        {
 98                            "name": "branch",
 99                            "type": "string",
100                            "sql": "JSON_VALUE(events_stream.experiments[${TABLE}].branch)",
101                            "suggest_persist_for": DEFAULT_MAX_SUGGEST_PERSIST_FOR,
102                        },
103                        {
104                            "name": "enrollment_id",
105                            "type": "string",
106                            "sql": "JSON_VALUE(events_stream.experiments[${TABLE}].extra.enrollment_id)",
107                            "suggest_persist_for": DEFAULT_MAX_SUGGEST_PERSIST_FOR,
108                        },
109                        {
110                            "name": "type",
111                            "type": "string",
112                            "sql": "JSON_VALUE(events_stream.experiments[${TABLE}].extra.type)",
113                            "suggest_persist_for": DEFAULT_MAX_SUGGEST_PERSIST_FOR,
114                        },
115                    ],
116                },
117            ],
118        }
119
120    def get_measures(self, dimensions: list[dict[str, Any]]) -> list[dict[str, str]]:
121        """Get measures for this view."""
122        measures = deepcopy(EventsStreamView.default_measures)
123        if client_id_dimension := self.get_client_id(
124            dimensions, self.tables[0]["table"]
125        ):
126            measures.append(
127                {
128                    "name": "client_count",
129                    "type": "count_distinct",
130                    "sql": f"${{{client_id_dimension}}}",
131                    "description": "The number of clients that completed the event(s).",
132                }
133            )
134            # GleanPingViews were previously generated for some `events_stream` views, and those had
135            # `clients` measures, so we generate the same measures here to avoid breaking anything.
136            # TODO: Remove this once dashboards have been migrated to use the proper `client_count` measures.
137            measures.append(
138                {
139                    "name": "clients",
140                    "type": "count_distinct",
141                    "sql": f"${{{client_id_dimension}}}",
142                    "hidden": "yes",
143                }
144            )
145        return measures