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

mojo/apps/metrics/rest/values.py

@@ -0,0 +1,277 @@
+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 time-series metrics endpoints
+SERIES_GET_DOCS = {
+    "summary": "Get time-series values at a point in time",
+    "description": "Retrieves time-series metric values for multiple slugs at a specific datetime and granularity.",
+    "parameters": [
+        {
+            "name": "slugs",
+            "in": "query",
+            "required": True,
+            "schema": {"type": "string"},
+            "description": "Comma-separated list of slugs to fetch values for (e.g., 'user_activity_day,page_views')."
+        },
+        {
+            "name": "when",
+            "in": "query",
+            "required": True,
+            "schema": {"type": "string", "format": "date-time"},
+            "description": "The specific date/datetime to fetch values for."
+        },
+        {
+            "name": "granularity",
+            "in": "query",
+            "schema": {"type": "string", "default": "hours"},
+            "description": "Granularity of the data (e.g., 'hours', 'days', 'months', 'years')."
+        },
+        {
+            "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 metric values.",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "response": {
+                            "data": {
+                                "user_activity_day": 22,
+                                "page_views": 156
+                            },
+                            "slugs": ["user_activity_day", "page_views"],
+                            "when": "2025-08-01T00:00:00",
+                            "granularity": "days",
+                            "account": "public",
+                            "status": True
+                        },
+                        "status_code": 200
+                    }
+                }
+            }
+        }
+    }
+}
+
+SERIES_POST_DOCS = {
+    "summary": "Get time-series values at a point in time (POST)",
+    "description": "Retrieves time-series metric values for multiple slugs at a specific datetime and granularity using POST method.",
+    "parameters": [
+        {
+            "name": "slugs",
+            "in": "body",
+            "required": True,
+            "schema": {"type": "string"},
+            "description": "Comma-separated list of slugs to fetch values for (e.g., 'user_activity_day,page_views')."
+        },
+        {
+            "name": "when",
+            "in": "body",
+            "required": True,
+            "schema": {"type": "string", "format": "date-time"},
+            "description": "The specific date/datetime to fetch values for."
+        },
+        {
+            "name": "granularity",
+            "in": "body",
+            "schema": {"type": "string", "default": "hours"},
+            "description": "Granularity of the data (e.g., 'hours', 'days', 'months', 'years')."
+        },
+        {
+            "name": "account",
+            "in": "body",
+            "schema": {"type": "string", "default": "public"},
+            "description": "Account identifier (e.g., 'public', 'global', or 'group_<id>')."
+        }
+    ]
+}
+
+# Documentation for simple value storage endpoints
+SET_VALUE_DOCS = {
+    "summary": "Set simple global values",
+    "description": "Sets simple key-value pairs for global storage (not time-series).",
+    "parameters": [
+        {
+            "name": "slug",
+            "in": "body",
+            "required": True,
+            "schema": {"type": "string"},
+            "description": "The key identifier for the value to set."
+        },
+        {
+            "name": "value",
+            "in": "body",
+            "required": True,
+            "schema": {"type": "string"},
+            "description": "The value to store."
+        },
+        {
+            "name": "account",
+            "in": "body",
+            "schema": {"type": "string", "default": "public"},
+            "description": "Account identifier (e.g., 'public', 'global', or 'group_<id>')."
+        }
+    ],
+    "responses": {
+        "200": {
+            "description": "Successful value storage.",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "response": {
+                            "slug": "max_users",
+                            "value": "1000",
+                            "account": "public",
+                            "status": True
+                        },
+                        "status_code": 200
+                    }
+                }
+            }
+        }
+    }
+}
+
+VALUE_GET_DOCS = {
+    "summary": "Get simple global values",
+    "description": "Retrieves simple key-value pairs from global storage (not time-series). Supports multiple slugs.",
+    "parameters": [
+        {
+            "name": "slugs",
+            "in": "query",
+            "required": True,
+            "schema": {"type": "string"},
+            "description": "Comma-separated list of slugs to fetch values for (e.g., 'max_users,maintenance_mode')."
+        },
+        {
+            "name": "account",
+            "in": "query",
+            "schema": {"type": "string", "default": "public"},
+            "description": "Account identifier (e.g., 'public', 'global', or 'group_<id>')."
+        },
+        {
+            "name": "default",
+            "in": "query",
+            "schema": {"type": "string"},
+            "description": "Default value to return for missing keys."
+        }
+    ],
+    "responses": {
+        "200": {
+            "description": "Successful response with values.",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "response": {
+                            "data": {
+                                "max_users": "1000",
+                                "maintenance_mode": "false"
+                            },
+                            "slugs": ["max_users", "maintenance_mode"],
+                            "account": "public",
+                            "status": True
+                        },
+                        "status_code": 200
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+# Time-series metrics endpoints
+@md.GET('series', docs=SERIES_GET_DOCS)
+@md.requires_params("slugs")
+def on_metrics_series(request):
+    """
+    Get time-series values for multiple slugs at a single point in time.
+    """
+    when = request.DATA.get_typed("when")
+    account = request.DATA.get("account", "public")
+    granularity = request.DATA.get("granularity", "hours")
+    slugs = request.DATA.get("slugs")
+
+    check_view_permissions(request, account)
+
+    # Fetch the values using our new method
+    result = metrics.fetch_values(slugs, when, granularity, account=account)
+    result['status'] = True
+
+    return JsonResponse(result)
+
+
+@md.POST('series', docs=SERIES_POST_DOCS)
+@md.requires_params("slugs")
+def on_metrics_series_post(request):
+    """
+    POST version of the series endpoint - same functionality as GET.
+    """
+    return on_metrics_series(request)
+
+
+# Simple value storage endpoints
+@md.POST('value/set', docs=SET_VALUE_DOCS)
+@md.requires_params("slug", "value")
+def on_set_value(request):
+    """
+    Set a simple global value (not time-series).
+    """
+    slug = request.DATA.get("slug")
+    value = request.DATA.get("value")
+    account = request.DATA.get("account", "public")
+
+    check_write_permissions(request, account)
+
+    metrics.set_value(slug, value, account=account)
+
+    return JsonResponse({
+        "slug": slug,
+        "value": value,
+        "account": account,
+        "status": True
+    })
+
+
+@md.GET('value/get', docs=VALUE_GET_DOCS)
+@md.requires_params("slugs")
+def on_get_value(request):
+    """
+    Get simple global values for multiple slugs (not time-series).
+    """
+    slugs = request.DATA.get("slugs")
+    account = request.DATA.get("account", "public")
+    default = request.DATA.get("default")
+
+    check_view_permissions(request, account)
+
+    # Handle comma-separated string input
+    if isinstance(slugs, str):
+        if ',' in slugs:
+            slugs_list = [s.strip() for s in slugs.split(',')]
+        else:
+            slugs_list = [slugs]
+    else:
+        slugs_list = slugs
+
+    # Fetch values for all slugs
+    data = {}
+    for slug in slugs_list:
+        value = metrics.get_value(slug, account=account, default=default)
+        data[slug] = value
+
+    return JsonResponse({
+        "data": data,
+        "slugs": slugs_list,
+        "account": account,
+        "status": True
+    })

mojo/apps/metrics/utils.py

@@ -179,6 +179,23 @@ def generate_perm_write_key(account):
 def generate_perm_view_key(account):
     return f"mets:{account}:perm:v"
 
+def generate_accounts_key():
+    return f"mets:_accounts_"
+
+def generate_value_key(slug, account):
+    """
+    Generate a Redis key for storing simple key-value pairs.
+
+    Args:
+        slug (str): The slug identifier for the value.
+        account (str): The account under which the value is stored.
+
+    Returns:
+        str: The Redis key for the value.
+    """
+    normalized_slug = normalize_slug(slug)
+    return f"mets:{account}:val:{normalized_slug}"
+
 
 def normalize_slug(slug):
     return slug.replace(':', '|')

mojo/decorators/http.py

@@ -10,6 +10,7 @@ from mojo.helpers.response import JsonResponse
 from functools import wraps
 from mojo.helpers import modules
 from mojo.models import rest
+from django.http import HttpResponse
 from mojo.apps import metrics
 
 logger = logit.get_logger("error", "error.log")
@@ -23,6 +24,7 @@ MOJO_APPEND_SLASH = settings.get("MOJO_APPEND_SLASH", False)
 
 API_METRICS = settings.get("API_METRICS", False)
 API_METRICS_GRANULARITY = settings.get("API_METRICS_GRANULARITY", "days")
+EVENTS_ON_ERRORS = settings.get("EVENTS_ON_ERRORS", True)
 
 
 def dispatcher(request, *args, **kwargs):
@@ -37,6 +39,13 @@ def dispatcher(request, *args, **kwargs):
             if request.group is not None:
                 request.group.touch()
         except ValueError:
+            if EVENTS_ON_ERRORS:
+                rest.MojoModel.class_report_incident(
+                    details=f"Permission denied: Invalid group ID -> '{request.DATA.group}'",
+                    event_type="rest_error",
+                    request=request,
+                    request_path=getattr(request, "path", None),
+                )
             return JsonResponse({"error": "Invalid group ID", "code": 400}, status=400)
     method_key = f"{key}__{request.method}"
     if method_key not in URLPATTERN_METHODS:
@@ -56,21 +65,51 @@ def dispatch_error_handler(func):
         try:
             if API_METRICS:
                 metrics.record("api_calls", category="mojo_api", min_granularity=API_METRICS_GRANULARITY)
-            return func(request, *args, **kwargs)
+            resp = func(request, *args, **kwargs)
+            if not isinstance(resp, HttpResponse) and isinstance(resp, dict):
+                return JsonResponse(resp)
+            return resp
         except mojo.errors.MojoException as err:
             if API_METRICS:
                 metrics.record("api_errors", category="mojo_api", min_granularity=API_METRICS_GRANULARITY)
+            if EVENTS_ON_ERRORS:
+                rest.MojoModel.class_report_incident_for_user(
+                    details=f"Rest Mojo Error: {err.reason}",
+                    event_type="rest_error",
+                    request_data=request.DATA,
+                    request=request,
+                    request_path=getattr(request, "path", None),
+                    stack_trace=traceback.format_exc(),
+                )
             return JsonResponse({"error": err.reason, "code": err.code}, status=err.status)
         except ValueError as err:
             if API_METRICS:
                 metrics.record("api_errors", category="mojo_api", min_granularity=API_METRICS_GRANULARITY)
             logger.exception(f"ValueErrror: {str(err)}, Path: {request.path}, IP: {request.META.get('REMOTE_ADDR')}")
+            if EVENTS_ON_ERRORS:
+                rest.MojoModel.class_report_incident_for_user(
+                    details=f"Rest Value Error: {err}",
+                    event_type="rest_error",
+                    request_data=request.DATA,
+                    request=request,
+                    request_path=getattr(request, "path", None),
+                    stack_trace=traceback.format_exc()
+                )
             return JsonResponse({"error": str(err), "code": 555 }, status=500)
         except Exception as err:
             if API_METRICS:
                 metrics.record("api_errors", category="mojo_api", min_granularity=API_METRICS_GRANULARITY)
             # logger.exception(f"Unhandled REST Exception: {request.path}")
             logger.exception(f"Error: {str(err)}, Path: {request.path}, IP: {request.META.get('REMOTE_ADDR')}")
+            if EVENTS_ON_ERRORS:
+                rest.MojoModel.class_report_incident_for_user(
+                    details=f"Rest Exception: {err}",
+                    event_type="rest_error",
+                    request_data=request.DATA,
+                    request=request,
+                    stack_trace=traceback.format_exc(),
+                    request_path=getattr(request, "path", None),
+                )
             return JsonResponse({"error": str(err), "code": 500 }, status=500)
 
     return wrapper

mojo/helpers/aws/__init__.py

@@ -7,6 +7,7 @@ A simple interface for working with AWS services.
 # Import service modules - these will be implemented
 from .s3 import S3Bucket, S3Item
 from .client import get_session
+from .kms import KMSHelper
 
 # These will be implemented in future modules
 from .iam import IAMRole, IAMPolicy, IAMUser
@@ -17,25 +18,28 @@ from .ec2 import EC2Instance, EC2SecurityGroup
 __all__ = [
     # Base
     'get_session',
-    
+
     # S3
     'S3Bucket',
     'S3Item',
-    
+
+    # KMS
+    'KMSHelper',
+
     # IAM
     'IAMRole',
     'IAMPolicy',
     'IAMUser',
-    
+
     # SES
     'EmailSender',
     'EmailTemplate',
-    
+
     # SNS
-    'SNSTopic', 
+    'SNSTopic',
     'SNSSubscription',
-    
+
     # EC2
     'EC2Instance',
     'EC2SecurityGroup',
-]
+]