260 lines
15 KiB
Python
260 lines
15 KiB
Python
import json
|
|
|
|
import schemas
|
|
from chalicelib.core import custom_metrics, dashboard
|
|
from chalicelib.utils import helper
|
|
from chalicelib.utils import pg_client
|
|
|
|
CATEGORY_DESCRIPTION = {
|
|
'categ1': 'lorem',
|
|
}
|
|
|
|
|
|
def get_templates(project_id, user_id):
|
|
with pg_client.PostgresClient() as cur:
|
|
pg_query = cur.mogrify(f"""SELECT category, jsonb_agg(metrics ORDER BY name) AS widgets
|
|
FROM metrics
|
|
WHERE deleted_at IS NULL AND (project_id ISNULL OR (project_id = %(project_id)s AND (is_public OR user_id= %(userId)s)))
|
|
GROUP BY category
|
|
ORDER BY category;""", {"project_id": project_id, "userId": user_id})
|
|
cur.execute(pg_query)
|
|
rows = cur.fetchall()
|
|
for r in rows:
|
|
r["description"] = CATEGORY_DESCRIPTION.get(r["category"], "")
|
|
return helper.list_to_camel_case(rows)
|
|
|
|
|
|
def create_dashboard(project_id, user_id, data: schemas.CreateDashboardSchema):
|
|
with pg_client.PostgresClient() as cur:
|
|
pg_query = f"""INSERT INTO dashboards(project_id, user_id, name, is_public, is_pinned)
|
|
VALUES(%(projectId)s, %(userId)s, %(name)s, %(is_public)s, %(is_pinned)s)
|
|
RETURNING *"""
|
|
params = {"userId": user_id, "projectId": project_id, **data.dict()}
|
|
if data.metrics is not None and len(data.metrics) > 0:
|
|
pg_query = f"""WITH dash AS ({pg_query})
|
|
INSERT INTO dashboard_widgets(dashboard_id, metric_id, user_id, config)
|
|
VALUES {",".join([f"((SELECT dashboard_id FROM dash),%(metric_id_{i})s, %(userId)s, %(config_{i})s)" for i in range(len(data.metrics))])}
|
|
RETURNING (SELECT dashboard_id FROM dash)"""
|
|
for i, m in enumerate(data.metrics):
|
|
params[f"metric_id_{i}"] = m
|
|
params[f"config_{i}"] = schemas.AddWidgetToDashboardPayloadSchema.schema() \
|
|
.get("properties", {}).get("config", {}).get("default", {})
|
|
params[f"config_{i}"]["position"] = i
|
|
params[f"config_{i}"] = json.dumps(params[f"config_{i}"])
|
|
cur.execute(cur.mogrify(pg_query, params))
|
|
row = cur.fetchone()
|
|
if row is None:
|
|
return {"errors": ["something went wrong while creating the dashboard"]}
|
|
return {"data": get_dashboard(project_id=project_id, user_id=user_id, dashboard_id=row["dashboard_id"])}
|
|
|
|
|
|
def get_dashboards(project_id, user_id):
|
|
with pg_client.PostgresClient() as cur:
|
|
pg_query = f"""SELECT *
|
|
FROM dashboards
|
|
WHERE deleted_at ISNULL
|
|
AND project_id = %(projectId)s
|
|
AND (user_id = %(userId)s OR is_public);"""
|
|
params = {"userId": user_id, "projectId": project_id}
|
|
cur.execute(cur.mogrify(pg_query, params))
|
|
rows = cur.fetchall()
|
|
return helper.list_to_camel_case(rows)
|
|
|
|
|
|
def get_dashboard(project_id, user_id, dashboard_id):
|
|
with pg_client.PostgresClient() as cur:
|
|
pg_query = """SELECT dashboards.*, all_metric_widgets.widgets AS widgets
|
|
FROM dashboards
|
|
LEFT JOIN LATERAL (SELECT COALESCE(JSONB_AGG(raw_metrics), '[]') AS widgets
|
|
FROM (SELECT dashboard_widgets.*, metrics.*, metric_series.series
|
|
FROM metrics
|
|
INNER JOIN dashboard_widgets USING (metric_id)
|
|
LEFT JOIN LATERAL (SELECT JSONB_AGG(metric_series.* ORDER BY index) AS series
|
|
FROM metric_series
|
|
WHERE metric_series.metric_id = metrics.metric_id
|
|
AND metric_series.deleted_at ISNULL
|
|
) AS metric_series ON (TRUE)
|
|
WHERE dashboard_widgets.dashboard_id = dashboards.dashboard_id
|
|
AND metrics.deleted_at ISNULL
|
|
AND (metrics.project_id = %(projectId)s OR metrics.project_id ISNULL)) AS raw_metrics
|
|
) AS all_metric_widgets ON (TRUE)
|
|
WHERE dashboards.deleted_at ISNULL
|
|
AND dashboards.project_id = %(projectId)s
|
|
AND dashboard_id = %(dashboard_id)s
|
|
AND (dashboards.user_id = %(userId)s OR is_public);"""
|
|
params = {"userId": user_id, "projectId": project_id, "dashboard_id": dashboard_id}
|
|
cur.execute(cur.mogrify(pg_query, params))
|
|
row = cur.fetchone()
|
|
return helper.dict_to_camel_case(row)
|
|
|
|
|
|
def delete_dashboard(project_id, user_id, dashboard_id):
|
|
with pg_client.PostgresClient() as cur:
|
|
pg_query = """UPDATE dashboards
|
|
SET deleted_at = timezone('utc'::text, now())
|
|
WHERE dashboards.project_id = %(projectId)s
|
|
AND dashboard_id = %(dashboard_id)s
|
|
AND (dashboards.user_id = %(userId)s OR is_public);"""
|
|
params = {"userId": user_id, "projectId": project_id, "dashboard_id": dashboard_id}
|
|
cur.execute(cur.mogrify(pg_query, params))
|
|
return {"data": {"success": True}}
|
|
|
|
|
|
def update_dashboard(project_id, user_id, dashboard_id, data: schemas.EditDashboardSchema):
|
|
with pg_client.PostgresClient() as cur:
|
|
pg_query = f"""UPDATE dashboards
|
|
SET name = %(name)s
|
|
{", is_public = %(is_public)s" if data.is_public is not None else ""}
|
|
{", is_pinned = %(is_pinned)s" if data.is_pinned is not None else ""}
|
|
WHERE dashboards.project_id = %(projectId)s
|
|
AND dashboard_id = %(dashboard_id)s
|
|
AND (dashboards.user_id = %(userId)s OR is_public)"""
|
|
params = {"userId": user_id, "projectId": project_id, "dashboard_id": dashboard_id, **data.dict()}
|
|
if data.metrics is not None and len(data.metrics) > 0:
|
|
pg_query = f"""WITH dash AS ({pg_query})
|
|
INSERT INTO dashboard_widgets(dashboard_id, metric_id, user_id, config)
|
|
VALUES {",".join([f"(%(dashboard_id)s, %(metric_id_{i})s, %(userId)s, %(config_{i})s)" for i in range(len(data.metrics))])};"""
|
|
for i, m in enumerate(data.metrics):
|
|
params[f"metric_id_{i}"] = m
|
|
params[f"config_{i}"] = schemas.AddWidgetToDashboardPayloadSchema.schema() \
|
|
.get("properties", {}).get("config", {}).get("default", {})
|
|
params[f"config_{i}"]["position"] = i
|
|
params[f"config_{i}"] = json.dumps(params[f"config_{i}"])
|
|
|
|
cur.execute(cur.mogrify(pg_query, params))
|
|
|
|
return get_dashboard(project_id=project_id, user_id=user_id, dashboard_id=dashboard_id)
|
|
|
|
|
|
def get_widget(project_id, user_id, dashboard_id, widget_id):
|
|
with pg_client.PostgresClient() as cur:
|
|
pg_query = """SELECT metrics.*, metric_series.series
|
|
FROM dashboard_widgets
|
|
INNER JOIN dashboards USING (dashboard_id)
|
|
INNER JOIN metrics USING (metric_id)
|
|
LEFT JOIN LATERAL (SELECT COALESCE(jsonb_agg(metric_series.* ORDER BY index), '[]'::jsonb) AS series
|
|
FROM metric_series
|
|
WHERE metric_series.metric_id = metrics.metric_id
|
|
AND metric_series.deleted_at ISNULL
|
|
) AS metric_series ON (TRUE)
|
|
WHERE dashboard_id = %(dashboard_id)s
|
|
AND widget_id = %(widget_id)s
|
|
AND (dashboards.is_public OR dashboards.user_id = %(userId)s)
|
|
AND dashboards.deleted_at IS NULL
|
|
AND metrics.deleted_at ISNULL
|
|
AND (metrics.project_id = %(projectId)s OR metrics.project_id ISNULL)
|
|
AND (metrics.is_public OR metrics.user_id = %(userId)s);"""
|
|
params = {"userId": user_id, "projectId": project_id, "dashboard_id": dashboard_id, "widget_id": widget_id}
|
|
cur.execute(cur.mogrify(pg_query, params))
|
|
row = cur.fetchone()
|
|
return helper.dict_to_camel_case(row)
|
|
|
|
|
|
def add_widget(project_id, user_id, dashboard_id, data: schemas.AddWidgetToDashboardPayloadSchema):
|
|
with pg_client.PostgresClient() as cur:
|
|
pg_query = """INSERT INTO dashboard_widgets(dashboard_id, metric_id, user_id, config)
|
|
SELECT %(dashboard_id)s AS dashboard_id, %(metric_id)s AS metric_id,
|
|
%(userId)s AS user_id, %(config)s::jsonb AS config
|
|
WHERE EXISTS(SELECT 1 FROM dashboards
|
|
WHERE dashboards.deleted_at ISNULL AND dashboards.project_id = %(projectId)s
|
|
AND dashboard_id = %(dashboard_id)s
|
|
AND (dashboards.user_id = %(userId)s OR is_public))
|
|
RETURNING *;"""
|
|
params = {"userId": user_id, "projectId": project_id, "dashboard_id": dashboard_id, **data.dict()}
|
|
params["config"] = json.dumps(data.config)
|
|
cur.execute(cur.mogrify(pg_query, params))
|
|
row = cur.fetchone()
|
|
return helper.dict_to_camel_case(row)
|
|
|
|
|
|
def update_widget(project_id, user_id, dashboard_id, widget_id, data: schemas.UpdateWidgetPayloadSchema):
|
|
with pg_client.PostgresClient() as cur:
|
|
pg_query = """UPDATE dashboard_widgets
|
|
SET config= %(config)s
|
|
WHERE dashboard_id=%(dashboard_id)s AND widget_id=%(widget_id)s
|
|
RETURNINIG *;"""
|
|
params = {"userId": user_id, "projectId": project_id, "dashboard_id": dashboard_id,
|
|
"widget_id": widget_id, **data.dict()}
|
|
cur.execute(cur.mogrify(pg_query, params))
|
|
row = cur.fetchone()
|
|
return helper.dict_to_camel_case(row)
|
|
|
|
|
|
def remove_widget(project_id, user_id, dashboard_id, widget_id):
|
|
with pg_client.PostgresClient() as cur:
|
|
pg_query = """DELETE FROM dashboard_widgets
|
|
WHERE dashboard_id=%(dashboard_id)s AND widget_id=%(widget_id)s;"""
|
|
params = {"userId": user_id, "projectId": project_id, "dashboard_id": dashboard_id, "widget_id": widget_id}
|
|
cur.execute(cur.mogrify(pg_query, params))
|
|
return {"data": {"success": True}}
|
|
|
|
|
|
def pin_dashboard(project_id, user_id, dashboard_id):
|
|
with pg_client.PostgresClient() as cur:
|
|
pg_query = """UPDATE dashboards
|
|
SET is_pinned = FALSE
|
|
WHERE project_id=%(project_id)s;
|
|
UPDATE dashboards
|
|
SET is_pinned = True
|
|
WHERE dashboard_id=%(dashboard_id)s AND project_id=%(project_id)s AND deleted_at ISNULL
|
|
RETURNING *;"""
|
|
params = {"userId": user_id, "project_id": project_id, "dashboard_id": dashboard_id}
|
|
cur.execute(cur.mogrify(pg_query, params))
|
|
row = cur.fetchone()
|
|
return helper.dict_to_camel_case(row)
|
|
|
|
|
|
def create_metric_add_widget(project_id, user_id, dashboard_id, data: schemas.CreateCustomMetricsSchema):
|
|
metric_id = custom_metrics.create(project_id=project_id, user_id=user_id, data=data, dashboard=True)
|
|
return add_widget(project_id=project_id, user_id=user_id, dashboard_id=dashboard_id,
|
|
data=schemas.AddWidgetToDashboardPayloadSchema(metric_id=metric_id))
|
|
|
|
|
|
PREDEFINED = {schemas.TemplateKeys.count_sessions: dashboard.get_processed_sessions,
|
|
schemas.TemplateKeys.avg_image_load_time: dashboard.get_application_activity_avg_image_load_time,
|
|
schemas.TemplateKeys.avg_page_load_time: dashboard.get_application_activity_avg_page_load_time,
|
|
schemas.TemplateKeys.avg_request_load_time: dashboard.get_application_activity_avg_request_load_time,
|
|
schemas.TemplateKeys.avg_dom_content_load_start: dashboard.get_page_metrics_avg_dom_content_load_start,
|
|
schemas.TemplateKeys.avg_first_contentful_pixel: dashboard.get_page_metrics_avg_first_contentful_pixel,
|
|
schemas.TemplateKeys.avg_visited_pages: dashboard.get_user_activity_avg_visited_pages,
|
|
schemas.TemplateKeys.avg_session_duration: dashboard.get_user_activity_avg_session_duration,
|
|
schemas.TemplateKeys.avg_pages_dom_buildtime: dashboard.get_pages_dom_build_time,
|
|
schemas.TemplateKeys.avg_pages_response_time: dashboard.get_pages_response_time,
|
|
schemas.TemplateKeys.avg_response_time: dashboard.get_top_metrics_avg_response_time,
|
|
schemas.TemplateKeys.avg_first_paint: dashboard.get_top_metrics_avg_first_paint,
|
|
schemas.TemplateKeys.avg_dom_content_loaded: dashboard.get_top_metrics_avg_dom_content_loaded,
|
|
schemas.TemplateKeys.avg_till_first_bit: dashboard.get_top_metrics_avg_till_first_bit,
|
|
schemas.TemplateKeys.avg_time_to_interactive: dashboard.get_top_metrics_avg_time_to_interactive,
|
|
schemas.TemplateKeys.count_requests: dashboard.get_top_metrics_count_requests,
|
|
schemas.TemplateKeys.avg_time_to_render: dashboard.get_time_to_render,
|
|
schemas.TemplateKeys.avg_used_js_heap_size: dashboard.get_memory_consumption,
|
|
schemas.TemplateKeys.avg_cpu: dashboard.get_avg_cpu,
|
|
schemas.TemplateKeys.avg_fps: dashboard.get_avg_fps}
|
|
|
|
|
|
def get_predefined_metric(key: schemas.TemplateKeys, project_id: int, data: dict):
|
|
return PREDEFINED.get(key, lambda *args: None)(project_id=project_id, **data)
|
|
|
|
|
|
def make_chart_metrics(project_id, user_id, metric_id, data: schemas.CustomMetricChartPayloadSchema):
|
|
raw_metric = custom_metrics.get_with_template(metric_id=metric_id, project_id=project_id, user_id=user_id)
|
|
if raw_metric is None:
|
|
return None
|
|
metric = schemas.CustomMetricAndTemplate = schemas.CustomMetricAndTemplate.parse_obj(raw_metric)
|
|
if metric.is_template:
|
|
return get_predefined_metric(key=metric.key, project_id=project_id, data=data.dict())
|
|
else:
|
|
return custom_metrics.make_chart(project_id=project_id, user_id=user_id, metric_id=metric_id, data=data,
|
|
metric=raw_metric)
|
|
|
|
|
|
def make_chart_widget(dashboard_id, project_id, user_id, widget_id, data: schemas.CustomMetricChartPayloadSchema):
|
|
raw_metric = get_widget(widget_id=widget_id, project_id=project_id, user_id=user_id, dashboard_id=dashboard_id)
|
|
if raw_metric is None:
|
|
return None
|
|
metric = schemas.CustomMetricAndTemplate = schemas.CustomMetricAndTemplate.parse_obj(raw_metric)
|
|
if metric.is_template:
|
|
return get_predefined_metric(key=metric.key, project_id=project_id, data=data.dict())
|
|
else:
|
|
return custom_metrics.make_chart(project_id=project_id, user_id=user_id, metric_id=raw_metric["metricId"],
|
|
data=data, metric=raw_metric)
|