unstructured-platform-plugins 0.0.2__tar.gz → 0.0.5__tar.gz

{unstructured-platform-plugins-0.0.2/unstructured_platform_plugins.egg-info → unstructured-platform-plugins-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unstructured-platform-plugins
-Version: 0.0.2
+Version: 0.0.5
 Summary: A utility library that provides tools around unstructured plugin development
 Home-page: https://github.com/Unstructured-IO/unstructured-platform-plugins
 License: Apache-2.0

{unstructured-platform-plugins-0.0.2 → unstructured-platform-plugins-0.0.5}/test/test_schema.py

@@ -554,6 +554,10 @@ def test_file_data():
                                 ],
                                 "default": None,
                             },
+                            "filesize_bytes": {
+                                "anyOf": [{"type": "integer"}, {"type": "null"}],
+                                "default": None,
+                            },
                         },
                         "required": [],
                     },
@@ -562,6 +566,10 @@ def test_file_data():
                         "items": {"key": {"type": "string"}, "value": {}},
                     },
                     "reprocess": {"type": "boolean", "default": False},
+                    "local_download_path": {
+                        "anyOf": [{"type": "string"}, {"type": "null"}],
+                        "default": None,
+                    },
                 },
                 "required": ["identifier", "connector_type", "metadata", "additional_metadata"],
             }
@@ -643,6 +651,10 @@ def test_file_data():
                             ],
                             "default": None,
                         },
+                        "filesize_bytes": {
+                            "anyOf": [{"type": "integer"}, {"type": "null"}],
+                            "default": None,
+                        },
                     },
                     "required": [],
                 },
@@ -651,6 +663,10 @@ def test_file_data():
                     "items": {"key": {"type": "string"}, "value": {}},
                 },
                 "reprocess": {"type": "boolean", "default": False},
+                "local_download_path": {
+                    "anyOf": [{"type": "string"}, {"type": "null"}],
+                    "default": None,
+                },
             },
             "required": ["identifier", "connector_type", "metadata", "additional_metadata"],
         },

unstructured-platform-plugins-0.0.5/unstructured_platform_plugins/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.0.5"  # pragma: no cover

{unstructured-platform-plugins-0.0.2 → unstructured-platform-plugins-0.0.5}/unstructured_platform_plugins/etl_uvicorn/api_generator.py

@@ -3,13 +3,17 @@ import hashlib
 import inspect
 import json
 import logging
+from functools import partial
 from typing import Any, Callable, Optional
 
 from fastapi import FastAPI, status
+from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
 from pydantic import BaseModel
 from starlette.responses import RedirectResponse
+from uvicorn.config import LOG_LEVELS
 from uvicorn.importer import import_from_string
 
+from unstructured_platform_plugins.etl_uvicorn.otel import get_metric_provider, get_trace_provider
 from unstructured_platform_plugins.etl_uvicorn.utils import (
     get_func,
     get_input_schema,
@@ -26,12 +30,28 @@ from unstructured_platform_plugins.schema.usage import UsageData
 logger = logging.getLogger("uvicorn.error")
 
 
+def log_func_and_body(func: Callable, body: Optional[str] = None) -> None:
+    msg = None
+    if logger.level == LOG_LEVELS.get("debug", logging.NOTSET):
+        if not body:
+            msg = f"invoking function without inputs: {func.__name__}"
+        else:
+            msg = f"invoking function {func.__name__} with body"
+    elif logger.level == LOG_LEVELS.get("trace", logging.NOTSET):
+        if not body:
+            msg = f"invoking function without inputs: {func}"
+        else:
+            msg = f"invoking function {func} with body: {body}"
+    if msg:
+        logger.log(level=logger.level, msg=msg)
+
+
 async def invoke_func(func: Callable, kwargs: Optional[dict[str, Any]] = None) -> Any:
     kwargs = kwargs or {}
     if inspect.iscoroutinefunction(func):
         return await func(**kwargs)
     else:
-        return func(**kwargs)
+        return await asyncio.get_event_loop().run_in_executor(None, partial(func, **kwargs))
 
 
 def check_precheck_func(precheck_func: Callable):
@@ -113,18 +133,19 @@ def generate_fast_api(
 
         @fastapi_app.post("/invoke", response_model=InvokeResponse)
         async def run_job(request: input_schema_model) -> InvokeResponse:
-            logger.debug(f"invoking function {func} with input: {request.model_dump()}")
+            log_func_and_body(func=func, body=request.json())
             # Create dictionary from pydantic model while preserving underlying types
             request_dict = {f: getattr(request, f) for f in request.model_fields}
             map_inputs(func=func, raw_inputs=request_dict)
-            logger.debug(f"passing inputs to function: {request_dict}")
+            if logger.level == LOG_LEVELS.get("trace", logging.NOTSET):
+                logger.log(level=logger.level, msg=f"passing inputs to function: {request_dict}")
             return await wrap_fn(func=func, kwargs=request_dict)
 
     else:
 
         @fastapi_app.post("/invoke", response_model=InvokeResponse)
         async def run_job() -> InvokeResponse:
-            logger.debug(f"invoking function without inputs: {func}")
+            log_func_and_body(func=func)
             return await wrap_fn(
                 func=func,
             )
@@ -170,4 +191,8 @@ def generate_fast_api(
     except TypeError as e:
         raise TypeError(f"failed to validate function schema: {e}") from e
 
+    FastAPIInstrumentor.instrument_app(
+        fastapi_app, tracer_provider=get_trace_provider(), meter_provider=get_metric_provider()
+    )
+
     return fastapi_app

unstructured-platform-plugins-0.0.5/unstructured_platform_plugins/etl_uvicorn/otel.py

@@ -0,0 +1,107 @@
+import os
+from typing import Literal, TypedDict
+
+from opentelemetry.environment_variables import OTEL_METRICS_EXPORTER, OTEL_TRACES_EXPORTER
+from opentelemetry.sdk.environment_variables import OTEL_SERVICE_NAME
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics.export import (
+    ConsoleMetricExporter,
+    MetricReader,
+    PeriodicExportingMetricReader,
+)
+from opentelemetry.sdk.resources import SERVICE_NAME, Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import (
+    ConsoleSpanExporter,
+    SimpleSpanProcessor,
+)
+
+TraceExporterType = Literal["otlp", "jaeger", "zipkin", "console"]
+MetricExporterType = Literal["otlp", "prometheus", "none"]
+
+
+class OtelSettings(TypedDict):
+    service_name: str
+    trace_exporters: list[TraceExporterType]
+    metric_exporters: list[MetricExporterType]
+
+
+def get_settings() -> OtelSettings:
+    service_name = os.environ.get(OTEL_SERVICE_NAME, "unknown_service")
+    trace_exporters = os.environ.get(OTEL_TRACES_EXPORTER)
+    trace_exporters = trace_exporters.split(",") if trace_exporters else []
+
+    metric_exporters = os.environ.get(OTEL_METRICS_EXPORTER)
+    metric_exporters = metric_exporters.split(",") if metric_exporters else []
+    return OtelSettings(
+        service_name=service_name,
+        trace_exporters=trace_exporters,
+        metric_exporters=metric_exporters,
+    )
+
+
+def get_trace_provider() -> TracerProvider:
+    settings = get_settings()
+    print(settings)
+    provider = TracerProvider(resource=Resource({SERVICE_NAME: settings["service_name"]}))
+
+    for trace_exporter_type in settings["trace_exporters"]:
+        _add_trace_exporter(exporter_type=trace_exporter_type, provider=provider)
+
+    return provider
+
+
+def get_metric_provider() -> MeterProvider:
+    settings = get_settings()
+    readers = []
+    for metric_exporter_type in settings["metric_exporters"]:
+        readers.append(_get_metrics_reader(exporter_type=metric_exporter_type))
+    return MeterProvider(
+        resource=Resource({SERVICE_NAME: settings["service_name"]}), metric_readers=readers
+    )
+
+
+def _add_trace_exporter(exporter_type: TraceExporterType, provider: TracerProvider):
+    if exporter_type == "otlp":
+        _add_traces_otlp_exporter(
+            provider,
+        )
+
+    elif exporter_type == "console":
+        _add_traces_console_exporter(provider)
+    else:
+        raise NotImplementedError(f"{exporter_type} implementation not supported yet")
+
+
+def _get_metrics_reader(exporter_type: MetricExporterType) -> MetricReader:
+    if exporter_type == "otlp":
+        return _get_metric_otlp_reader()
+    if exporter_type == "console":
+        return _get_metric_console_reader()
+    raise NotImplementedError(f"{exporter_type} implementation not supported yet")
+
+
+def _add_traces_console_exporter(provider: TracerProvider) -> None:
+    exporter = ConsoleSpanExporter()
+    processor = SimpleSpanProcessor(exporter)
+    provider.add_span_processor(processor)
+
+
+def _add_traces_otlp_exporter(provider: TracerProvider) -> None:
+    from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+
+    exporter = OTLPSpanExporter()
+    processor = SimpleSpanProcessor(exporter)
+    provider.add_span_processor(processor)
+
+
+def _get_metric_otlp_reader() -> MetricReader:
+    from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
+
+    exporter = OTLPMetricExporter()
+    return PeriodicExportingMetricReader(exporter)
+
+
+def _get_metric_console_reader() -> MetricReader:
+    exporter = ConsoleMetricExporter()
+    return PeriodicExportingMetricReader(exporter)

{unstructured-platform-plugins-0.0.2 → unstructured-platform-plugins-0.0.5/unstructured_platform_plugins.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unstructured-platform-plugins
-Version: 0.0.2
+Version: 0.0.5
 Summary: A utility library that provides tools around unstructured plugin development
 Home-page: https://github.com/Unstructured-IO/unstructured-platform-plugins
 License: Apache-2.0

{unstructured-platform-plugins-0.0.2 → unstructured-platform-plugins-0.0.5}/unstructured_platform_plugins.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ unstructured_platform_plugins.egg-info/top_level.txt
 unstructured_platform_plugins/etl_uvicorn/__init__.py
 unstructured_platform_plugins/etl_uvicorn/api_generator.py
 unstructured_platform_plugins/etl_uvicorn/main.py
+unstructured_platform_plugins/etl_uvicorn/otel.py
 unstructured_platform_plugins/etl_uvicorn/utils.py
 unstructured_platform_plugins/schema/__init__.py
 unstructured_platform_plugins/schema/json_schema.py

unstructured-platform-plugins-0.0.5/unstructured_platform_plugins.egg-info/requires.txt

@@ -0,0 +1,8 @@
+opentelemetry-instrumentation-fastapi
+uvicorn
+opentelemetry-exporter-otlp-proto-grpc
+click
+unstructured-ingest
+fastapi
+click
+requests

unstructured-platform-plugins-0.0.2/unstructured_platform_plugins/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.0.2"  # pragma: no cover

unstructured-platform-plugins-0.0.2/unstructured_platform_plugins.egg-info/requires.txt

@@ -1,6 +0,0 @@
-click
-uvicorn
-unstructured-ingest
-fastapi
-click
-requests