flagsmith-common 1.5.0__py3-none-any.whl

common/core/app.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class CoreConfig(AppConfig):
+    name = "common.core"
+    label = "common_core"

common/core/logging.py

@@ -0,0 +1,24 @@
+import json
+import logging
+from typing import Any
+
+
+class JsonFormatter(logging.Formatter):
+    """Custom formatter for json logs."""
+
+    def get_json_record(self, record: logging.LogRecord) -> dict[str, Any]:
+        formatted_message = record.getMessage()
+        json_record = {
+            "levelname": record.levelname,
+            "message": formatted_message,
+            "timestamp": self.formatTime(record, self.datefmt),
+            "logger_name": record.name,
+            "pid": record.process,
+            "thread_name": record.threadName,
+        }
+        if record.exc_info:
+            json_record["exc_info"] = self.formatException(record.exc_info)
+        return json_record
+
+    def format(self, record: logging.LogRecord) -> str:
+        return json.dumps(self.get_json_record(record))

common/core/main.py

@@ -0,0 +1,40 @@
+import logging
+import os
+import sys
+import tempfile
+
+from django.core.management import execute_from_command_line
+
+logger = logging.getLogger(__name__)
+
+
+def main() -> None:
+    """
+    The main entry point to the Flagsmith application.
+
+    An equivalent to Django's `manage.py` script, this module is used to run management commands.
+
+    It's installed as the `flagsmith` command.
+
+    Everything that needs to be run before Django is started should be done here.
+
+    The end goal is to eventually replace Core API's `run-docker.sh` with this.
+
+    Usage:
+    `flagsmith <command> [options]`
+    """
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "settings.dev")
+
+    # Set up Prometheus' multiprocess mode
+    if "PROMETHEUS_MULTIPROC_DIR" not in os.environ:
+        prometheus_multiproc_dir = tempfile.TemporaryDirectory(
+            prefix="prometheus_multiproc",
+        )
+        logger.info(
+            "Created %s for Prometheus multi-process mode",
+            prometheus_multiproc_dir.name,
+        )
+        os.environ["PROMETHEUS_MULTIPROC_DIR"] = prometheus_multiproc_dir.name
+
+    # Run Django
+    execute_from_command_line(sys.argv)

common/core/management/commands/start.py

@@ -0,0 +1,41 @@
+from typing import Any, Callable
+
+from django.core.management import BaseCommand, CommandParser
+from django.utils.module_loading import autodiscover_modules
+
+from common.gunicorn.utils import add_arguments, run_server
+
+
+class Command(BaseCommand):
+    help = "Start the Flagsmith application."
+
+    def create_parser(self, *args: Any, **kwargs: Any) -> CommandParser:
+        return super().create_parser(*args, conflict_handler="resolve", **kwargs)
+
+    def add_arguments(self, parser: CommandParser) -> None:
+        add_arguments(parser)
+
+        subparsers = parser.add_subparsers(
+            title="sub-commands",
+            required=True,
+        )
+        api_parser = subparsers.add_parser(
+            "api",
+            help="Start the Core API.",
+        )
+        api_parser.set_defaults(handle_method=self.handle_api)
+
+    def initialise(self) -> None:
+        autodiscover_modules("metrics")
+
+    def handle(
+        self,
+        *args: Any,
+        handle_method: Callable[..., None],
+        **options: Any,
+    ) -> None:
+        self.initialise()
+        handle_method(*args, **options)
+
+    def handle_api(self, *args: Any, **options: Any) -> None:
+        run_server(options)

common/core/metrics.py

@@ -0,0 +1,23 @@
+import prometheus_client
+
+from common.core.utils import get_version_info
+
+flagsmith_build_info = prometheus_client.Gauge(
+    "flagsmith_build_info",
+    "Flagsmith version and build information",
+    ["ci_commit_sha", "version"],
+    multiprocess_mode="livemax",
+)
+
+
+def advertise() -> None:
+    # Advertise Flagsmith build info.
+    version_info = get_version_info()
+
+    flagsmith_build_info.labels(
+        ci_commit_sha=version_info["ci_commit_sha"],
+        version=version_info.get("package_versions", {}).get(".") or "unknown",
+    ).set(1)
+
+
+advertise()

common/core/urls.py

@@ -0,0 +1,17 @@
+from django.conf import settings
+from django.urls import include, re_path
+
+from common.core import views
+
+urlpatterns = [
+    re_path(r"^version/?", views.version_info),
+    re_path(r"^health/liveness/?", views.version_info),
+    re_path(r"^health/readiness/?", include("health_check.urls", namespace="health")),
+    re_path(r"^health", include("health_check.urls", namespace="health-deprecated")),
+    # Aptible health checks must be on /healthcheck and cannot redirect
+    # see https://www.aptible.com/docs/core-concepts/apps/connecting-to-apps/app-endpoints/https-endpoints/health-checks
+    re_path(r"^healthcheck", include("health_check.urls", namespace="health-aptible")),
+]
+
+if settings.PROMETHEUS_ENABLED:
+    urlpatterns += [re_path(r"^metrics/?", views.metrics)]

common/core/utils.py

@@ -0,0 +1,90 @@
+import json
+import pathlib
+from functools import lru_cache
+from typing import NotRequired, TypedDict
+
+from django.conf import settings
+from django.contrib.auth import get_user_model
+from django.contrib.auth.models import AbstractBaseUser
+from django.db.models import Manager
+
+UNKNOWN = "unknown"
+VERSIONS_INFO_FILE_LOCATION = ".versions.json"
+
+
+class SelfHostedData(TypedDict):
+    has_users: bool
+    has_logins: bool
+
+
+class VersionInfo(TypedDict):
+    ci_commit_sha: str
+    image_tag: str
+    has_email_provider: bool
+    is_enterprise: bool
+    is_saas: bool
+    self_hosted_data: SelfHostedData | None
+    package_versions: NotRequired[dict[str, str]]
+
+
+@lru_cache()
+def is_enterprise() -> bool:
+    return pathlib.Path("./ENTERPRISE_VERSION").exists()
+
+
+@lru_cache()
+def is_saas() -> bool:
+    return pathlib.Path("./SAAS_DEPLOYMENT").exists()
+
+
+@lru_cache()
+def has_email_provider() -> bool:
+    match settings.EMAIL_BACKEND:
+        case "django.core.mail.backends.smtp.EmailBackend":
+            return settings.EMAIL_HOST_USER is not None
+        case "sgbackend.SendGridBackend":
+            return settings.SENDGRID_API_KEY is not None
+        case "django_ses.SESBackend":
+            return settings.AWS_SES_REGION_ENDPOINT is not None
+        case _:
+            return False
+
+
+def get_version_info() -> VersionInfo:
+    """Reads the version info baked into src folder of the docker container"""
+    _is_saas = is_saas()
+    version_json: VersionInfo = {
+        "ci_commit_sha": get_file_contents("./CI_COMMIT_SHA") or UNKNOWN,
+        "image_tag": UNKNOWN,
+        "has_email_provider": has_email_provider(),
+        "is_enterprise": is_enterprise(),
+        "is_saas": _is_saas,
+        "self_hosted_data": None,
+    }
+
+    manifest_versions_content = get_file_contents(VERSIONS_INFO_FILE_LOCATION)
+
+    if manifest_versions_content:
+        manifest_versions = json.loads(manifest_versions_content)
+        version_json["package_versions"] = manifest_versions
+        version_json["image_tag"] = manifest_versions["."]
+
+    if not _is_saas:
+        user_objects: Manager[AbstractBaseUser] = getattr(get_user_model(), "objects")
+
+        version_json["self_hosted_data"] = {
+            "has_users": user_objects.exists(),
+            "has_logins": user_objects.filter(last_login__isnull=False).exists(),
+        }
+
+    return version_json
+
+
+@lru_cache()
+def get_file_contents(file_path: str) -> str | None:
+    """Attempts to read a file from the filesystem and return the contents"""
+    try:
+        with open(file_path) as f:
+            return f.read().replace("\n", "")
+    except FileNotFoundError:
+        return None

common/core/views.py

@@ -0,0 +1,23 @@
+import logging
+
+import prometheus_client
+from django.http import HttpResponse, JsonResponse
+from rest_framework.request import Request
+
+from common.core import utils
+from common.prometheus.utils import get_registry
+
+logger = logging.getLogger(__name__)
+
+
+def version_info(request: Request) -> JsonResponse:
+    return JsonResponse(utils.get_version_info())
+
+
+def metrics(request: Request) -> HttpResponse:
+    registry = get_registry()
+    metrics_page = prometheus_client.generate_latest(registry)
+    return HttpResponse(
+        metrics_page,
+        content_type=prometheus_client.CONTENT_TYPE_LATEST,
+    )

common/environments/permissions.py

@@ -0,0 +1,15 @@
+# Maintain a list of permissions here
+VIEW_ENVIRONMENT = "VIEW_ENVIRONMENT"
+UPDATE_FEATURE_STATE = "UPDATE_FEATURE_STATE"
+MANAGE_IDENTITIES = "MANAGE_IDENTITIES"
+VIEW_IDENTITIES = "VIEW_IDENTITIES"
+CREATE_CHANGE_REQUEST = "CREATE_CHANGE_REQUEST"
+APPROVE_CHANGE_REQUEST = "APPROVE_CHANGE_REQUEST"
+MANAGE_SEGMENT_OVERRIDES = "MANAGE_SEGMENT_OVERRIDES"
+
+TAG_SUPPORTED_PERMISSIONS = [
+    UPDATE_FEATURE_STATE,
+    CREATE_CHANGE_REQUEST,
+    APPROVE_CHANGE_REQUEST,
+    MANAGE_SEGMENT_OVERRIDES,
+]

common/features/multivariate/serializers.py

@@ -0,0 +1,19 @@
+import typing
+
+from django.apps import apps
+from rest_framework import serializers
+
+if typing.TYPE_CHECKING:
+    from common.types import MultivariateFeatureStateValue  # noqa: F401
+
+
+class MultivariateFeatureStateValueSerializer(
+    serializers.ModelSerializer["MultivariateFeatureStateValue"]
+):
+    class Meta:
+        model = apps.get_model("multivariate", "MultivariateFeatureStateValue")
+        fields = (
+            "id",
+            "multivariate_feature_option",
+            "percentage_allocation",
+        )

common/features/serializers.py

@@ -0,0 +1,68 @@
+import typing
+
+from django.apps import apps
+from drf_writable_nested.serializers import WritableNestedModelSerializer
+from rest_framework import serializers
+
+from common.features.multivariate.serializers import (
+    MultivariateFeatureStateValueSerializer,
+)
+
+if typing.TYPE_CHECKING:
+    from common.types import FeatureSegment, FeatureStateValue  # noqa: F401
+
+
+class FeatureStateValueSerializer(serializers.ModelSerializer["FeatureStateValue"]):
+    class Meta:
+        model = apps.get_model("features", "FeatureStateValue")
+        fields = ("type", "string_value", "integer_value", "boolean_value")
+
+
+class CreateSegmentOverrideFeatureSegmentSerializer(
+    serializers.ModelSerializer["FeatureSegment"]
+):
+    class Meta:
+        model = apps.get_model("features", "FeatureSegment")
+        fields = ("id", "segment", "priority", "uuid")
+
+
+class CreateSegmentOverrideFeatureStateSerializer(WritableNestedModelSerializer):
+    feature_state_value = FeatureStateValueSerializer()
+    feature_segment = CreateSegmentOverrideFeatureSegmentSerializer(
+        required=False, allow_null=True
+    )
+    multivariate_feature_state_values = MultivariateFeatureStateValueSerializer(
+        many=True, required=False
+    )
+
+    class Meta:
+        model = apps.get_model("features", "FeatureState")
+        fields = (
+            "id",
+            "feature",
+            "enabled",
+            "feature_state_value",
+            "feature_segment",
+            "deleted_at",
+            "uuid",
+            "created_at",
+            "updated_at",
+            "live_from",
+            "environment",
+            "identity",
+            "change_request",
+            "multivariate_feature_state_values",
+        )
+
+        read_only_fields = (
+            "id",
+            "deleted_at",
+            "uuid",
+            "created_at",
+            "updated_at",
+            "live_from",
+            "environment",
+            "identity",
+            "change_request",
+            "feature",
+        )

common/features/versioning/serializers.py

@@ -0,0 +1,13 @@
+from common.features.serializers import (
+    CreateSegmentOverrideFeatureStateSerializer,
+)
+
+
+class EnvironmentFeatureVersionFeatureStateSerializer(
+    CreateSegmentOverrideFeatureStateSerializer
+):
+    class Meta(CreateSegmentOverrideFeatureStateSerializer.Meta):
+        read_only_fields = (
+            CreateSegmentOverrideFeatureStateSerializer.Meta.read_only_fields
+            + ("feature",)  # type: ignore[assignment]
+        )

common/gunicorn/conf.py

@@ -0,0 +1,18 @@
+"""
+This module is used as a default configuration file for Gunicorn.
+
+It is used to correctly support Prometheus metrics in a multi-process environment.
+"""
+
+import typing
+
+from prometheus_client.multiprocess import mark_process_dead
+
+if typing.TYPE_CHECKING:  # pragma: no cover
+    from gunicorn.arbiter import Arbiter  # type: ignore[import-untyped]
+    from gunicorn.workers.base import Worker  # type: ignore[import-untyped]
+
+
+def worker_exit(server: "Arbiter", worker: "Worker") -> None:
+    """Detach the process Prometheus metrics collector when a worker exits."""
+    mark_process_dead(worker.pid)  # type: ignore[no-untyped-call]

common/gunicorn/constants.py

@@ -0,0 +1 @@
+WSGI_DJANGO_ROUTE_ENVIRON_KEY = "wsgi.django_route"

common/gunicorn/logging.py

@@ -0,0 +1,94 @@
+import logging
+import sys
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING, Any
+
+from django.conf import settings
+from gunicorn.config import Config  # type: ignore[import-untyped]
+from gunicorn.http.message import Request  # type: ignore[import-untyped]
+from gunicorn.http.wsgi import Response  # type: ignore[import-untyped]
+from gunicorn.instrument.statsd import (  # type: ignore[import-untyped]
+    Statsd as StatsdGunicornLogger,
+)
+
+from common.core.logging import JsonFormatter
+from common.gunicorn import metrics
+from common.gunicorn.constants import WSGI_DJANGO_ROUTE_ENVIRON_KEY
+
+
+class GunicornAccessLogJsonFormatter(JsonFormatter):
+    def get_json_record(self, record: logging.LogRecord) -> dict[str, Any]:
+        args = record.args
+
+        if TYPE_CHECKING:
+            assert isinstance(args, dict)
+
+        url = args["U"]
+        if q := args["q"]:
+            url += f"?{q}"
+
+        return {
+            **super().get_json_record(record),
+            "time": datetime.strptime(args["t"], "[%d/%b/%Y:%H:%M:%S %z]").isoformat(),
+            "path": url,
+            "remote_ip": args["h"],
+            "route": args["R"],
+            "method": args["m"],
+            "status": str(args["s"]),
+            "user_agent": args["a"],
+            "duration_in_ms": args["M"],
+        }
+
+
+class PrometheusGunicornLogger(StatsdGunicornLogger):  # type: ignore[misc]
+    def access(
+        self,
+        resp: Response,
+        req: Request,
+        environ: dict[str, Any],
+        request_time: timedelta,
+    ) -> None:
+        super().access(resp, req, environ, request_time)
+        duration_seconds = (
+            request_time.seconds + float(request_time.microseconds) / 10**6
+        )
+        labels = {
+            # To avoid cardinality explosion, we use a resolved Django route
+            # instead of raw path.
+            # The Django route is set by `RouteLoggerMiddleware`.
+            "route": environ.get(WSGI_DJANGO_ROUTE_ENVIRON_KEY) or "",
+            "method": environ.get("REQUEST_METHOD") or "",
+            "response_status": resp.status_code,
+        }
+        metrics.http_server_request_duration_seconds.labels(**labels).observe(
+            duration_seconds
+        )
+        metrics.http_server_requests_total.labels(**labels).inc()
+
+
+class GunicornJsonCapableLogger(PrometheusGunicornLogger):
+    def atoms(
+        self,
+        resp: Response,
+        req: Request,
+        environ: dict[str, Any],
+        request_time: timedelta,
+    ) -> dict[str, str]:
+        atoms: dict[str, str] = super().atoms(resp, req, environ, request_time)
+        atoms["R"] = environ.get(WSGI_DJANGO_ROUTE_ENVIRON_KEY) or "-"
+        return atoms
+
+    def setup(self, cfg: Config) -> None:
+        super().setup(cfg)
+        if getattr(settings, "LOG_FORMAT", None) == "json":
+            self._set_handler(
+                self.error_log,
+                cfg.errorlog,
+                JsonFormatter(),
+            )
+            self._set_handler(
+                self.access_log,
+                cfg.accesslog,
+                GunicornAccessLogJsonFormatter(),
+                stream=sys.stdout,
+            )

common/gunicorn/metrics.py

@@ -0,0 +1,14 @@
+import prometheus_client
+
+from common.prometheus import Histogram
+
+http_server_requests_total = prometheus_client.Counter(
+    "http_server_requests_total",
+    "Total number of HTTP requests",
+    ["route", "method", "response_status"],
+)
+http_server_request_duration_seconds = Histogram(
+    "http_server_request_duration_seconds",
+    "HTTP request duration in seconds",
+    ["route", "method", "response_status"],
+)

common/gunicorn/middleware.py

@@ -0,0 +1,28 @@
+from typing import Callable
+
+from django.http import HttpRequest, HttpResponse
+
+from common.gunicorn.constants import WSGI_DJANGO_ROUTE_ENVIRON_KEY
+
+
+class RouteLoggerMiddleware:
+    """
+    Make the resolved Django route available to the WSGI server
+    (e.g. Gunicorn) for logging purposes.
+    """
+
+    def __init__(
+        self,
+        get_response: Callable[[HttpRequest], HttpResponse],
+    ) -> None:
+        self.get_response = get_response
+
+    def __call__(self, request: HttpRequest) -> HttpResponse:
+        response = self.get_response(request)
+
+        if resolver_match := request.resolver_match:
+            # https://peps.python.org/pep-3333/#specification-details
+            # "...the application is allowed to modify the dictionary in any way it desires"
+            request.META[WSGI_DJANGO_ROUTE_ENVIRON_KEY] = resolver_match.route
+
+        return response

common/gunicorn/utils.py

@@ -0,0 +1,61 @@
+import argparse
+import os
+from typing import Any
+
+from django.core.handlers.wsgi import WSGIHandler
+from django.core.wsgi import get_wsgi_application
+from environs import Env
+from gunicorn.app.wsgiapp import (  # type: ignore[import-untyped]
+    WSGIApplication as GunicornWSGIApplication,
+)
+from gunicorn.config import Config  # type: ignore[import-untyped]
+
+env = Env()
+
+DEFAULT_ACCESS_LOG_FORMAT = '%(h)s %(l)s %(u)s %(t)s "%(r)s" %(s)s %(b)s "%(f)s" "%(a)s" %({origin}i)s %({access-control-allow-origin}o)s'
+GUNICORN_FLAGSMITH_DEFAULTS = {
+    "access_log_format": env.str("ACCESS_LOG_FORMAT", DEFAULT_ACCESS_LOG_FORMAT),
+    "accesslog": env.str("ACCESS_LOG_LOCATION", os.devnull),
+    "bind": "0.0.0.0:8000",
+    "config": "python:common.gunicorn.conf",
+    "logger_class": "common.gunicorn.logging.GunicornJsonCapableLogger",
+    "statsd_prefix": "flagsmith.api",
+    "threads": env.int("GUNICORN_THREADS", 1),
+    "timeout": env.int("GUNICORN_TIMEOUT", 30),
+    "worker_class": "sync",
+    "workers": env.int("GUNICORN_WORKERS", 1),
+}
+
+
+class DjangoWSGIApplication(GunicornWSGIApplication):  # type: ignore[misc]
+    def __init__(self, options: dict[str, Any] | None) -> None:
+        self.options = {
+            key: value for key, value in (options or {}).items() if value is not None
+        }
+        super().__init__()
+
+    def load_config(self) -> None:
+        cfg_settings = self.cfg.settings
+        options_items = (
+            (key, value)
+            for key, value in {**GUNICORN_FLAGSMITH_DEFAULTS, **self.options}.items()
+            if key in cfg_settings
+        )
+        for key, value in options_items:
+            self.cfg.set(key.lower(), value)
+        self.load_config_from_module_name_or_filename(self.cfg.config)
+
+    def load_wsgiapp(self) -> WSGIHandler:
+        return get_wsgi_application()
+
+
+def add_arguments(parser: argparse.ArgumentParser) -> None:
+    gunicorn_group = parser.add_argument_group("gunicorn")
+    _config = Config()
+    keys = sorted(_config.settings, key=_config.settings.__getitem__)
+    for key in keys:
+        _config.settings[key].add_option(gunicorn_group)
+
+
+def run_server(options: dict[str, Any] | None = None) -> None:
+    DjangoWSGIApplication(options).run()