gl-observability-binary 0.0.0b1__cp311-cp311-win_amd64.whl

gl_observability/__init__.pyi

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

gl_observability/backend/__init__.pyi

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,39 @@
+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/initializer.pyi

@@ -0,0 +1,24 @@
+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
+
+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.
+
+        Args:
+            sentry_config (SentryConfig): The Sentry configuration.
+            otel_config: The OpenTelemetry config.
+        """
+
+def init_telemetry(config: TelemetryConfig) -> None:
+    """Initializes telemetry for error tracking and performance monitoring.
+
+    Initializes telemetry with the specified parameters.
+
+    Args:
+        config (TelemetryConfig): The telemetry configuration.
+    """

gl_observability/logs/ner_pii_logger_handler.pyi

@@ -0,0 +1,44 @@
+import logging
+from _typeshed import Incomplete
+
+class NerLoggerHandler(logging.Handler):
+    """Handler for preprocessing log messages using NER."""
+    api_url: Incomplete
+    api_field: Incomplete
+    pii_ner_process_enabled: Incomplete
+    def __init__(self, api_url: str, api_field: str, pii_ner_process_enabled: bool = False) -> None:
+        """Initialize the handler.
+
+        Args:
+            api_url (str): The URL of the NER API.
+            api_field (str): The field name for the NER API.
+            pii_ner_process_enabled (bool): Flag to enable NER processing.
+        """
+    def process_message_using_ner(self, message: str) -> str:
+        """Process message through NER API and return modified message.
+
+        Args:
+            message (str): The log message to process.
+
+        Returns:
+            str: The processed message.
+        """
+    def emit(self, record: logging.LogRecord):
+        """Emit the log record.
+
+        Args:
+            record (LogRecord): The log record to emit.
+        """
+
+def init_ner_pii_logging_handler(logger_name: str, api_url: str, api_field: str, pii_ner_process_enabled: bool = False) -> None:
+    """Initialize the NER PII logging handler.
+
+    Args:
+        logger_name (str): The name of the logger.
+        api_url (str): The URL of the NER API.
+        api_field (str): The field name for the NER API.
+        pii_ner_process_enabled (bool): Flag to enable NER processing.
+
+    Returns:
+        NerLoggerHandler: The initialized NER PII logging handler.
+    """

gl_observability/logs/regex_pii_logger_handler.pyi

@@ -0,0 +1,78 @@
+import logging
+from _typeshed import Incomplete
+
+class RegexLoggerHandler(logging.Handler):
+    """Handler for preprocessing log messages using regex."""
+    REGEX_KTP: Incomplete
+    REGEX_NPWP: Incomplete
+    REGEX_PHONE_NUMBER: Incomplete
+    REGEX_EMAIL_ADDRESS: Incomplete
+    pii_regex_process_enabled: Incomplete
+    def __init__(self, pii_regex_process_enabled: bool = False) -> None:
+        """Initialize the handler.
+
+        Args:
+            pii_regex_process_enabled (bool): Flag to enable regex processing.
+        """
+    def process_message_using_regex(self, message: str) -> str:
+        """Process message through regex and return modified message.
+
+        Args:
+            message (str): The log message to process.
+
+        Returns:
+         str: The processed message.
+        """
+    def mask_ktp_number(self, ktp_number: str) -> str:
+        """Mask the KTP number to show only the first 2 and last 2 digits.
+
+        Args:
+            ktp_number (str): The KTP number to mask.
+
+        Returns:
+            str: The masked KTP number.
+        """
+    def mask_npwp_number(self, npwp_number: str) -> str:
+        """Mask the NPWP number to show only the first 2 and last 2 digits.
+
+        Args:
+            npwp_number (str): The NPWP number to mask.
+
+        Returns:
+            str: The masked NPWP number.
+        """
+    def mask_phone_number(self, phone_number: str) -> str:
+        """Mask the phone number to show only the first 4 and last 4 digits.
+
+        Args:
+            phone_number (str): The phone number to mask.
+
+        Returns:
+            str: The masked phone number.
+        """
+    def mask_email_address(self, email_address: str) -> str:
+        """Mask the email address to show only the first 2 and last 2 characters.
+
+        Args:
+            email_address (str): The email address to mask.
+
+        Returns:
+            str: The masked email address.
+        """
+    def emit(self, record: logging.LogRecord):
+        """Emit the log record.
+
+        Args:
+            record (LogRecord): The log record to emit.
+        """
+
+def init_regex_pii_logging_handler(logger_name: str, pii_regex_process_enabled: bool = False) -> None:
+    """Initialize the NER PII logging handler.
+
+    Args:
+        logger_name (str): The name of the logger.
+        pii_regex_process_enabled (bool): Flag to enable regex processing.
+
+    Returns:
+        NerLoggerHandler: The initialized NER PII logging handler.
+    """

gl_observability/traces/opentelemetry/instrument/__init__.pyi

@@ -0,0 +1,4 @@
+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/traces/opentelemetry/instrument/functions.pyi

@@ -0,0 +1,121 @@
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from typing import Collection
+
+class BOSAFunctionsInstrumentor(BaseInstrumentor):
+    """OpenTelemetry Generic Function Instrumentor.
+
+    Supports:
+        - Class functions (CustomClass.function)
+        - Module functions (module.function)
+        - Static methods (@staticmethod)
+        - Class methods (@classmethod)
+
+    Not Supported:
+        - Passing bound instance methods (obj.method) directly to ``instrument``
+        - Abstract methods (abc.abstractmethod)
+
+    Note:
+        For overridden methods (including implementation of abstract method), you have to instrument the
+        overridden method. Instrumenting the parent class method will not instrument the overridden method.
+
+    Params:
+        methods (list[Callable]): List of methods to instrument.
+        max_length (int): Maximum length for function args, kwargs, and return value string. Defaults to 200.
+
+    Example:
+        ```
+        ### Below source code from `module/classes/custom_class.py`
+        class CustomClass:
+
+            def method(self, ...):
+                ...
+
+            @classmethod
+            def class_method(cls, ...):
+                ...
+
+            @staticmethod
+            def static_method(...):
+                ...
+
+            async def async_method(self, ...):
+                ...
+
+            @classmethod
+            async def async_class_method(cls, ...):
+                ...
+
+            @staticmethod
+            async def async_static_method(...):
+                ...
+
+        ### Below source code from `module/functions.py`
+        def sync_function(...):
+            ...
+
+        async def async_function(...):
+            ...
+
+        ### Instrumenting the above methods in different modules
+        from module import functions
+        from module.classes.custom_class import CustomClass
+
+        # Instrument all functions in the module
+        BOSAFunctionsInstrumentor().instrument(
+            methods=[
+                functions.sync_function, functions.async_function,
+                CustomClass.method, CustomClass.class_method,
+                CustomClass.static_method, CustomClass.async_method,
+                CustomClass.async_class_method, CustomClass.async_static_method
+            ],
+            max_length=100
+        )
+
+        obj = CustomClass()
+        # Call the methods
+        obj.method(...)
+        CustomClass.class_method(...)
+        CustomClass.static_method(...)
+
+        await obj.async_method(...)
+        await CustomClass.async_class_method(...)
+        await CustomClass.async_static_method(...)
+
+        functions.sync_function(...)
+        await functions.async_function(...)
+
+        # Uninstrument all functions in the module
+        BOSAFunctionsInstrumentor().uninstrument()
+        ```
+
+    Note:
+        To use instrumented function from a module, you must use the function with module prefix. For example,
+        if you have a function `sync_function` in a module `functions` and you instrumented it with this
+        instrumentor, you must use it as `functions.sync_function(...)`. The reason is because this instrumentor
+        rely on monkey patching, which will not effect the function if it is imported before instrumenting.
+        By importing the module,you can avoid this issue.
+    """
+    DEFAULT_MAX_LENGTH: int
+    def instrumentation_dependencies(self) -> Collection[str]:
+        """Returns a collection of dependencies required for instrumentation.
+
+        Returns:
+            Collection[str]: A collection of dependency names.
+        """
+    def instrument(self, **kwargs) -> None:
+        """Instruments generic custom classes.
+
+        Args:
+            **kwargs: Additional keyword arguments.
+                methods (list): List of methods to instrument.
+                max_length (int): Maximum length for trimming non-dict/list data. Defaults to 200.
+
+        Raises:
+            TypeError: If any method is not callable.
+        """
+    def uninstrument(self, **kwargs) -> None:
+        """Uninstrument the instrumented methods.
+
+        Args:
+            **kwargs: Additional keyword arguments.
+        """

gl_observability/traces/opentelemetry/instrument/http.pyi

@@ -0,0 +1,58 @@
+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 typing import Any, Callable
+
+METHOD_INDEX: int
+URL_INDEX: int
+BODY_INDEX: int
+HEADERS_INDEX: int
+
+@dataclass
+class RequestInfo:
+    """Container for HTTP request information passed to request hooks."""
+    method: str
+    url: str
+    headers: dict[str, str]
+    body: Any
+    connection: http.client.HTTPConnection
+
+@dataclass
+class ResponseInfo:
+    """Container for HTTP response information passed to response hooks."""
+    status_code: int
+    headers: dict[str, str]
+    response: http.client.HTTPResponse
+    connection: http.client.HTTPConnection
+RequestHookT = Callable[[Span, RequestInfo], None]
+ResponseHookT = Callable[[Span, ResponseInfo], None]
+
+@dataclass
+class InstrumentationContext:
+    """Context for instrumentation configuration."""
+    tracer: Tracer
+    request_hook: RequestHookT | None
+    response_hook: ResponseHookT | None
+
+class HTTPClientInstrumentor(BaseInstrumentor):
+    """Instrumentor for Python's http.client library.
+
+    Wraps http.client.HTTPConnection.request() and getresponse() methods
+    to create spans for HTTP requests.
+    """
+    def instrumentation_dependencies(self) -> list[str]:
+        """Return list of instrumentation dependencies.
+
+        Returns:
+            list[str]: Empty list (http.client is stdlib).
+        """
+    def instrument(self, *, tracer_provider: TracerProvider | None = None, request_hook: RequestHookT | None = None, response_hook: ResponseHookT | None = None, **kwargs: Any) -> None:
+        """Instrument the library.
+
+        Args:
+            tracer_provider: OpenTelemetry TracerProvider instance
+            request_hook: Optional callback for request customization
+            response_hook: Optional callback for response customization
+            **kwargs: Additional keyword arguments
+        """

gl_observability.build/.gitignore

@@ -0,0 +1 @@
+*

gl_observability.pyi

@@ -0,0 +1,55 @@
+# This file was generated by Nuitka
+
+# Stubs included by default
+from gl_observability.initializer import TelemetryConfig, init_telemetry
+from gl_observability.backend import OpenTelemetryConfig, SentryConfig
+
+
+__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.exporter
+import opentelemetry.exporter.otlp
+import opentelemetry.exporter.otlp.proto
+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.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
+import opentelemetry.instrumentation.instrumentor
+import http
+import http.client
+import dataclasses
+import http.HTTPStatus
+import urllib
+import urllib.parse
+import opentelemetry.semconv
+import opentelemetry.semconv.attributes
+import opentelemetry.trace

gl_observability_binary-0.0.0b1.dist-info/METADATA

@@ -0,0 +1,217 @@
+Metadata-Version: 2.2
+Name: gl-observability-binary
+Version: 0.0.0b1
+Summary: SDK for Observability tools
+Author-email: HansSeanNathanael <hans.s.nathanael@gdplabs.id>
+Requires-Python: <3.14,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi<1.0.0,>=0.115.6
+Requires-Dist: requests<3.0.0,>=2.31.0
+Requires-Dist: httpx<1.0.0,>=0.27.0
+Requires-Dist: langchain-core<1.0.0,>=0.3
+Requires-Dist: sentry-sdk<3.0.0,>=2.20.0
+Requires-Dist: opentelemetry-api
+Requires-Dist: opentelemetry-sdk
+Requires-Dist: opentelemetry-exporter-otlp-proto-http
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc
+Requires-Dist: opentelemetry-instrumentation-fastapi
+Requires-Dist: opentelemetry-instrumentation-langchain
+Requires-Dist: opentelemetry-instrumentation-requests
+Requires-Dist: opentelemetry-instrumentation-httpx
+Provides-Extra: dev
+Requires-Dist: pytest<9.0.0,>=8.3.4; extra == "dev"
+Requires-Dist: pre-commit<4.0.0,>=3.7.0; extra == "dev"
+Requires-Dist: pytest-cov<6.0.0,>=5.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio<1.0.0,>=0.25.3; extra == "dev"
+Requires-Dist: pytest-mock<4.0.0,>=3.14.0; extra == "dev"
+Requires-Dist: coverage<8.0.0,>=7.6.10; extra == "dev"
+Requires-Dist: mypy<2.0.0,>=1.11.2; extra == "dev"
+Requires-Dist: ruff<1.0.0,>=0.11.12; extra == "dev"
+
+# GL Observability
+
+`gl-observability` is a comprehensive SDK for implementing observability in Python applications. It provides easy-to-use wrappers for OpenTelemetry, Sentry, and custom logging handlers with PII redaction capabilities.
+
+## Key Features
+
+- 📊 **OpenTelemetry Integration**: simplified initialization for tracing and metrics.
+- 🛡️ **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.
+
+## Installation
+
+### Prerequisites
+
+- Python 3.11-3.13 - [Install here](https://www.python.org/downloads/)
+- Pip (if using pip) - [Install here](https://pip.pypa.io/en/stable/installation/)
+- Poetry 2.1.3+ (if using Poetry) - [Install here](https://python-poetry.org/docs/#installation)
+- uv (if using uv) - [Install here](https://docs.astral.sh/uv/guides/install-python/)
+- Git (if using Git) - [Install here](https://git-scm.com/downloads)
+- For git installation, access to the [GDP Labs SDK github repository](https://github.com/GDP-ADMIN/gl-sdk)
+
+### 1. Installation from Pypi
+
+Choose one of the following methods to install the package:
+
+#### Using pip
+
+```bash
+pip install gl-observability-binary
+```
+
+#### Using Poetry
+
+```bash
+poetry add gl-observability-binary
+```
+
+#### Using uv
+
+```bash
+uv add gl-observability-binary
+```
+
+### 2. Development Installation (Git)
+
+For development purposes, you can install directly from the Git repository:
+
+```bash
+poetry add "git+ssh://git@github.com/GDP-ADMIN/gl-sdk.git#subdirectory=libs/gl-observability"
+```
+
+## Usage
+
+### 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.
+
+#### OpenTelemetry Configuration (External Exporter)
+
+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
+
+# 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"}
+)
+
+# 3. Initialize Telemetry
+init_telemetry(TelemetryConfig(otel_config=otel_config))
+```
+
+#### Sentry Configuration
+
+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
+)
+
+# 2. Initialize Telemetry
+init_telemetry(TelemetryConfig(sentry_config=sentry_config))
+```
+
+#### Sentry with OpenTelemetry
+
+This setup combines Sentry with OpenTelemetry instrumentation, allowing Sentry to capture OTel spans.
+
+```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
+)
+
+# 2. Configure Sentry with OTel config
+sentry_config = SentryConfig(
+    dsn="your-sentry-dsn",
+    environment="production",
+    open_telemetry_config=otel_config
+)
+
+# 3. Initialize Telemetry
+init_telemetry(TelemetryConfig(sentry_config=sentry_config))
+```
+
+### 2. Logging Handlers
+
+The library provides logging handlers to automatically redact Personally Identifiable Information (PII) from logs.
+
+#### Regex-based PII Redaction
+
+Uses regular expressions to mask common PII patterns like KTP, NPWP, Phone Numbers, and Email.
+
+```python
+import logging
+from gl_observability.logs.regex_pii_logger_handler import init_regex_pii_logging_handler
+
+# Initialize the handler for a specific logger
+init_regex_pii_logging_handler(
+    logger_name="my_application_logger",
+    pii_regex_process_enabled=True
+)
+
+logger = logging.getLogger("my_application_logger")
+logger.info("User email is john.doe@example.com and phone is 08123456789")
+# Output: User email is jo******om and phone is 0812******6789
+```
+
+#### NER-based PII Redaction (Named Entity Recognition)
+
+Uses an external API to perform Named Entity Recognition for more advanced PII detection and redaction.
+
+> [!WARNING]
+> The NER logging handler makes synchronous API calls for each log record, which may impact performance.
+
+```python
+import logging
+from gl_observability.logs.ner_pii_logger_handler import init_ner_pii_logging_handler
+
+# Initialize the handler
+init_ner_pii_logging_handler(
+    logger_name="my_application_logger",
+    api_url="https://your-ner-api.com/anonymize",
+    api_field="text",  # The field name in API response containing the redacted text
+    pii_ner_process_enabled=True
+)
+
+logger = logging.getLogger("my_application_logger")
+logger.info("My KTP is 3525011212941001")
+# Output will be redacted based on API response
+```

gl_observability_binary-0.0.0b1.dist-info/RECORD

@@ -0,0 +1,22 @@
+gl_observability.cp311-win_amd64.pyd,sha256=lPtli1Zf8apyEx1Od88UfF_cU0Od80IypPe2kuOdvpk,661504
+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=l2aKBREYfqJ7T2ljmr6hUiXPoNvvXF47bG4IHjuSyS4,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,,

gl_observability_binary-0.0.0b1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: Nuitka (2.6.9)
+Root-Is-Purelib: false
+Tag: cp311-cp311-win_amd64
+

gl_observability_binary-0.0.0b1.dist-info/top_level.txt

@@ -0,0 +1 @@
+gl_observability