gl-observability-binary 0.0.0b1__cp313-cp313-win_amd64.whl → 0.1.1__cp313-cp313-win_amd64.whl

gl_observability/__init__.pyi

@@ -1,4 +1,6 @@
-from gl_observability.backend import OpenTelemetryConfig as OpenTelemetryConfig, SentryConfig as SentryConfig
 from gl_observability.initializer import TelemetryConfig as TelemetryConfig, init_telemetry as init_telemetry
+from gl_observability.traces.backend.opentelemetry import OpenTelemetryBackendConfig as OpenTelemetryBackendConfig
+from gl_observability.traces.backend.sentry import SentryBackendConfig as SentryBackendConfig
+from gl_observability.traces.config import FastAPIConfig as FastAPIConfig
 
-__all__ = ['OpenTelemetryConfig', 'SentryConfig', 'TelemetryConfig', 'init_telemetry']
+__all__ = ['TelemetryConfig', 'init_telemetry', 'FastAPIConfig', 'OpenTelemetryBackendConfig', 'SentryBackendConfig']

gl_observability/initializer.pyi

@@ -1,24 +1,66 @@
 from _typeshed import Incomplete
-from gl_observability.backend.opentelemetry.initializer import OpenTelemetryConfig as OpenTelemetryConfig, init_otel_with_external_exporter as init_otel_with_external_exporter
-from gl_observability.backend.sentry.initializer import SentryConfig as SentryConfig, init_sentry as init_sentry
+from gl_observability.traces.backend.opentelemetry import OpenTelemetryBackendConfig as OpenTelemetryBackendConfig, init_otel_with_external_exporter as init_otel_with_external_exporter
+from gl_observability.traces.backend.sentry import SentryBackendConfig as SentryBackendConfig, init_sentry as init_sentry
+from gl_observability.traces.config import FastAPIConfig as FastAPIConfig, OpenTelemetryTraceConfig as OpenTelemetryTraceConfig, auto_initialize_services as auto_initialize_services, setup_tracer_provider as setup_tracer_provider
+from opentelemetry.sdk.trace.sampling import Sampler
 
 class TelemetryConfig:
-    """Configuration class for telemetry config."""
-    sentry_config: Incomplete
-    otel_config: Incomplete
-    def __init__(self, sentry_config: SentryConfig | None = None, otel_config: OpenTelemetryConfig | None = None) -> None:
-        """Initializes the telemetry configuration object with the specified parameters.
+    """Configuration for telemetry initialization.
+
+    All instrumentation is done via OpenTelemetry.
+    """
+    trace_sampler: Incomplete
+    attributes: Incomplete
+    fastapi_config: Incomplete
+    use_langchain: Incomplete
+    use_httpx: Incomplete
+    use_requests: Incomplete
+    backend_config: Incomplete
+    def __init__(self, *, attributes: dict[str, str] | None = None, trace_sampler: Sampler | None = None, fastapi_config: FastAPIConfig | None = None, use_langchain: bool = False, use_httpx: bool = True, use_requests: bool = True, backend_config: OpenTelemetryBackendConfig | SentryBackendConfig | None = None) -> None:
+        """Initialize the telemetry configuration.
 
         Args:
-            sentry_config (SentryConfig): The Sentry configuration.
-            otel_config: The OpenTelemetry config.
+            attributes (dict[str, str] | None, optional): Resource attributes. Defaults to None.
+            trace_sampler (Sampler | None, optional): The sampler for traces. Defaults to None.
+            fastapi_config (FastAPIConfig | None, optional): FastAPI configuration for instrumentation.
+                Defaults to None.
+            use_langchain (bool, optional): Enable Langchain instrumentation. Defaults to False.
+            use_httpx (bool, optional): Enable HTTPX instrumentation. Defaults to True.
+            use_requests (bool, optional): Enable Requests instrumentation. Defaults to True.
+            backend_config (OpenTelemetryBackendConfig | SentryBackendConfig | None, optional): The telemetry
+                backend configuration. Defaults to None. Make sure to set at least one backend configuration,
+                if not traces will not be exported.
         """
 
 def init_telemetry(config: TelemetryConfig) -> None:
-    """Initializes telemetry for error tracking and performance monitoring.
+    '''Initialize telemetry for tracing.
+
+    This function initializes OpenTelemetry instrumentation with the specified backend.
+    All tracing is done via OpenTelemetry regardless of the backend.
 
-    Initializes telemetry with the specified parameters.
+    Supported backends:
+    - OTLP: Export traces to an OTLP endpoint (Jaeger, Tempo, etc.)
+    - Sentry: Export traces to Sentry using OpenTelemetry
+
+    Examples:
+        Basic OTLP setup:
+        >>> from gl_observability import TelemetryConfig, init_telemetry, OpenTelemetryBackendConfig
+        >>>
+        >>> config = TelemetryConfig(
+        ...     attributes={"service.name": "my-service"},
+        ...     backend_config=OpenTelemetryBackendConfig(endpoint="localhost:4317")
+        ... )
+        >>> init_telemetry(config)
+
+        Sentry setup:
+        >>> from gl_observability import TelemetryConfig, init_telemetry, SentryBackendConfig
+        >>>
+        >>> config = TelemetryConfig(
+        ...     attributes={"service.name": "my-service"},
+        ...     backend_config=SentryBackendConfig(dsn="https://...")
+        ... )
+        >>> init_telemetry(config)
 
     Args:
         config (TelemetryConfig): The telemetry configuration.
-    """
+    '''

gl_observability/traces/backend/opentelemetry.pyi

@@ -0,0 +1,30 @@
+from _typeshed import Incomplete
+from opentelemetry.sdk.trace import TracerProvider
+from typing import Any
+
+class OpenTelemetryBackendConfig:
+    """Configuration for OpenTelemetry OTLP exporter."""
+    endpoint: Incomplete
+    headers: Incomplete
+    use_grpc: Incomplete
+    additional_options: Incomplete
+    def __init__(self, *, endpoint: str, headers: dict[str, str] = None, use_grpc: bool = True, **kwargs: Any) -> None:
+        '''Initializes the OpenTelemetryBackendConfig configuration object with the specified parameters.
+
+        Args:
+            endpoint (str): The OTLP endpoint e.g. "https://localhost:4318".
+            headers (dict[str, str], optional): Headers with key value for connecting to the exporter. Defaults to None.
+            use_grpc (bool, optional): Use gRPC for OpenTelemetry exporter. Defaults to True.
+            **kwargs: Additional keyword arguments passed to OTLPSpanExporter.
+        '''
+
+def init_otel_with_external_exporter(config: OpenTelemetryBackendConfig, tracer_provider: TracerProvider) -> None:
+    """Initialize OpenTelemetry with an external OTLP exporter.
+
+    This method initializes OpenTelemetry with an external exporter (OTLP)
+    and instruments FastAPI, Langchain, HTTPX, and Requests if configured.
+
+    Args:
+        config (OpenTelemetryBackendConfig): The OTLP exporter configuration.
+        tracer_provider (TracerProvider): The tracer provider to use.
+    """

gl_observability/traces/backend/sentry.pyi

@@ -0,0 +1,37 @@
+from _typeshed import Incomplete
+from opentelemetry.sdk.trace import TracerProvider
+from typing import Any
+
+class SentryBackendConfig:
+    """Configuration object for Sentry initialization."""
+    dsn: Incomplete
+    environment: Incomplete
+    release: Incomplete
+    profiles_sample_rate: Incomplete
+    send_default_pii: Incomplete
+    disable_sentry_distributed_tracing: Incomplete
+    additional_options: Incomplete
+    def __init__(self, *, dsn: str | None = None, environment: str | None = None, release: str | None = None, profiles_sample_rate: float | None = None, send_default_pii: bool | None = None, disable_sentry_distributed_tracing: bool = False, **kwargs: Any) -> None:
+        """Initializes the Sentry configuration object with the specified parameters.
+
+        Args:
+            dsn (str | None, optional): The Sentry Project DSN. Defaults to None.
+            environment (str | None, optional): The environment for the Sentry project. Defaults to None.
+            release (str | None, optional): The release version for the Sentry project. Defaults to None.
+            profiles_sample_rate (float | None, optional): The sample rate for performance monitoring. Defaults to None.
+            send_default_pii (bool | None, optional): Whether to send default Personally Identifiable Information (PII).
+                Defaults to None.
+            disable_sentry_distributed_tracing (bool, optional): Whether to disable distributed tracing for Sentry.
+                Defaults to False.
+            **kwargs: Additional keyword arguments to pass to sentry_sdk.init
+        """
+
+def init_sentry(config: SentryBackendConfig, tracer_provider: TracerProvider) -> None:
+    """Initializes Sentry with OpenTelemetry for error tracking and performance monitoring.
+
+    Initializes Sentry with the specified parameters.
+
+    Args:
+        config (SentryBackendConfig): The configuration object for Sentry initialization.
+        tracer_provider (TracerProvider): The tracer provider to use.
+    """

gl_observability/traces/config.pyi

@@ -0,0 +1,48 @@
+from _typeshed import Incomplete
+from fastapi import FastAPI
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.sampling import Sampler
+
+class FastAPIConfig:
+    """Configuration for FastAPI instrumentation."""
+    app: Incomplete
+    def __init__(self, app: FastAPI) -> None:
+        """Initialize FastAPI configuration.
+
+        Args:
+            app (FastAPI): The FastAPI application instance.
+        """
+
+class OpenTelemetryTraceConfig:
+    """Configuration for OpenTelemetry Trace initialization."""
+    provider: TracerProvider | None
+    attributes: Incomplete
+    trace_sampler: Incomplete
+    fastapi_config: Incomplete
+    use_langchain: Incomplete
+    use_httpx: Incomplete
+    use_requests: Incomplete
+    def __init__(self, *, attributes: dict[str, str], trace_sampler: Sampler | None, fastapi_config: FastAPIConfig | None, use_langchain: bool, use_httpx: bool, use_requests: bool) -> None:
+        """Initialize OpenTelemetry configuration.
+
+        Args:
+            attributes (dict[str, str]): Resource attributes.
+            trace_sampler (Sampler): Trace sampler.
+            fastapi_config (FastAPIConfig): FastAPI configuration.
+            use_langchain (bool): Enable Langchain instrumentation.
+            use_httpx (bool): Enable HTTPX instrumentation.
+            use_requests (bool): Enable Requests instrumentation.
+        """
+
+def setup_tracer_provider(opentelemetry_config: OpenTelemetryTraceConfig):
+    """Set up the TracerProvider with the given configuration.
+
+    Args:
+        opentelemetry_config (OpenTelemetryTraceConfig): The configuration for OpenTelemetry.
+    """
+def auto_initialize_services(opentelemetry_config: OpenTelemetryTraceConfig) -> None:
+    """Automatically initialize FastAPI, Langchain, HTTPX, and Requests tracing if applicable.
+
+    Args:
+        opentelemetry_config (OpenTelemetryTraceConfig): The configuration for OpenTelemetry.
+    """

gl_observability/traces/{opentelemetry/instrument → instrument}/functions.pyi

@@ -1,7 +1,7 @@
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from typing import Collection
 
-class BOSAFunctionsInstrumentor(BaseInstrumentor):
+class FunctionsInstrumentor(BaseInstrumentor):
     """OpenTelemetry Generic Function Instrumentor.
 
     Supports:
@@ -61,7 +61,7 @@ class BOSAFunctionsInstrumentor(BaseInstrumentor):
         from module.classes.custom_class import CustomClass
 
         # Instrument all functions in the module
-        BOSAFunctionsInstrumentor().instrument(
+        FunctionsInstrumentor().instrument(
             methods=[
                 functions.sync_function, functions.async_function,
                 CustomClass.method, CustomClass.class_method,
@@ -85,7 +85,7 @@ class BOSAFunctionsInstrumentor(BaseInstrumentor):
         await functions.async_function(...)
 
         # Uninstrument all functions in the module
-        BOSAFunctionsInstrumentor().uninstrument()
+        FunctionsInstrumentor().uninstrument()
         ```
 
     Note:

gl_observability/traces/{opentelemetry/instrument → instrument}/http.pyi

@@ -1,7 +1,7 @@
 import http.client
 from dataclasses import dataclass
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
-from opentelemetry.trace import Span, Tracer as Tracer, TracerProvider as TracerProvider
+from opentelemetry.trace import Span, Tracer, TracerProvider
 from typing import Any, Callable
 
 METHOD_INDEX: int

gl_observability.pyi

@@ -1,8 +1,10 @@
 # This file was generated by Nuitka
 
 # Stubs included by default
+from gl_observability.traces.backend.opentelemetry import OpenTelemetryBackendConfig
+from gl_observability.traces.config import FastAPIConfig
+from gl_observability.traces.backend.sentry import SentryBackendConfig
 from gl_observability.initializer import TelemetryConfig, init_telemetry
-from gl_observability.backend import OpenTelemetryConfig, SentryConfig
 
 
 __name__ = ...
@@ -11,10 +13,14 @@ __name__ = ...
 
 # Modules used internally, to allow implicit dependencies to be seen:
 import os
-import gl_observability.backend.OpenTelemetryConfig
-import gl_observability.backend.SentryConfig
-import fastapi
 import opentelemetry
+import opentelemetry.sdk
+import opentelemetry.sdk.trace
+import opentelemetry.sdk.trace.sampling
+import logging
+import typing
+import requests
+import re
 import opentelemetry.exporter
 import opentelemetry.exporter.otlp
 import opentelemetry.exporter.otlp.proto
@@ -22,24 +28,18 @@ import opentelemetry.exporter.otlp.proto.grpc
 import opentelemetry.exporter.otlp.proto.grpc.trace_exporter
 import opentelemetry.exporter.otlp.proto.http
 import opentelemetry.exporter.otlp.proto.http.trace_exporter
+import opentelemetry.sdk.trace.export
+import sentry_sdk
+import opentelemetry.propagate
+import sentry_sdk.integrations
+import sentry_sdk.integrations.opentelemetry
+import fastapi
 import opentelemetry.instrumentation
 import opentelemetry.instrumentation.fastapi
 import opentelemetry.instrumentation.httpx
 import opentelemetry.instrumentation.langchain
 import opentelemetry.instrumentation.requests
-import opentelemetry.propagate
-import opentelemetry.sdk
 import opentelemetry.sdk.resources
-import opentelemetry.sdk.trace
-import opentelemetry.sdk.trace.export
-import opentelemetry.sdk.trace.sampling
-import sentry_sdk
-import sentry_sdk.integrations
-import sentry_sdk.integrations.opentelemetry
-import typing
-import logging
-import requests
-import re
 import importlib
 import inspect
 import wrapt

{gl_observability_binary-0.0.0b1.dist-info → gl_observability_binary-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gl-observability-binary
-Version: 0.0.0b1
+Version: 0.1.1
 Summary: SDK for Observability tools
 Author-email: HansSeanNathanael <hans.s.nathanael@gdplabs.id>
 Requires-Python: <3.14,>=3.11
@@ -34,7 +34,7 @@ Requires-Dist: ruff<1.0.0,>=0.11.12; extra == "dev"
 
 ## Key Features
 
-- 📊 **OpenTelemetry Integration**: simplified initialization for tracing and metrics.
+- 📊 **OpenTelemetry Integration**: simplified initialization for tracing.
 - 🛡️ **Sentry Support**: easy setup for error tracking and performance monitoring.
 - 🕵️ **PII Redaction**: custom logging handlers to redact PII using Regex or NER (Named Entity Recognition).
 - 🔌 **Framework Support**: built-in support for FastAPI, Langchain, HTTPX, and Requests instrumentation.
@@ -84,34 +84,39 @@ poetry add "git+ssh://git@github.com/GDP-ADMIN/gl-sdk.git#subdirectory=libs/gl-o
 
 ### 1. Telemetry Initialization
 
-The library uses a unified `init_telemetry` function that takes a `TelemetryConfig` object. You can configure it for OpenTelemetry, Sentry, or both.
+The library uses a unified `init_telemetry` function that takes a `TelemetryConfig` object. You can configure it to send traces to OpenTelemetry (OTLP) or Sentry backend. Multiple backend configuration is supported.
 
-#### OpenTelemetry Configuration (External Exporter)
+#### OpenTelemetry Configuration
 
 This setup sends traces to an external OTLP collector (e.g., Jaeger, Tempo).
 
 ```python
 from fastapi import FastAPI
-from gl_observability.backend import FastAPIConfig, OpenTelemetryConfig
-from gl_observability import TelemetryConfig, init_telemetry
+from gl_observability import init_telemetry, TelemetryConfig, OpenTelemetryBackendConfig, FastAPIConfig
 
 # 1. Setup FastAPI Config (optional, if using FastAPI)
 app = FastAPI()
 fastapi_config = FastAPIConfig(app=app)
 
-# 2. Configure OpenTelemetry
-otel_config = OpenTelemetryConfig(
-    endpoint="localhost:4317",  # OTLP endpoint
-    use_grpc=False,             # Use gRPC or HTTP
-    fastapi_config=fastapi_config,
-    use_langchain=True,         # Enable Langchain instrumentation
-    use_httpx=True,             # Enable HTTPX instrumentation
-    use_requests=True,          # Enable Requests instrumentation
-    attributes={"service.name": "my-service", "env": "production"}
+# 2. Configure OpenTelemetryBackendConfig
+otel_backend_config = OpenTelemetryBackendConfig(
+    endpoint="localhost:4318",                  # OTLP endpoint
+    use_grpc=False,                             # Use gRPC or HTTP
+    headers={"Authorization": "Bearer ..."},    # Optional headers
 )
 
-# 3. Initialize Telemetry
-init_telemetry(TelemetryConfig(otel_config=otel_config))
+# 3. Configure TelemetryConfig
+otel_config = TelemetryConfig(
+    attributes={"service.name": "..."},         # Resource attributes
+    backend_config=otel_backend_config,         # Backend configuration
+    fastapi_config=fastapi_config,              # FastAPI Instrumentation
+    use_langchain=True,                         # Enable Langchain instrumentation
+    use_httpx=True,                             # Enable HTTPX instrumentation
+    use_requests=True,                          # Enable Requests instrumentation
+)
+
+# 4. Initialize Telemetry
+init_telemetry(otel_config)
 ```
 
 #### Sentry Configuration
@@ -119,54 +124,69 @@ init_telemetry(TelemetryConfig(otel_config=otel_config))
 This setup sends errors and traces to Sentry.
 
 ```python
-from gl_observability.backend import SentryConfig
-from gl_observability import TelemetryConfig, init_telemetry
-
-def traces_sampler(sampling_context: dict) -> float:
-    """Custom trace sampler."""
-    return 1.0
-
-# 1. Configure Sentry
-sentry_config = SentryConfig(
-    dsn="your-sentry-dsn",
-    environment="production",
-    release="1.0.0",
-    traces_sampler=traces_sampler,
-    send_default_pii=True
+from fastapi import FastAPI
+from gl_observability import init_telemetry, TelemetryConfig, SentryBackendConfig, FastAPIConfig
+
+# 1. Setup FastAPI Config (optional, if using FastAPI)
+app = FastAPI()
+fastapi_config = FastAPIConfig(app=app)
+
+# 2. Configure SentryBackendConfig
+sentry_backend_config = SentryBackendConfig(
+    dsn="https://...",
+    environment="...",
+    release="...",
+    send_default_pii=True,
+    disable_sentry_distributed_tracing=False
 )
 
-# 2. Initialize Telemetry
-init_telemetry(TelemetryConfig(sentry_config=sentry_config))
+# 3. Configure TelemetryConfig
+otel_config = TelemetryConfig(
+    attributes={"service.name": "..."},         # Resource attributes
+    backend_config=sentry_backend_config,       # Backend configuration
+    fastapi_config=fastapi_config,              # FastAPI Instrumentation
+    use_langchain=True,                         # Enable Langchain instrumentation
+    use_httpx=True,                             # Enable HTTPX instrumentation
+    use_requests=True,                          # Enable Requests instrumentation
+)
+
+# 4. Initialize Telemetry
+init_telemetry(otel_config)
 ```
 
-#### Sentry with OpenTelemetry
+#### Multiple Backend Configuration
 
-This setup combines Sentry with OpenTelemetry instrumentation, allowing Sentry to capture OTel spans.
+This setup the OpenTelemetry SDK used for tracing.
 
 ```python
 from fastapi import FastAPI
-from gl_observability.backend import FastAPIConfig, OpenTelemetryConfig, SentryConfig
-from gl_observability import TelemetryConfig, init_telemetry
-
-app = FastAPI()
-fastapi_config = FastAPIConfig(app=app)
-
-# 1. Configure OpenTelemetry (without endpoint, as Sentry handles export)
-otel_config = OpenTelemetryConfig(
-    attributes={"service.name": "my-service"},
-    fastapi_config=fastapi_config,
-    use_langchain=True
+from gl_observability import init_telemetry, TelemetryConfig, OpenTelemetryBackendConfig, SentryBackendConfig
+
+jaeger_backend = OpenTelemetryBackendConfig(endpoint="jager...", ...)
+init_telemetry(
+    TelemetryConfig(
+        attributes={"service.name": "..."},
+        backend_config=jaeger_backend,
+        fastapi_config=fastapi_config,
+        use_langchain=True,
+        use_httpx=True,
+        use_requests=True,
+    )
 )
 
-# 2. Configure Sentry with OTel config
-sentry_config = SentryConfig(
-    dsn="your-sentry-dsn",
-    environment="production",
-    open_telemetry_config=otel_config
+langfuse_backend = OpenTelemetryBackendConfig(endpoint="langfuse...", ...)
+init_telemetry(
+    TelemetryConfig(
+        backend_config=langfuse_backend
+    )
 )
 
-# 3. Initialize Telemetry
-init_telemetry(TelemetryConfig(sentry_config=sentry_config))
+sentry_backend = SentryBackendConfig(dsn="https://...", ...)
+init_telemetry(
+    TelemetryConfig(
+        backend_config=sentry_backend
+    )
+)
 ```
 
 ### 2. Logging Handlers

gl_observability_binary-0.1.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+gl_observability.cp313-win_amd64.pyd,sha256=H_-_orDp1AM7dT7auhkAaHIG5O6CjgZq3sXXGtBXHyo,645632
+gl_observability.pyi,sha256=zLWMUAsSLQclPGwJIhjJpDo_yw3gjUE3RmEB0e2JDUQ,1671
+gl_observability/__init__.pyi,sha256=YvrsoNmib8ulmQtWz9yxKyHDWnsTxzLWXOiI5C-BqmM,518
+gl_observability/initializer.pyi,sha256=T8_r7zuT8zrVofPemaS-9TEliOy0iqR-hAgq6sPGN6I,3524
+gl_observability/logs/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gl_observability/logs/ner_pii_logger_handler.pyi,sha256=KkX_78DsEJVFqdgcrrV-sosUmIR14gKJD6JEp16YOLU,1573
+gl_observability/logs/regex_pii_logger_handler.pyi,sha256=mN9pAOn8t3GrEjM7hldAn2HZLV8m3Ja2wY5vwWDWdAI,2538
+gl_observability/traces/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gl_observability/traces/config.pyi,sha256=E-U-Sda2CL4VKXQPTkGdwLSB230jusIHHbFKW8hC98I,1982
+gl_observability/traces/backend/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gl_observability/traces/backend/opentelemetry.pyi,sha256=jXsw3ZG2PnT0VWuC23yjQHaPMit3mF8m-C8LFeEBruo,1460
+gl_observability/traces/backend/sentry.pyi,sha256=dVrmxAc5F7vZym3NQ6G7gCynuwa_TkstodEkFSvdhbs,2049
+gl_observability/traces/instrument/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gl_observability/traces/instrument/functions.pyi,sha256=Hd2CmrBF4qxjb_LEUf5jgljVJ1DKy7XiQXJzvpYTl5w,4293
+gl_observability/traces/instrument/http.pyi,sha256=F86Nscqe9GxNdEduPJepzzjg3EeLZL-zRMUSj7tPxRg,2033
+gl_observability.build/.gitignore,sha256=aEiIwOuxfzdCmLZe4oB1JsBmCUxwG8x-u-HBCV9JT8E,1
+gl_observability_binary-0.1.1.dist-info/METADATA,sha256=wWLm2SHd2xY9o1ae3TP2RWO-rh8H2yQXJJwE7P2rVMg,8259
+gl_observability_binary-0.1.1.dist-info/WHEEL,sha256=O_u6PJIQ2pIcyIInxVQ9r-yArMuUZbBIaF1kpYVkYxA,96
+gl_observability_binary-0.1.1.dist-info/top_level.txt,sha256=qX0-e4NxRAAXXjWIZ7gvIspQP7J_dgxPQ7e3-WEbIeQ,17
+gl_observability_binary-0.1.1.dist-info/RECORD,,

gl_observability/backend/__init__.pyi

@@ -1,4 +0,0 @@
-from gl_observability.backend.opentelemetry.initializer import FastAPIConfig as FastAPIConfig, OpenTelemetryConfig as OpenTelemetryConfig
-from gl_observability.backend.sentry.initializer import SentryConfig as SentryConfig
-
-__all__ = ['OpenTelemetryConfig', 'SentryConfig', 'FastAPIConfig']

gl_observability/backend/opentelemetry/initializer.pyi

@@ -1,61 +0,0 @@
-from _typeshed import Incomplete
-from fastapi import FastAPI as FastAPI
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.sampling import Sampler as Sampler
-
-class FastAPIConfig:
-    """Configuration class for FastAPI application."""
-    app: Incomplete
-    def __init__(self, app: FastAPI) -> None:
-        """Initializes FastAPIConfig with a FastAPI application.
-
-        Args:
-            app (FastAPI): The FastAPI application to configure.
-        """
-
-class OpenTelemetryConfig:
-    """Configuration-based initializer for OpenTelemetry with FastAPI and Langchain support."""
-    provider: TracerProvider | None
-    endpoint: Incomplete
-    trace_sampler: Incomplete
-    headers: Incomplete
-    attributes: Incomplete
-    use_grpc: Incomplete
-    fastapi_config: Incomplete
-    use_langchain: Incomplete
-    use_httpx: Incomplete
-    use_requests: Incomplete
-    disable_sentry_distributed_tracing: Incomplete
-    def __init__(self, endpoint: str = '', trace_sampler: Sampler = None, headers: dict[str, str] = None, attributes: dict[str, str] = None, use_grpc: bool = True, fastapi_config: FastAPIConfig | None = None, use_langchain: bool = False, use_httpx: bool = True, use_requests: bool = True, disable_sentry_distributed_tracing: bool = False) -> None:
-        '''Initializes OpenTelemetryConfig with optional attributes.
-
-        Args:
-            endpoint (str): The OTLP endpoint. If you have port, please concat with the endpoint, e.g. "localhost:4317".
-            trace_sampler (Sampler): The sampler for traces.
-            headers (dict[str, str]): Headers with key value for connecting to the exporter.
-            attributes (dict[str, str]): Additional resource attributes.
-            use_grpc (bool): use grpc for opentelemetry exporter.
-            fastapi_config (FastAPI | None): The FastAPI fastapi_config (if using FastAPI tracing).
-            use_langchain (bool): Whether to use Langchain tracing.
-            use_httpx (bool): Whether to use httpx for tracing.
-            use_requests (bool): Whether to use requests for tracing.
-            disable_sentry_distributed_tracing (bool): Disable Sentry distributed tracing.
-        '''
-
-def init_otel_with_external_exporter(initializer: OpenTelemetryConfig) -> None:
-    """Initializes OpenTelemetry with an external exporter.
-
-    This method initializes OpenTelemetry with an external exporter (OTLP)
-        and instruments FastAPI and Langchain if applicable.
-
-    Args:
-        initializer (OpenTelemetryConfig): The configuration for OpenTelemetry.
-    """
-def init_otel_sentry(initializer: OpenTelemetryConfig) -> None:
-    """Initializes OpenTelemetry tracing.
-
-    This method initializes OpenTelemetry with Sentry and instruments FastAPI and Langchain if applicable.
-
-    Args:
-        initializer (OpenTelemetryConfig): The configuration for OpenTelemetry.
-    """

gl_observability/backend/sentry/initializer.pyi

@@ -1,39 +0,0 @@
-from _typeshed import Incomplete
-from gl_observability.backend.opentelemetry.initializer import OpenTelemetryConfig as OpenTelemetryConfig, init_otel_sentry as init_otel_sentry
-from typing import Any
-
-class SentryConfig:
-    """Configuration object for Sentry initialization.
-
-    this class is used to store the configuration for Sentry initialization.
-    """
-    dsn: Incomplete
-    environment: Incomplete
-    release: Incomplete
-    profiles_sample_rate: Incomplete
-    send_default_pii: Incomplete
-    traces_sampler: Incomplete
-    open_telemetry_config: Incomplete
-    additional_options: Incomplete
-    def __init__(self, dsn: str | None = None, environment: str | None = None, release: str | None = None, profiles_sample_rate: float | None = None, send_default_pii: bool | None = None, traces_sampler=None, open_telemetry_config: OpenTelemetryConfig | None = None, **kwargs: Any) -> None:
-        """Initializes the Sentry configuration object with the specified parameters.
-
-        Args:
-            dsn (str): The Data Source Name (DSN) for the Sentry project.
-            environment (str): The environment for the Sentry project.
-            release (str): The release version for the Sentry project.
-            profiles_sample_rate (float): The sample rate for performance monitoring.
-            send_default_pii (bool): Whether to send default Personally Identifiable Information (PII).
-            traces_sampler (TracesSampler): The sampler for traces.
-            open_telemetry_config: The OpenTelemetry Config
-            **kwargs: Additional keyword arguments to pass to sentry_sdk.init
-        """
-
-def init_sentry(config: SentryConfig | None = None) -> None:
-    """Initializes Sentry for error tracking and performance monitoring.
-
-    Initializes Sentry with the specified parameters.
-
-    Args:
-        config (SentryConfig | None, optional): The configuration object for Sentry initialization. Defaults to None.
-    """

gl_observability/traces/opentelemetry/instrument/__init__.pyi

@@ -1,4 +0,0 @@
-from gl_observability.traces.opentelemetry.instrument.functions import BOSAFunctionsInstrumentor as BOSAFunctionsInstrumentor
-from gl_observability.traces.opentelemetry.instrument.http import HTTPClientInstrumentor as HTTPClientInstrumentor
-
-__all__ = ['BOSAFunctionsInstrumentor', 'HTTPClientInstrumentor']

gl_observability_binary-0.0.0b1.dist-info/RECORD

@@ -1,22 +0,0 @@
-gl_observability.cp313-win_amd64.pyd,sha256=Z9oOG0VBa7YcqkEqVX2zp7nOGfgIvEoAjV0HUEyBztw,649728
-gl_observability.pyi,sha256=46n3y42spCx9vMmhRew5Ah26B67UoblpNHDsmIb8uU8,1626
-gl_observability/__init__.pyi,sha256=Ae5Vy1UKE0GokAsbCejhl8IfomzxoHQklX1EMqWAZEs,312
-gl_observability/initializer.pyi,sha256=vSBAy4QdpjDbrmKLYwFk_yBzwqCklDvMyTiVsmAWEzw,1108
-gl_observability/backend/__init__.pyi,sha256=IbzwPhr570SWM4925eUdYt_QarRz0idNResU9gv6Lig,295
-gl_observability/backend/opentelemetry/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gl_observability/backend/opentelemetry/initializer.pyi,sha256=X4ojVPJVwcdghJq0RHytwvltEyiV3qC8uZv1u7h7Rhc,2947
-gl_observability/backend/sentry/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gl_observability/backend/sentry/initializer.pyi,sha256=pOZGRlHCM2TLi-3knvvWFLSB1gbeyeGx6lDnthuJ7Ss,1990
-gl_observability/logs/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gl_observability/logs/ner_pii_logger_handler.pyi,sha256=KkX_78DsEJVFqdgcrrV-sosUmIR14gKJD6JEp16YOLU,1573
-gl_observability/logs/regex_pii_logger_handler.pyi,sha256=mN9pAOn8t3GrEjM7hldAn2HZLV8m3Ja2wY5vwWDWdAI,2538
-gl_observability/traces/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gl_observability/traces/opentelemetry/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gl_observability/traces/opentelemetry/instrument/__init__.pyi,sha256=PC9q9GLoWkGDGgcrYsp6j3rpS_A3yse80NaCAb-3BBQ,312
-gl_observability/traces/opentelemetry/instrument/functions.pyi,sha256=NeLDDzYJwXrAR5ltmfkdqj78UQqbyTHtW-eFXgoI5uM,4305
-gl_observability/traces/opentelemetry/instrument/http.pyi,sha256=GQRN3YdFElTF-m_nRWUG8XE50ge1QxMmRJiLY1TYP3c,2061
-gl_observability.build/.gitignore,sha256=aEiIwOuxfzdCmLZe4oB1JsBmCUxwG8x-u-HBCV9JT8E,1
-gl_observability_binary-0.0.0b1.dist-info/METADATA,sha256=r1pS0wyqq4WC19Hzp5mLoYu1lu_8jqW2GcUx-dGQA5o,7356
-gl_observability_binary-0.0.0b1.dist-info/WHEEL,sha256=O_u6PJIQ2pIcyIInxVQ9r-yArMuUZbBIaF1kpYVkYxA,96
-gl_observability_binary-0.0.0b1.dist-info/top_level.txt,sha256=qX0-e4NxRAAXXjWIZ7gvIspQP7J_dgxPQ7e3-WEbIeQ,17
-gl_observability_binary-0.0.0b1.dist-info/RECORD,,