django-nativemojo 0.1.10__py3-none-any.whl → 0.1.16__py3-none-any.whl

mojo/apps/logit/models/log.py

@@ -1,6 +1,7 @@
 from mojo.models import MojoModel
 from django.db import models as dm
 from mojo.helpers import logit
+import ujson
 # logger = logit.get_logger("requests", "requests.log")
 
 
@@ -23,12 +24,15 @@ class Log(dm.Model, MojoModel):
 
     @classmethod
     def logit(cls, request, log, kind="log", model_name=None, model_id=0, level="info", **kwargs):
+        if isinstance(log, dict):
+            log = ujson.encode(log, indent=4)
         if not isinstance(log, (bytes, str)):
             log = f"INVALID LOG TYPE: attempting to log type: {type(log)}"
         log = log.decode("utf-8") if isinstance(log, bytes) else log
         log = logit.mask_sensitive_data(log)
 
         uid, username, ip_address, path, method, duid = 0, None, None, None, None, None
+        user_agent = "system"
         if request:
             username = request.user.username if request.user.is_authenticated else None
             uid = request.user.pk if request.user.is_authenticated else 0
@@ -36,6 +40,7 @@ class Log(dm.Model, MojoModel):
             duid = request.duid
             ip_address = request.ip
             method = request.method
+            user_agent = request.user_agent
 
         path = kwargs.get("path", path)
         method = kwargs.get("method", method)
@@ -46,12 +51,13 @@ class Log(dm.Model, MojoModel):
             kind=kind,
             method=method,
             path=path,
+            payload=kwargs.get("payload", None),
             ip=ip_address,
             uid=uid,
             duid=duid,
             username=username,
             log=log,
-            user_agent=request.user_agent,
+            user_agent=user_agent,
             model_name=model_name,
             model_id=model_id
         )

mojo/apps/metrics/__init__.py

@@ -1,6 +1,7 @@
 from .redis_metrics import (
     record,
     fetch,
+    fetch_values,
     get_categories,
     fetch_by_category,
     get_category_slugs,
@@ -8,5 +9,11 @@ from .redis_metrics import (
     get_view_perms,
     get_write_perms,
     set_view_perms,
-    set_write_perms
+    set_write_perms,
+    list_accounts,
+    add_account,
+    delete_account,
+    get_accounts_with_permissions,
+    set_value,
+    get_value
 )

mojo/apps/metrics/redis_metrics.py

@@ -84,6 +84,104 @@ def fetch(slug, dt_start=None, dt_end=None, granularity="hours",
         return values
     return nobjict(labels=utils.periods_from_dr_slugs(dr_slugs), data={slug: values})
 
+
+def fetch_values(slugs, when=None, granularity="hours", redis_con=None, account="global", timezone=None):
+    """
+    Fetches specific metric values for multiple slugs at a single point in time.
+
+    Args:
+        slugs (str or list): The slug(s) to fetch values for. If string, should be comma-separated.
+        when (datetime): The specific datetime to fetch values for.
+        granularity (str, optional): The time granularity to use. Defaults to "hours".
+        redis_con: The Redis connection instance (optional).
+        account (str, optional): The account under which the metrics are recorded. Defaults to "global".
+
+    Returns:
+        dict: A dictionary containing:
+            - 'data': dict mapping slug names to their values
+            - 'slugs': list of slug names that were queried
+            - 'when': the datetime that was queried (as string)
+            - 'granularity': the granularity used
+            - 'account': the account queried
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+    when = utils.normalize_datetime(when, timezone)
+    # Handle comma-separated string input
+    if isinstance(slugs, str):
+        if ',' in slugs:
+            slugs = [s.strip() for s in slugs.split(',')]
+        else:
+            slugs = [slugs]
+
+    # Generate Redis keys for each slug at the specific datetime
+    redis_keys = []
+    for slug in slugs:
+        redis_key = utils.generate_slug(slug, when, granularity, account)
+        redis_keys.append(redis_key)
+
+    # Fetch all values with single MGET operation
+    values = redis_con.mget(redis_keys)
+
+    # Build response data dictionary
+    data = {}
+    for i, slug in enumerate(slugs):
+        value = values[i]
+        data[slug] = int(value) if value is not None else 0
+
+    return {
+        'data': data,
+        'slugs': slugs,
+        'when': when.isoformat() if hasattr(when, 'isoformat') else str(when),
+        'granularity': granularity,
+        'account': account
+    }
+
+
+def set_value(slug, value, redis_con=None, account="global"):
+    """
+    Sets a simple key-value pair in Redis for global storage (not time-series).
+
+    Args:
+        slug (str): The key identifier for the value.
+        value: The value to store (will be converted to string).
+        redis_con: The Redis connection instance (optional).
+        account (str, optional): The account under which the value is stored. Defaults to "global".
+
+    Returns:
+        None
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+
+    key = utils.generate_value_key(slug, account)
+    redis_con.set(key, str(value))
+
+
+def get_value(slug, redis_con=None, account="global", default=None):
+    """
+    Retrieves a simple value from Redis for global storage (not time-series).
+
+    Args:
+        slug (str): The key identifier for the value.
+        redis_con: The Redis connection instance (optional).
+        account (str, optional): The account under which the value is stored. Defaults to "global".
+        default: The default value to return if key doesn't exist. Defaults to None.
+
+    Returns:
+        str or default: The stored value as string, or default if key doesn't exist.
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+
+    key = utils.generate_value_key(slug, account)
+    value = redis_con.get(key)
+
+    if value is not None:
+        return value.decode('utf-8')
+    return default
+
+
 def add_metrics_slug(slug, redis_con=None, account="global"):
     """
     Adds a metric slug to a Redis set for the specified account.
@@ -259,6 +357,7 @@ def set_view_perms(account, perms, redis_con=None):
     if perms is None:
         redis_con.delete(view_perm_key)
     else:
+        add_account(account, redis_con)
         if isinstance(perms, list):
             perms = ','.join(perms)
         redis_con.set(view_perm_key, perms)
@@ -282,6 +381,7 @@ def set_write_perms(account, perms, redis_con=None):
     if perms is None:
         redis_con.delete(write_perm_key)
     else:
+        add_account(account, redis_con)
         if isinstance(perms, list):
             perms = ','.join(perms)
         redis_con.set(write_perm_key, perms)
@@ -329,3 +429,101 @@ def get_write_perms(account, redis_con=None):
         if ',' in perms:
             perms = perms.split(',')
     return perms
+
+def add_account(account, redis_con=None):
+    """
+    Adds a new account to the system.
+
+    Args:
+        account (str): The account to add.
+        redis_con: The Redis connection instance (optional).
+
+    Returns:
+        bool: True if the account was added successfully, False otherwise.
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+    accounts_key = utils.generate_accounts_key()
+    return redis_con.sadd(accounts_key, account) == 1
+
+def list_accounts(redis_con=None):
+    """
+    Lists all accounts in the system.
+
+    Args:
+        redis_con: The Redis connection instance (optional).
+
+    Returns:
+        list: A list of all accounts in the system.
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+    accounts_key = utils.generate_accounts_key()
+    return [account.decode('utf-8') for account in redis_con.smembers(accounts_key)]
+
+def delete_account(account, redis_con=None):
+    if redis_con is None:
+        redis_con = redis.get_connection()
+    set_view_perms(account, None, redis_con)
+    set_write_perms(account, None, redis_con)
+    accounts_key = utils.generate_accounts_key()
+    return redis_con.srem(accounts_key, account)
+
+
+
+def get_accounts_with_permissions(redis_con=None):
+    """
+    Scans Redis to find all accounts that have view or write permissions configured.
+
+    Args:
+        redis_con: The Redis connection instance (optional).
+
+    Returns:
+        list: A list of dictionaries containing account information and their permissions.
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+
+    accounts = {}
+
+    # Scan for view permission keys
+    cursor = b'0'
+    while cursor != b'0':
+        cursor, keys = redis_con.scan(cursor=cursor, match="mets:*:perm:v")
+        for key in keys:
+            key_str = key.decode('utf-8')
+            # Extract account from key: mets:{account}:perm:v
+            parts = key_str.split(':')
+            if len(parts) >= 4:
+                account = parts[1]
+                if account not in accounts:
+                    accounts[account] = {"account": account, "view_permissions": None, "write_permissions": None}
+
+                perms = redis_con.get(key)
+                if perms:
+                    perms = perms.decode('utf-8')
+                    if ',' in perms:
+                        perms = perms.split(',')
+                    accounts[account]["view_permissions"] = perms
+
+    # Scan for write permission keys
+    cursor = b'0'
+    while cursor != b'0':
+        cursor, keys = redis_con.scan(cursor=cursor, match="mets:*:perm:w")
+        for key in keys:
+            key_str = key.decode('utf-8')
+            # Extract account from key: mets:{account}:perm:w
+            parts = key_str.split(':')
+            if len(parts) >= 4:
+                account = parts[1]
+                if account not in accounts:
+                    accounts[account] = {"account": account, "view_permissions": None, "write_permissions": None}
+
+                perms = redis_con.get(key)
+                if perms:
+                    perms = perms.decode('utf-8')
+                    if ',' in perms:
+                        perms = perms.split(',')
+                    accounts[account]["write_permissions"] = perms
+
+    return list(accounts.values())

mojo/apps/metrics/rest/__init__.py

@@ -1 +1,4 @@
 from .base import *
+from .values import *
+from .categories import *
+from .permissions import *

mojo/apps/metrics/rest/categories.py

@@ -0,0 +1,266 @@
+from mojo import decorators as md
+from mojo.apps import metrics
+from mojo.helpers.response import JsonResponse
+import mojo.errors
+import datetime
+from .helpers import check_view_permissions, check_write_permissions
+
+# Documentation for API endpoints
+CATEGORIES_LIST_DOCS = {
+    "summary": "List all categories",
+    "description": "Retrieves all categories for a specific account.",
+    "parameters": [
+        {
+            "name": "account",
+            "in": "query",
+            "schema": {"type": "string", "default": "public"},
+            "description": "Account identifier (e.g., 'public', 'global', or 'group_<id>')."
+        }
+    ],
+    "responses": {
+        "200": {
+            "description": "Successful response with list of categories.",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "response": {
+                            "categories": ["activity", "engagement", "performance"],
+                            "account": "public",
+                            "status": True
+                        },
+                        "status_code": 200
+                    }
+                }
+            }
+        }
+    }
+}
+
+CATEGORY_SLUGS_DOCS = {
+    "summary": "Get slugs in a category",
+    "description": "Retrieves all slugs within a specific category.",
+    "parameters": [
+        {
+            "name": "category",
+            "in": "query",
+            "required": True,
+            "schema": {"type": "string"},
+            "description": "The category name to get slugs for."
+        },
+        {
+            "name": "account",
+            "in": "query",
+            "schema": {"type": "string", "default": "public"},
+            "description": "Account identifier (e.g., 'public', 'global', or 'group_<id>')."
+        }
+    ],
+    "responses": {
+        "200": {
+            "description": "Successful response with list of slugs in the category.",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "response": {
+                            "slugs": ["user_login", "user_signup", "user_logout"],
+                            "category": "activity",
+                            "account": "public",
+                            "status": True
+                        },
+                        "status_code": 200
+                    }
+                }
+            }
+        }
+    }
+}
+
+CATEGORY_FETCH_DOCS = {
+    "summary": "Fetch metrics for category",
+    "description": "Retrieves metrics data for all slugs within a category, date range, and granularity.",
+    "parameters": [
+        {
+            "name": "category",
+            "in": "query",
+            "required": True,
+            "schema": {"type": "string"},
+            "description": "The category name to fetch metrics for."
+        },
+        {
+            "name": "dt_start",
+            "in": "query",
+            "schema": {"type": "string", "format": "date-time"},
+            "description": "Start date and time for the data range."
+        },
+        {
+            "name": "dt_end",
+            "in": "query",
+            "schema": {"type": "string", "format": "date-time"},
+            "description": "End date and time for the data range."
+        },
+        {
+            "name": "account",
+            "in": "query",
+            "schema": {"type": "string", "default": "public"},
+            "description": "Account identifier (e.g., 'public', 'global', or 'group_<id>')."
+        },
+        {
+            "name": "granularity",
+            "in": "query",
+            "schema": {"type": "string", "default": "hours"},
+            "description": "Granularity of the data (e.g., 'hours', 'days', 'months', 'years')."
+        },
+        {
+            "name": "with_labels",
+            "in": "query",
+            "schema": {"type": "boolean", "default": False},
+            "description": "Include timestamp labels in response data."
+        }
+    ],
+    "responses": {
+        "200": {
+            "description": "Successful response with category metrics data.",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "response": {
+                            "data": {
+                                "user_login": [1, 2, 3, 4],
+                                "user_signup": [0, 1, 0, 2]
+                            },
+                            "category": "activity",
+                            "account": "public",
+                            "status": True
+                        },
+                        "status_code": 200
+                    }
+                }
+            }
+        }
+    }
+}
+
+CATEGORY_DELETE_DOCS = {
+    "summary": "Delete category",
+    "description": "Deletes an entire category and all its associated slugs and data.",
+    "parameters": [
+        {
+            "name": "category",
+            "in": "body",
+            "required": True,
+            "schema": {"type": "string"},
+            "description": "The category name to delete."
+        },
+        {
+            "name": "account",
+            "in": "body",
+            "schema": {"type": "string", "default": "public"},
+            "description": "Account identifier (e.g., 'public', 'global', or 'group_<id>')."
+        }
+    ],
+    "responses": {
+        "200": {
+            "description": "Successful deletion of category.",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "response": {
+                            "deleted_category": "activity",
+                            "account": "public",
+                            "status": True
+                        },
+                        "status_code": 200
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+@md.GET('categories', docs=CATEGORIES_LIST_DOCS)
+def on_categories_list(request):
+    """
+    List all categories for an account.
+    """
+    account = request.DATA.get("account", "public")
+    check_view_permissions(request, account)
+
+    categories = list(metrics.get_categories(account=account))
+
+    return JsonResponse({
+        "categories": categories,
+        "account": account,
+        "status": True
+    })
+
+
+@md.GET('category_slugs', docs=CATEGORY_SLUGS_DOCS)
+@md.requires_params("category")
+def on_category_slugs(request):
+    """
+    Get all slugs within a specific category.
+    """
+    category = request.DATA.get("category")
+    account = request.DATA.get("account", "public")
+    check_view_permissions(request, account)
+
+    slugs = list(metrics.get_category_slugs(category, account=account))
+
+    return JsonResponse({
+        "slugs": slugs,
+        "category": category,
+        "account": account,
+        "status": True
+    })
+
+
+@md.GET('category_fetch', docs=CATEGORY_FETCH_DOCS)
+@md.requires_params("category")
+def on_category_fetch(request):
+    """
+    Fetch metrics for all slugs within a category.
+    """
+    category = request.DATA.get("category")
+    dt_start = request.DATA.get_typed("dt_start", typed=datetime.datetime)
+    dt_end = request.DATA.get_typed("dt_end", typed=datetime.datetime)
+    account = request.DATA.get("account", "public")
+    granularity = request.DATA.get("granularity", "hours")
+    with_labels = request.DATA.get_typed("with_labels", default=False, typed=bool)
+
+    check_view_permissions(request, account)
+
+    data = metrics.fetch_by_category(
+        category,
+        dt_start=dt_start,
+        dt_end=dt_end,
+        granularity=granularity,
+        account=account,
+        with_labels=with_labels
+    )
+
+    return JsonResponse({
+        "data": data,
+        "category": category,
+        "account": account,
+        "status": True
+    })
+
+
+@md.DELETE('category_delete', docs=CATEGORY_DELETE_DOCS)
+@md.requires_params("category")
+def on_category_delete(request):
+    """
+    Delete an entire category and all its associated slugs and data.
+    """
+    category = request.DATA.get("category")
+    account = request.DATA.get("account", "public")
+
+    check_write_permissions(request, account)
+
+    metrics.delete_category(category, account=account)
+
+    return JsonResponse({
+        "deleted_category": category,
+        "account": account,
+        "status": True
+    })

mojo/apps/metrics/rest/helpers.py

@@ -0,0 +1,48 @@
+from mojo.apps import metrics
+import mojo.errors
+
+
+def check_view_permissions(request, account="public"):
+    """
+    Helper function to check view permissions for metrics operations.
+
+    Args:
+        request: The Django request object
+        account: The account to check permissions for
+
+    Raises:
+        PermissionDeniedException: If user doesn't have proper permissions
+    """
+    if account == "global":
+        if not request.user.is_authenticated or not request.user.has_permission("view_metrics"):
+            raise mojo.errors.PermissionDeniedException()
+    elif account != "public":
+        perms = metrics.get_view_perms(account)
+        if not perms:
+            raise mojo.errors.PermissionDeniedException()
+        if perms != "public":
+            if not request.user.is_authenticated or not request.user.has_permission(perms):
+                raise mojo.errors.PermissionDeniedException()
+
+
+def check_write_permissions(request, account="public"):
+    """
+    Helper function to check write permissions for metrics operations.
+
+    Args:
+        request: The Django request object
+        account: The account to check permissions for
+
+    Raises:
+        PermissionDeniedException: If user doesn't have proper permissions
+    """
+    if account == "global":
+        if not request.user.is_authenticated or not request.user.has_permission("write_metrics"):
+            raise mojo.errors.PermissionDeniedException()
+    elif account != "public":
+        perms = metrics.get_write_perms(account)
+        if not perms:
+            raise mojo.errors.PermissionDeniedException()
+        if perms != "public":
+            if not request.user.is_authenticated or not request.user.has_permission(perms):
+                raise mojo.errors.PermissionDeniedException()