gooddata-flight-server 1.34.1.dev1__py3-none-any.whl

gooddata_flight_server/utils/logging.py

@@ -0,0 +1,158 @@
+# (C) 2024 GoodData Corporation
+"""
+Logging configuration helper functions
+"""
+
+import os
+from logging.config import fileConfig
+from typing import Any, Optional, Union
+
+import orjson
+import structlog
+from opentelemetry import trace
+from structlog.typing import EventDict, WrappedLogger
+
+
+def _resolve_config(logging_ini: str, for_module: Optional[str]) -> str:
+    if os.path.isabs(logging_ini):
+        return logging_ini
+    else:
+        conf_dir = os.path.dirname(for_module) if for_module is not None else os.path.curdir
+
+        return os.path.join(conf_dir, logging_ini)
+
+
+class _ORJsonRenderer:
+    def __init__(self, output_bytes: bool = False):
+        self._output_bytes = output_bytes
+
+    @staticmethod
+    def default(obj: Any) -> Any:
+        # sets are not serializable by default, so convert them to lists
+        if isinstance(obj, set):
+            return list(obj)
+        # otherwise, do nothing, this will make the default logic to kick in
+
+    def __call__(self, logger: Any, name: str, event_dict: Any) -> Union[str, bytes]:
+        if self._output_bytes:
+            return orjson.dumps(event_dict, default=_ORJsonRenderer.default)
+
+        return orjson.dumps(event_dict, default=_ORJsonRenderer.default).decode("UTF-8")
+
+
+class _OtelTraceContextInjector:
+    """
+    Injects trace id, span id and parent span id obtained from current OpenTelemetry span.
+    """
+
+    __slots__ = ("_trace_id_key", "_span_id_key", "_parent_span_id_key")
+
+    def __init__(self, trace_ctx_keys: Optional[dict[str, str]] = None) -> None:
+        _keys = trace_ctx_keys or {}
+
+        # do one-time lookup of the actual key names under which the different
+        # otel info should be hammered. this exists here because server allows
+        # admins to provide mapping between default trace/span/parent span
+        # and desired key names.
+        #
+        # the mapping exists to improve fit into different contexts where
+        # server is integrated. the default 'trace_id' and 'span_id' keys may
+        # thwart observability experience if the rest of the system uses say 'traceId'
+        # and 'spanId'.
+        self._trace_id_key = _keys.get("trace_id", "trace_id")
+        self._span_id_key = _keys.get("span_id", "span_id")
+        self._parent_span_id_key = _keys.get("parent_span_id", "parent_span_id")
+
+    def __call__(self, _: WrappedLogger, __: str, event_dict: EventDict) -> EventDict:
+        span = trace.get_current_span()
+        if span == trace.INVALID_SPAN:
+            # bail out right away if the current span is not valid
+            #
+            # most typically, this happens if the log is being emitted while there is no
+            # current span set (e.g. code runs outside a trace span -> very valid scenario)
+            return event_dict
+
+        span_ctx = span.get_span_context()
+        event_dict[self._trace_id_key] = f"{span_ctx.trace_id:x}"
+        event_dict[self._span_id_key] = f"{span_ctx.span_id:x}"
+
+        parent_ctx: Optional[trace.SpanContext] = getattr(span, "parent", None)
+        if parent_ctx:
+            event_dict[self._parent_span_id_key] = f"{parent_ctx.span_id:x}"
+
+        return event_dict
+
+
+def _configure_structlog(
+    dev_log: bool,
+    event_key: str,
+    add_trace_ctx: bool = False,
+    trace_ctx_keys: Optional[dict[str, str]] = None,
+) -> None:
+    common_processors: list[Any] = [
+        structlog.stdlib.filter_by_level,
+        structlog.contextvars.merge_contextvars,
+    ]
+
+    if add_trace_ctx:
+        common_processors.append(_OtelTraceContextInjector(trace_ctx_keys))
+
+    common_processors.extend(
+        [
+            structlog.stdlib.add_logger_name,
+            structlog.stdlib.add_log_level,
+            structlog.stdlib.PositionalArgumentsFormatter(),
+            structlog.processors.TimeStamper(fmt="iso"),
+            structlog.processors.StackInfoRenderer(),
+            structlog.processors.format_exc_info,
+            structlog.processors.UnicodeDecoder(),
+        ]
+    )
+
+    if dev_log:
+        processors: Any = common_processors + [structlog.dev.ConsoleRenderer()]
+    else:
+        processors = common_processors + [
+            structlog.processors.EventRenamer(event_key),
+            _ORJsonRenderer(),
+        ]
+
+    structlog.configure(
+        processors=processors,
+        wrapper_class=structlog.stdlib.BoundLogger,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+
+def init_logging(
+    logging_ini: str,
+    dev_log: bool = False,
+    event_key: str = "event",
+    for_module: Optional[str] = None,
+    add_trace_ctx: bool = False,
+    trace_ctx_keys: Optional[dict[str, str]] = None,
+) -> str:
+    """
+    Initializes python logging from the file on the provided path. If the path is absolute, then it is
+    used as is. Otherwise lookup is done for a file relative to the provided module if it is specified; if not
+    specified, lookup is done for file relative to the current directory.
+
+    :param logging_ini: path to logging ini file
+    :param dev_log: specify true to configure logging in development mode; this mode is more convenient
+     during dev testing but not so suitable for production
+    :param event_key: name of the event key (default event)
+    :param for_module: optionally specify, module pathname; relative file config will be resolved
+     in regard to this module directory; otherwise goes against current dir
+    :param add_trace_ctx: optionally specify whether logging pipeline should include processor that hammers in
+     otel tracing information (trace id, span id)
+    :param trace_ctx_keys: optionally specify mapping for key names under which trace context will be dumped into
+     log events. default values are 'trace_id', 'span_id' and 'parent_span_id'. The mapping allows to override
+     those key names
+    :return: pathname of log file that was used to configure
+    """
+    log_config = _resolve_config(logging_ini, for_module)
+    fileConfig(log_config)
+    _configure_structlog(dev_log, event_key, add_trace_ctx, trace_ctx_keys)
+
+    return log_config

gooddata_flight_server/utils/methods_discovery.py

@@ -0,0 +1,98 @@
+#  (C) 2024 GoodData Corporation
+import importlib
+from functools import wraps
+from inspect import signature
+from typing import Optional
+
+from gooddata_flight_server.exceptions import FlightMethodsModuleError
+from gooddata_flight_server.server.base import (
+    FlightServerMethods,
+    FlightServerMethodsFactory,
+    ServerContext,
+)
+
+
+def flight_server_methods(fun: FlightServerMethodsFactory) -> FlightServerMethodsFactory:
+    """
+    Decorator that marks a function as the FlightServerMethodsFactory to be used.
+    Any module that should provide the methods factory should contain exactly one function decorated with this decorator.
+    """
+
+    @wraps(fun)
+    def wrapped(ctx: ServerContext) -> FlightServerMethods:
+        return fun(ctx)
+
+    wrapped.__is_flight_server_methods__ = True  # type: ignore
+    return wrapped
+
+
+def _is_flight_server_methods(obj: object) -> bool:
+    """
+    Checks whether the object is a FlightServerMethods.
+    """
+
+    return getattr(obj, "__is_flight_server_methods__", False)
+
+
+def _is_valid_flight_methods_factory(obj: object) -> bool:
+    """
+    Check whether the object is a valid FlightServerMethodsFactory.
+    """
+
+    return callable(obj) and len(signature(obj).parameters) == 1
+
+
+def _only_valid_flight_methods_factory(
+    module_name: str, factories: list[FlightServerMethodsFactory]
+) -> FlightServerMethodsFactory:
+    """
+    Validate the list of factories and return the only valid one.
+    """
+    if len(factories) == 0:
+        raise FlightMethodsModuleError(
+            f"No flight methods factory found in the module {module_name}. "
+            "Make sure the module exports exactly one function decorated with the `@flight_server_methods` decorator "
+            "that conforms to the FlightMethodsFactory protocol."
+        )
+
+    if len(factories) > 1:
+        raise FlightMethodsModuleError(
+            f"Multiple flight methods factories ({len(factories)}) found in the module {module_name}"
+            "Make sure the module exports exactly one function decorated with the `@flight_server_methods` decorator "
+            "that conforms to the FlightMethodsFactory protocol."
+        )
+
+    factory = factories[0]
+
+    if not _is_valid_flight_methods_factory(factory):
+        raise FlightMethodsModuleError(
+            f"Invalid flight methods factory in the module {module_name}. "
+            "Make sure the function conforms to the FlightMethodsFactory protocol: "
+            "that it takes the correct number of arguments and returns an instance of FlightServerMethods."
+        )
+
+    return factory
+
+
+def get_methods_factory(module_name: str, root: Optional[str] = None) -> FlightServerMethodsFactory:
+    """
+    Get the method factory from the given module.
+    The module should contain exactly one method decorated with @flight_server_methods.
+
+    :param module_name: name of the module containing the methods abstract factory.
+    :param root: root package of the module: this is used to resolve relative module names (mainly useful in tests).
+    :return: a FlightServerMethodsFactory
+    """
+
+    try:
+        module = importlib.import_module(module_name, package=root)
+    except ModuleNotFoundError as e:
+        raise FlightMethodsModuleError(f"Flight methods module {module_name} not found.") from e
+
+    factories: list[FlightServerMethodsFactory] = [
+        member.__wrapped__  # unwrap the actual instance from the marker decorator to keep the type
+        for member in module.__dict__.values()
+        if _is_flight_server_methods(member)
+    ]
+
+    return _only_valid_flight_methods_factory(module_name, factories)

gooddata_flight_server/utils/otel_tracing.py

@@ -0,0 +1,142 @@
+#  (C) 2024 GoodData Corporation
+import os
+import platform
+import socket
+import sys
+from typing import Optional
+
+from opentelemetry import trace
+from opentelemetry.sdk.resources import (
+    OS_DESCRIPTION,
+    OS_TYPE,
+    PROCESS_PARENT_PID,
+    PROCESS_PID,
+    PROCESS_RUNTIME_DESCRIPTION,
+    PROCESS_RUNTIME_NAME,
+    PROCESS_RUNTIME_VERSION,
+    SERVICE_INSTANCE_ID,
+    SERVICE_NAME,
+    SERVICE_NAMESPACE,
+    SERVICE_VERSION,
+    Resource,
+)
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import (
+    BatchSpanProcessor,
+    ConsoleSpanExporter,
+    SpanExporter,
+)
+
+from gooddata_flight_server._version import __version__
+from gooddata_flight_server.config.config import OtelConfig, OtelExporterType
+
+SERVER_TRACER: trace.Tracer = trace.ProxyTracer("gooddata_flight_server")
+"""
+Tracer to use for all spans created within the server - all code in this package should
+use this one single tracer.
+"""
+
+
+def _create_console_span_exporter() -> SpanExporter:
+    return ConsoleSpanExporter()
+
+
+def _create_zipkin_span_exporter() -> SpanExporter:
+    from opentelemetry.exporter.zipkin.json import (
+        ZipkinExporter,  # type: ignore
+    )
+
+    return ZipkinExporter()
+
+
+def _create_otlp_grpc_exporter() -> SpanExporter:
+    from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
+        OTLPSpanExporter,  # type: ignore
+    )
+
+    return OTLPSpanExporter()
+
+
+def _create_otlp_http_exporter() -> SpanExporter:
+    from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+        OTLPSpanExporter,  # type: ignore
+    )
+
+    return OTLPSpanExporter()
+
+
+def _create_exporter(config: OtelConfig) -> SpanExporter:
+    if config.exporter_type == OtelExporterType.Console:
+        return _create_console_span_exporter()
+    elif config.exporter_type == OtelExporterType.Zipkin:
+        return _create_zipkin_span_exporter()
+    elif config.exporter_type == OtelExporterType.OtlpGrpc:
+        return _create_otlp_grpc_exporter()
+    elif config.exporter_type == OtelExporterType.OtlpHttp:
+        return _create_otlp_http_exporter()
+
+    raise AssertionError(f"Unsupported exporter type '{config.exporter_type}'.")
+
+
+def _default_service_instance_id() -> str:
+    return socket.gethostbyaddr("127.0.0.1")[0] if platform.system() == "Darwin" else socket.getfqdn()
+
+
+def _create_resource(config: OtelConfig) -> Resource:
+    # all PROCESS_RUNTIME_* attribute values including the code below picked as-is
+    # from recommendations written in:
+    #
+    # https://opentelemetry.io/docs/specs/semconv/resource/process/#python-runtimes
+    vinfo = sys.implementation.version
+    process_runtime_version = ".".join(
+        map(
+            str,
+            vinfo[:3] if vinfo.releaselevel == "final" and not vinfo.serial else vinfo,
+        )
+    )
+
+    service_instance_id = config.service_instance_id or _default_service_instance_id()
+
+    return Resource.create(
+        attributes={
+            SERVICE_NAME: config.service_name,
+            SERVICE_VERSION: __version__,
+            SERVICE_INSTANCE_ID: service_instance_id,
+            SERVICE_NAMESPACE: config.service_namespace or "",
+            OS_TYPE: platform.system().lower(),
+            OS_DESCRIPTION: platform.platform(terse=True),
+            PROCESS_PID: os.getpid(),
+            PROCESS_PARENT_PID: os.getppid(),
+            PROCESS_RUNTIME_NAME: sys.implementation.name,
+            PROCESS_RUNTIME_VERSION: process_runtime_version,
+            PROCESS_RUNTIME_DESCRIPTION: sys.version,
+            "os.version": platform.release(),
+        }
+    )
+
+
+def initialize_otel_tracing(config: Optional[OtelConfig]) -> None:
+    """
+    Initializes OpenTelemetry tracing according to the provided `config`:
+
+    - If the config is specified, the method creates the desired exporter and
+      initializes the tracer provider to pipe traces to it
+
+    - If the config is None, the method will initialize tracer provider to
+      NoOp implementation.
+
+    :param config: server's open telemetry configuration
+    :return: None
+    """
+    if config is None or config.exporter_type is None:
+        trace.set_tracer_provider(trace.NoOpTracerProvider())
+        return
+
+    resource = _create_resource(config)
+    span_exporter = _create_exporter(config)
+
+    span_processor = BatchSpanProcessor(span_exporter=span_exporter)
+
+    tracer_provider = TracerProvider(resource=resource)
+    tracer_provider.add_span_processor(span_processor=span_processor)
+    trace.set_tracer_provider(tracer_provider=tracer_provider)

gooddata_flight_server-1.34.1.dev1.data/scripts/gooddata-flight-server

@@ -0,0 +1,10 @@
+#!python
+# (C) 2024 GoodData Corporation
+import re
+import sys
+
+import gooddata_flight_server.cli as server
+
+if __name__ == "__main__":
+    sys.argv[0] = re.sub(r"(-script\.pyw?|\.exe)?$", "", sys.argv[0])
+    sys.exit(server.server_cli())

gooddata_flight_server-1.34.1.dev1.dist-info/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright (c) 2024 GoodData Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.