django-nativemojo 0.1.10__py3-none-any.whl

mojo/apps/incident/rest/__init__.py

@@ -0,0 +1,2 @@
+from .event import *
+from .ossec import *

mojo/apps/incident/rest/event.py

@@ -0,0 +1,23 @@
+from mojo import decorators as md
+from mojo.apps.incident.models import Incident, Event, RuleSet, Rule
+
+
+@md.URL('incident')
+@md.URL('incident/<int:pk>')
+def on_incident(request, pk=None):
+    return Incident.on_rest_request(request, pk)
+
+@md.URL('event')
+@md.URL('event/<int:pk>')
+def on_event(request, pk=None):
+    return Event.on_rest_request(request, pk)
+
+@md.URL('event/ruleset')
+@md.URL('event/ruleset/<int:pk>')
+def on_event_ruleset(request, pk=None):
+    return RuleSet.on_rest_request(request, pk)
+
+@md.URL('event/ruleset/rule')
+@md.URL('event/ruleset/rule/<int:pk>')
+def on_event_ruleset_rule(request, pk=None):
+    return Rule.on_rest_request(request, pk)

mojo/apps/incident/rest/ossec.py

@@ -0,0 +1,22 @@
+from mojo import decorators as md
+from mojo.apps.incident.parsers import ossec
+from mojo import JsonResponse
+from mojo.apps.incident import reporter
+
+
+@md.POST('ossec/alert')
+def on_ossec_alert(request):
+    ossec_alert = ossec.parse(request.DATA)
+    # add the request ip
+    ossec_alert["request_ip"] = request.ip
+    reporter.report_event(ossec_alert.text, category="ossec", **ossec_alert)
+    return JsonResponse({"status": True})
+
+
+@md.POST('ossec/alert/batch')
+def on_ossec_alert_batch(request):
+    ossec_alerts = ossec.parse(request.DATA)
+    for alert in ossec_alerts:
+        alert["request_ip"] = request.ip
+        reporter.report_event(alert.text, category="ossec", **alert)
+    return JsonResponse({"status": True})

mojo/apps/logit/admin.py

@@ -0,0 +1,37 @@
+from mojo.apps.logit.models import Log
+import json
+from django.utils.safestring import mark_safe
+
+from django.contrib import admin
+
+# from django.contrib.sites.models import Site
+
+# Unregister Group and Site from admin
+# admin.site.unregister(Group)
+# admin.site.unregister(Site)
+
+@admin.register(Log)
+class LogAdmin(admin.ModelAdmin):
+    exclude = ("log",)
+    list_display = ("created", "kind", "method", "path", "ip", "uid", "model_name", "model_id", "log_summary")
+    list_filter = ("kind", "ip", "uid", "model_name", "model_id", "created")
+    search_fields = ("log", "path", "ip", "model_name")
+    readonly_fields = ("created", "kind", "path", "ip", "uid", "model_name", "model_id", "user_agent", "method")
+    date_hierarchy = "created"
+    ordering = ("-created",)
+
+    def formatted_log(self, obj):
+        """Attempt to format the log as JSON if possible, otherwise return raw log."""
+        if obj.log:
+            try:
+                json_data = json.loads(obj.log)  # Try parsing as JSON
+                formatted_json = json.dumps(json_data, indent=4, sort_keys=True)
+                return mark_safe(f"<pre>{formatted_json}</pre>")  # Wrap in <pre> for better formatting
+            except json.JSONDecodeError:
+                return obj.log  # Return raw log if not JSON
+        return None
+
+    def log_summary(self, obj):
+        """Show a shortened version of the log for better readability."""
+        return obj.log[:75] + "..." if obj.log and len(obj.log) > 75 else obj.log
+    log_summary.short_description = "Log Preview"

mojo/apps/logit/migrations/0001_initial.py

@@ -0,0 +1,32 @@
+# Generated by Django 4.2.21 on 2025-05-29 23:34
+
+from django.db import migrations, models
+import mojo.models.rest
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Log',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created', models.DateTimeField(auto_now_add=True, db_index=True)),
+                ('kind', models.CharField(db_index=True, default=None, max_length=200, null=True)),
+                ('method', models.CharField(default=None, max_length=200, null=True)),
+                ('path', models.TextField(db_index=True, default=None, null=True)),
+                ('ip', models.CharField(db_index=True, default=None, max_length=32, null=True)),
+                ('uid', models.IntegerField(db_index=True, default=0)),
+                ('user_agent', models.TextField(default=None, null=True)),
+                ('log', models.TextField(default=None, null=True)),
+                ('model_name', models.TextField(db_index=True, default=None, null=True)),
+                ('model_id', models.IntegerField(db_index=True, default=0)),
+            ],
+            bases=(models.Model, mojo.models.rest.MojoModel),
+        ),
+    ]

mojo/apps/logit/migrations/0002_log_duid_log_payload_log_username.py

@@ -0,0 +1,28 @@
+# Generated by Django 4.2.21 on 2025-05-31 23:05
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('logit', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='log',
+            name='duid',
+            field=models.TextField(default=None, null=True),
+        ),
+        migrations.AddField(
+            model_name='log',
+            name='payload',
+            field=models.TextField(default=None, null=True),
+        ),
+        migrations.AddField(
+            model_name='log',
+            name='username',
+            field=models.TextField(default=None, null=True),
+        ),
+    ]

mojo/apps/logit/migrations/0003_log_level.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.21 on 2025-05-31 23:48
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('logit', '0002_log_duid_log_payload_log_username'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='log',
+            name='level',
+            field=models.CharField(db_index=True, default='low', max_length=12),
+        ),
+    ]

mojo/apps/logit/models/__init__.py

@@ -0,0 +1 @@
+from .log import *

mojo/apps/logit/models/log.py

@@ -0,0 +1,57 @@
+from mojo.models import MojoModel
+from django.db import models as dm
+from mojo.helpers import logit
+# logger = logit.get_logger("requests", "requests.log")
+
+
+class Log(dm.Model, MojoModel):
+    created = dm.DateTimeField(auto_now_add=True, db_index=True)
+    level = dm.CharField(max_length=12, default="info", db_index=True)
+    kind = dm.CharField(max_length=200, default=None, null=True, db_index=True)
+    method = dm.CharField(max_length=200, default=None, null=True)
+    path = dm.TextField(default=None, null=True, db_index=True)
+    payload = dm.TextField(default=None, null=True)
+    ip = dm.CharField(max_length=32, default=None, null=True, db_index=True)
+    duid = dm.TextField(default=None, null=True)
+    uid = dm.IntegerField(default=0, db_index=True)
+    username = dm.TextField(default=None, null=True)
+    user_agent = dm.TextField(default=None, null=True)
+    log = dm.TextField(default=None, null=True)
+    model_name = dm.TextField(default=None, null=True, db_index=True)
+    model_id = dm.IntegerField(default=0, db_index=True)
+    # expires = dm.DateTimeField(db_index=True)
+
+    @classmethod
+    def logit(cls, request, log, kind="log", model_name=None, model_id=0, level="info", **kwargs):
+        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
+        if request:
+            username = request.user.username if request.user.is_authenticated else None
+            uid = request.user.pk if request.user.is_authenticated else 0
+            path = request.path
+            duid = request.duid
+            ip_address = request.ip
+            method = request.method
+
+        path = kwargs.get("path", path)
+        method = kwargs.get("method", method)
+        duid = kwargs.get("duid", duid)
+
+        return cls.objects.create(
+            level=level,
+            kind=kind,
+            method=method,
+            path=path,
+            ip=ip_address,
+            uid=uid,
+            duid=duid,
+            username=username,
+            log=log,
+            user_agent=request.user_agent,
+            model_name=model_name,
+            model_id=model_id
+        )

mojo/apps/logit/rest.py

@@ -0,0 +1,9 @@
+from mojo import decorators as md
+from mojo.apps.logit.models import Log
+
+APP_NAME = ""
+
+@md.URL('logs')
+@md.URL('logs/<int:pk>')
+def on_logs(request, pk=None):
+    return Log.on_rest_request(request, pk)

mojo/apps/metrics/README.md

@@ -0,0 +1,79 @@
+# Redis Metrics
+
+The `redis_metrics` module is designed to record and retrieve metrics using Redis as the data store. This package helps in maintaining metrics at various time granularities (e.g., hours, days, months, etc.) and organizing them into categories for better management.
+
+Ensure that Redis is running, and your Django project is configured to connect to it.
+
+## Usage
+
+### Recording Metrics
+
+The `record_metrics` function is used to record events or occurrences by incrementing counters in Redis.
+
+#### Parameters
+
+- **slug (str)**: The base identifier for the metric.
+- **when (datetime)**: The timestamp when the event occurred.
+- **count (int, optional)**: The number by which to increment the metric. Default is 0.
+- **group (optional)**: Reserved for future use.
+- **category (optional)**: Used to group slugs into categories.
+- **min_granulariy (str, optional)**: The smallest time unit for metric tracking (e.g., "hours"). Default is "hours".
+- **max_granularity (str, optional)**: The largest time unit for metric tracking (e.g., "years"). Default is "years".
+- **args (*args)**: Additional arguments used in slug generation.
+
+#### Example
+
+```python
+from datetime import datetime
+from metrics.redis_metrics import record_metrics
+
+# Record a metric 'page_views' for current time, incremented by 1.
+record_metrics(slug="page_views", when=datetime.now(), count=1)
+
+# Record a metric 'user_signups' with category 'activity', incremented by 5 at specific time.
+record_metrics(slug="user_signups", when=datetime(2023,10,10), count=5, category="activity")
+
+# Record metrics with different granularities
+record_metrics(slug="app_usage", when=datetime.now(), count=10, min_granulariy="minutes", max_granularity="days")
+```
+
+### Retrieving Metrics
+
+Retrieve the recorded metrics using a variety of retrieval methods provided by the module.
+
+#### Get Metrics from Slug
+
+Fetch the metrics for a specific slug between two datetime ranges at a given granularity.
+
+#### Example
+
+```python
+from datetime import datetime
+from metrics.redis_metrics import get_metrics
+
+# Fetch 'page_views' metrics from October 1, 2023, to October 10, 2023, with hourly granularity.
+metrics = get_metrics(slug="page_views", dt_start=datetime(2023, 10, 1), dt_end=datetime(2023, 10, 10), granularity="hours")
+print(metrics)
+```
+
+### Categories
+
+You can organize your metrics into categories for more structured management.
+
+#### Example
+
+```python
+from metrics.redis_metrics import get_category_slugs, get_categories
+
+# Get all the slugs in the 'activity' category.
+activity_slugs = get_category_slugs(category="activity")
+print(activity_slugs)
+
+# Get all categories.
+categories = get_categories()
+print(categories)
+```
+
+## Conclusion
+
+Redis Metrics is a robust utility for tracking application-specific metrics over various time periods with ease. The flexibility provided through time granularity and categorization makes it ideal for applications requiring detailed metric tracking and analysis.

mojo/apps/metrics/__init__.py

@@ -0,0 +1,12 @@
+from .redis_metrics import (
+    record,
+    fetch,
+    get_categories,
+    fetch_by_category,
+    get_category_slugs,
+    delete_category,
+    get_view_perms,
+    get_write_perms,
+    set_view_perms,
+    set_write_perms
+)

mojo/apps/metrics/redis_metrics.py

@@ -0,0 +1,331 @@
+from . import utils
+from mojo.helpers import redis, dates
+from mojo.helpers.settings import settings
+import datetime
+from objict import objict, nobjict
+
+
+def record(slug, when=None, count=1, category=None, account="global",
+                   min_granularity="hours", max_granularity="years", timezone=None):
+    """
+    Records metrics in Redis by incrementing counters for various time granularities.
+
+    Args:
+        slug (str): The base identifier for the metric.
+        when (datetime, optional): The time at which the event occurred. Defaults to current time if not provided.
+        count (int, optional): The count to increment the metric by. Defaults to 1.
+        category (str, optional): The category to which the metric belongs. Useful for grouping similar metrics.
+        account (str, optional): The account under which the metric is recorded. Defaults to "global".
+        min_granularity (str, optional): The minimum time granularity (e.g., "hours"). Defaults to "hours".
+        max_granularity (str, optional): The maximum time granularity (e.g., "years"). Defaults to "years".
+        timezone (str, optional): The timezone to use as the base for the granularity calculations.
+        *kwargs: Additional arguments to be used in slug generation.
+
+    Returns:
+        None: This function doesn't return a value. It performs its operations on Redis directly.
+    """
+    when = utils.normalize_datetime(when, timezone)
+    # Get Redis connection
+    redis_conn = redis.get_connection()
+    pipeline = redis_conn.pipeline()
+    if category is not None:
+        add_category_slug(category, slug, pipeline, account)
+    add_metrics_slug(slug, pipeline, account)
+    # Generate granularities
+    granularities = utils.generate_granularities(min_granularity, max_granularity)
+    # Process each granularity
+    for granularity in granularities:
+        # Generate slug for the current granularity
+        generated_slug = utils.generate_slug(slug, when, granularity, account)
+        # Add count to the slug in Redis
+        pipeline.incr(generated_slug, count)
+        exp_at = utils.get_expires_at(granularity, slug, category)
+        if exp_at:
+            pipeline.expireat(generated_slug, exp_at)
+    pipeline.execute()
+
+
+def fetch(slug, dt_start=None, dt_end=None, granularity="hours",
+          redis_con=None, account="global", with_labels=False, dr_slugs=None):
+    """
+    Fetches metrics from Redis based on slugs within a specified date range and granularity.
+
+    Args:
+        slug (str or list): The slug(s) identifying metrics to fetch.
+        dt_start (datetime, optional): The start of the date range. Defaults to None.
+        dt_end (datetime, optional): The end of the date range. Defaults to None.
+        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 metric is recorded. Defaults to "global".
+        with_labels (bool, optional): If True, includes timestamp labels in response data. Defaults to False.
+        dr_slugs: Pre-generated slugs for the date range. Defaults to None.
+
+    Returns:
+        list or nobjict: Returns a list of values or a structured nobjict with periods and data if `with_labels` is True.
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+    if isinstance(slug, (list, set)):
+        resp = nobjict()
+        if with_labels:
+            resp.data = {}
+            resp.labels = utils.periods_from_dr_slugs(utils.generate_slugs_for_range(
+                slug[0], dt_start, dt_end, granularity, account))
+        for s in slug:
+            values = fetch(s, dt_start, dt_end, granularity, redis_con, account)
+            if with_labels:
+                resp.data[s] = values
+            else:
+                resp[s] = values
+        return resp
+    dr_slugs = utils.generate_slugs_for_range(slug, dt_start, dt_end, granularity, account)
+    values = [int(met) if met is not None else 0 for met in redis_con.mget(dr_slugs)]
+    if not with_labels:
+        return values
+    return nobjict(labels=utils.periods_from_dr_slugs(dr_slugs), data={slug: values})
+
+def add_metrics_slug(slug, redis_con=None, account="global"):
+    """
+    Adds a metric slug to a Redis set for the specified account.
+
+    Args:
+        slug (str): The slug to add.
+        redis_con: The Redis connection instance (optional).
+        account (str): The account to which the slug should be added. Defaults to "global".
+
+    Returns:
+        None
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+    redis_con.sadd(utils.generate_slugs_key(account), slug)
+
+
+def delete_metrics_slug(slug, account="global", redis_con=None):
+    """
+    Deletes a specific slug from the Redis set for a given account.
+
+    Args:
+        slug (str): The slug to delete.
+        redis_con: The Redis connection instance (optional).
+        account (str): The account from which the slug should be removed. Defaults to "global".
+
+    Returns:
+        None
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+    redis_con.srem(utils.generate_slugs_key(account), slug)
+
+    # now lets delete all keys with our slug prefix
+    prefix = utils.generate_slug_prefix(slug, account)
+    return __delete_keys_with_prefix(prefix, redis_con)
+
+
+def __delete_keys_with_prefix(prefix, redis_conn):
+    cursor = b'0'
+    total_deleted = 0
+    while cursor != b'0':
+        cursor, keys = redis_conn.scan(cursor=cursor, match=f"{prefix}*")
+        if keys:
+            total_deleted += len(keys)
+            redis_conn.delete(*keys)
+    return total_deleted
+
+def get_account_slugs(account, redis_con=None):
+    """
+    Retrieves all slugs associated with a specific account from Redis.
+
+    Args:
+        account (str): The account for which to retrieve slugs.
+        redis_con: The Redis connection instance (optional).
+
+    Returns:
+        set: A set of decoded slugs belonging to the specified account.
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+    return {s.decode() for s in redis_con.smembers(utils.generate_slugs_key(account))}
+
+
+def add_category_slug(category, slug, redis_con=None, account="global"):
+    """
+    Adds a slug to a category set in Redis and indexes the category.
+
+    Args:
+        category (str): The category to which the slug should be added.
+        slug (str): The slug to add.
+        redis_con: The Redis connection instance (optional).
+        account (str): The account under which the category resides. Defaults to "global".
+
+    Returns:
+        None
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+    redis_con.sadd(utils.generate_category_slug(account, category), slug)
+    redis_con.sadd(utils.generate_category_key(account), category)
+
+
+def get_category_slugs(category, redis_con=None, account="global"):
+    """
+    Retrieves all slugs associated with a specific category from Redis.
+
+    Args:
+        category (str): The category for which to retrieve slugs.
+        redis_con: The Redis connection instance (optional).
+        account (str): The account under which the category resides. Defaults to "global".
+
+    Returns:
+        set: A set of decoded slugs belonging to the specified category.
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+    return {s.decode() for s in redis_con.smembers(utils.generate_category_slug(account, category))}
+
+
+def delete_category(category, redis_con=None, account="global"):
+    """
+    Deletes a specific category from Redis, including all associated slugs.
+
+    Args:
+        category (str): The category to delete.
+        redis_con: The Redis connection instance (optional).
+        account (str): The account under which the category resides. Defaults to "global".
+
+    Returns:
+        None
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+    category_slug = utils.generate_category_slug(account, category)
+    pipeline = redis_con.pipeline()
+    pipeline.delete(category_slug)  # Deletes the entire set
+    pipeline.srem(utils.generate_category_key(account), category)  # Remove the category name from index
+    pipeline.execute()
+
+
+def get_categories(redis_con=None, account="global"):
+    """
+    Retrieves all categories for a specific account from Redis.
+
+    Args:
+        redis_con: The Redis connection instance (optional).
+        account (str): The account for which to retrieve categories. Defaults to "global".
+
+    Returns:
+        set: A set of decoded category names belonging to the specified account.
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+    return {s.decode() for s in redis_con.smembers(utils.generate_category_key(account))}
+
+
+def fetch_by_category(category, dt_start=None, dt_end=None, granularity="hours",
+    redis_con=None, account="global", with_labels=False):
+    """
+    Fetches metrics for all slugs within a specified category, date range, and granularity.
+
+    Args:
+        category (str): The category for which to fetch metrics.
+        dt_start (datetime, optional): The start date for fetching metrics.
+        dt_end (datetime, optional): The end date for fetching metrics.
+        granularity (str, optional): The granularity of the metrics. Defaults to "hours".
+        redis_con: The Redis connection instance (optional).
+        account (str, optional): The account under which the category resides. Defaults to "global".
+        with_labels (bool, optional): If True, includes timestamp labels in response data. Defaults to False.
+
+    Returns:
+        list or nobjict: Fetches and returns metric data using the `fetch` function.
+    """
+    return fetch(get_category_slugs(category, redis_con, account), with_labels=with_labels, account=account)
+
+
+def set_view_perms(account, perms, redis_con=None):
+    """
+    Sets view permissions for a specific account.
+
+    Args:
+        account (str): The account for which to set permissions.
+        perms (str or list, optional): Permissions to set. If list, it will be converted to a comma-separated string.
+        redis_con: The Redis connection instance (optional).
+
+    Returns:
+        None
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+    view_perm_key = utils.generate_perm_view_key(account)
+    if perms is None:
+        redis_con.delete(view_perm_key)
+    else:
+        if isinstance(perms, list):
+            perms = ','.join(perms)
+        redis_con.set(view_perm_key, perms)
+
+
+def set_write_perms(account, perms, redis_con=None):
+    """
+    Sets write permissions for a specific account.
+
+    Args:
+        account (str): The account for which to set permissions.
+        perms (str or list, optional): Permissions to set. If list, it will be converted to a comma-separated string.
+        redis_con: The Redis connection instance (optional).
+
+    Returns:
+        None
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+    write_perm_key = utils.generate_perm_write_key(account)
+    if perms is None:
+        redis_con.delete(write_perm_key)
+    else:
+        if isinstance(perms, list):
+            perms = ','.join(perms)
+        redis_con.set(write_perm_key, perms)
+
+
+def get_view_perms(account, redis_con=None):
+    """
+    Retrieves view permissions for a specific account.
+
+    Args:
+        account (str): The account for which to retrieve permissions.
+        redis_con: The Redis connection instance (optional).
+
+    Returns:
+        str or list or None: The permissions for the specified account. Returns None if no permissions are set.
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+    view_perm_key = utils.generate_perm_view_key(account)
+    perms = redis_con.get(view_perm_key)
+    if perms:
+        perms = perms.decode('utf-8')
+        if ',' in perms:
+            perms = perms.split(',')
+    return perms
+
+
+def get_write_perms(account, redis_con=None):
+    """
+    Retrieves write permissions for a specific account.
+
+    Args:
+        account (str): The account for which to retrieve permissions.
+        redis_con: The Redis connection instance (optional).
+
+    Returns:
+        str or list or None: The permissions for the specified account. Returns None if no permissions are set.
+    """
+    if redis_con is None:
+        redis_con = redis.get_connection()
+    write_perm_key = utils.generate_perm_write_key(account)
+    perms = redis_con.get(write_perm_key)
+    if perms:
+        perms = perms.decode('utf-8')
+        if ',' in perms:
+            perms = perms.split(',')
+    return perms

mojo/apps/metrics/rest/__init__.py

@@ -0,0 +1 @@
+from .base import *