feat(chalice): support timeseries of users-count

tahayk · Jun 20, 2024 · 0801b8a · 0801b8a
1 parent 83c5184
commit 0801b8a
Show file tree

Hide file tree

Showing 3 changed files with 58 additions and 22 deletions.
diff --git a/api/chalicelib/core/sessions.py b/api/chalicelib/core/sessions.py
@@ -189,17 +189,35 @@ def search2_series(data: schemas.SessionsSearchPayloadSchema, project_id: int, d
     with pg_client.PostgresClient() as cur:
         if metric_type == schemas.MetricType.timeseries:
             if view_type == schemas.MetricTimeseriesViewType.line_chart:
-                main_query = cur.mogrify(f"""WITH full_sessions AS (SELECT DISTINCT ON(s.session_id) s.session_id, s.start_ts
-                                                                {query_part})
-                                            SELECT generated_timestamp AS timestamp,
-                                                   COUNT(s)            AS count
-                                            FROM generate_series(%(startDate)s, %(endDate)s, %(step_size)s) AS generated_timestamp
-                                                     LEFT JOIN LATERAL ( SELECT 1 AS s
-                                                                         FROM full_sessions
-                                                                         WHERE start_ts >= generated_timestamp
-                                                                           AND start_ts <= generated_timestamp + %(step_size)s) AS sessions ON (TRUE)
-                                            GROUP BY generated_timestamp
-                                            ORDER BY generated_timestamp;""", full_args)
+                if metric_of == schemas.MetricOfTimeseries.session_count:
+                    # main_query = cur.mogrify(f"""WITH full_sessions AS (SELECT DISTINCT ON(s.session_id) s.session_id, s.start_ts
+                    main_query = cur.mogrify(f"""WITH full_sessions AS (SELECT s.session_id, s.start_ts
+                                                                    {query_part})
+                                                SELECT generated_timestamp AS timestamp,
+                                                       COUNT(s)            AS count
+                                                FROM generate_series(%(startDate)s, %(endDate)s, %(step_size)s) AS generated_timestamp
+                                                         LEFT JOIN LATERAL ( SELECT 1 AS s
+                                                                             FROM full_sessions
+                                                                             WHERE start_ts >= generated_timestamp
+                                                                               AND start_ts <= generated_timestamp + %(step_size)s) AS sessions ON (TRUE)
+                                                GROUP BY generated_timestamp
+                                                ORDER BY generated_timestamp;""", full_args)
+                elif metric_of == schemas.MetricOfTimeseries.user_count:
+                    main_query = cur.mogrify(f"""WITH full_sessions AS (SELECT s.user_id, s.start_ts
+                                                                    {query_part}
+                                                                    AND s.user_id IS NOT NULL
+                                                                    AND s.user_id != '')
+                                                SELECT generated_timestamp AS timestamp,
+                                                       COUNT(s)            AS count
+                                                FROM generate_series(%(startDate)s, %(endDate)s, %(step_size)s) AS generated_timestamp
+                                                         LEFT JOIN LATERAL ( SELECT DISTINCT user_id AS s
+                                                                             FROM full_sessions
+                                                                             WHERE start_ts >= generated_timestamp
+                                                                               AND start_ts <= generated_timestamp + %(step_size)s) AS sessions ON (TRUE)
+                                                GROUP BY generated_timestamp
+                                                ORDER BY generated_timestamp;""", full_args)
+                else:
+                    raise Exception(f"Unsupported metricOf:{metric_of}")
             else:
                 main_query = cur.mogrify(f"""SELECT count(DISTINCT s.session_id) AS count
                                             {query_part};""", full_args)
@@ -726,7 +744,8 @@ def search_query_parts(data: schemas.SessionsSearchPayloadSchema, error_status,
                     event_from = event_from % f"{events.EventType.CLICK_MOBILE.table} AS main "
                     if not is_any:
                         event_where.append(
-                            sh.multi_conditions(f"main.{events.EventType.CLICK_MOBILE.column} {op} %({e_k})s", event.value,
+                            sh.multi_conditions(f"main.{events.EventType.CLICK_MOBILE.column} {op} %({e_k})s",
+                                                event.value,
                                                 value_key=e_k))
 
             elif event_type == events.EventType.TAG.ui_type:
@@ -750,7 +769,8 @@ def search_query_parts(data: schemas.SessionsSearchPayloadSchema, error_status,
                     event_from = event_from % f"{events.EventType.INPUT_MOBILE.table} AS main "
                     if not is_any:
                         event_where.append(
-                            sh.multi_conditions(f"main.{events.EventType.INPUT_MOBILE.column} {op} %({e_k})s", event.value,
+                            sh.multi_conditions(f"main.{events.EventType.INPUT_MOBILE.column} {op} %({e_k})s",
+                                                event.value,
                                                 value_key=e_k))
 
 

diff --git a/api/schemas/schemas.py b/api/schemas/schemas.py
@@ -1013,6 +1013,7 @@ class MetricOfTable(str, Enum):
 
 class MetricOfTimeseries(str, Enum):
     session_count = "sessionCount"
+    user_count = "userCount"
 
 
 class MetricOfFunnels(str, Enum):

diff --git a/ee/api/chalicelib/core/sessions_exp.py b/ee/api/chalicelib/core/sessions_exp.py
@@ -269,15 +269,30 @@ def search2_series(data: schemas.SessionsSearchPayloadSchema, project_id: int, d
     with ch_client.ClickHouseClient() as cur:
         if metric_type == schemas.MetricType.timeseries:
             if view_type == schemas.MetricTimeseriesViewType.line_chart:
-                query = f"""SELECT toUnixTimestamp(
-                                    toStartOfInterval(processed_sessions.datetime, INTERVAL %(step_size)s second)
-                                    ) * 1000 AS timestamp,
-                                COUNT(processed_sessions.session_id) AS count
-                            FROM (SELECT DISTINCT ON(s.session_id) s.session_id AS session_id,
-                                        s.datetime AS datetime
-                                    {query_part}) AS processed_sessions
-                            GROUP BY timestamp
-                            ORDER BY timestamp;"""
+                if metric_of == schemas.MetricOfTimeseries.session_count:
+                    query = f"""SELECT toUnixTimestamp(
+                                        toStartOfInterval(processed_sessions.datetime, INTERVAL %(step_size)s second)
+                                        ) * 1000 AS timestamp,
+                                    COUNT(processed_sessions.session_id) AS count
+                                FROM (SELECT s.session_id AS session_id,
+                                            s.datetime AS datetime
+                                        {query_part}) AS processed_sessions
+                                GROUP BY timestamp
+                                ORDER BY timestamp;"""
+                elif metric_of == schemas.MetricOfTimeseries.user_count:
+                    query = f"""SELECT toUnixTimestamp(
+                                        toStartOfInterval(processed_sessions.datetime, INTERVAL %(step_size)s second)
+                                        ) * 1000 AS timestamp,
+                                    COUNT(DISTINCT processed_sessions.user_id) AS count
+                                FROM (SELECT s.user_id AS user_id,
+                                            s.datetime AS datetime
+                                        {query_part}
+                                      WHERE isNotNull(s.user_id)
+                                        AND s.user_id != '') AS processed_sessions
+                                GROUP BY timestamp
+                                ORDER BY timestamp;"""
+                else:
+                    raise Exception(f"Unsupported metricOf:{metric_of}")
                 main_query = cur.format(query, full_args)
             else:
                 main_query = cur.format(f"""SELECT count(DISTINCT s.session_id) AS count