Application Real-Time Monitoring Service:Report trace data from Python applications by using OpenTelemetry

Paso 1: Instalación de dependencias

pip install django
pip install requests
pip install opentelemetry-distro \
	opentelemetry-exporter-otlp

opentelemetry-bootstrap -a install

opentelemetry-bootstrap detecta las bibliotecas instaladas e instala automáticamente los complementos de instrumentación correspondientes.

Paso 2: Creación de un proyecto y una aplicación Django

1. Cree un proyecto AutoAndManualDemo:

      django-admin startproject AutoAndManualDemo

2. Cree una aplicación HelloWorld dentro del proyecto:

      cd AutoAndManualDemo
   
      # Create a HelloWorld application in the project.
      python manage.py startapp helloworld

Paso 3: Adición de código de la aplicación

1. Agregue el siguiente código al archivo AutoAndManualDemo/helloworld/views.py:

      from django.http import HttpResponse
      from datetime import datetime
   
      # Create your views here.
      def hello_world_view(request):
          result = "Hello World!  Current Time =" + str(get_time())
          return HttpResponse(result)
   
      def get_time():
          now = datetime.now()
          return now.strftime("%H:%M:%S")

2. Cree un archivo AutoAndManualDemo/helloworld/urls.py y agregue el siguiente código:

      from django.urls import path
   
      from . import views
   
      urlpatterns = [
          path('', views.hello_world_view, name='helloworld')
      ]

3. Agregue el patrón de URL al archivo AutoAndManualDemo/AutoAndManualDemo/urls.py:

      from django.contrib import admin
      from django.urls import path, include
   
      urlpatterns = [
       path('admin/', admin.site.urls),
       path('helloworld/', include('helloworld.urls')),
      ]

Paso 4: Ejecución de la aplicación

Anteponga opentelemetry-instrument a su comando de inicio y pase la configuración del exportador.

Reporte a través de HTTP

opentelemetry-instrument \
    --traces_exporter console,otlp_proto_http \
    --metrics_exporter none \
    --service_name <your-service-name> \
    --exporter_otlp_traces_endpoint <endpoint> \
    python manage.py runserver --noreload

Si no desea que la consola muestre los datos de rastreo, establezca el parámetro --traces_exporter como --traces_exporter otlp_proto_http.

  export DJANGO_SETTINGS_MODULE=AutoAndManualDemo.settings

Paso 5: Verificación del reporte de rastreo

1. Visite http://127.0.0.1:8000/helloworld/ en un navegador. La consola muestra los datos de rastreo y los reporta a Managed Service for OpenTelemetry.

2. Inicie sesión en la consola de ARMS.

3. En el panel de navegación izquierdo, elija Application Monitoring > Applications.

4. En la página Applications, busque su aplicación por el nombre de servicio que configuró y haga clic en ella.

5. En la página de detalles de la aplicación, compruebe que aparezcan los rastreos. Debería ver datos de span correspondientes a las solicitudes que envió.

Paso 1: Instalación de dependencias

pip install opentelemetry-api opentelemetry-sdk opentelemetry-exporter-otlp

Paso 2: Inicialización de OpenTelemetry

Cree un módulo de inicialización (por ejemplo, manual.py) que configure el proveedor de rastreo y el exportador.

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
    OTLPSpanExporter as OTLPSpanGrpcExporter,
)
from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
    OTLPSpanExporter as OTLPSpanHttpExporter,
)
from opentelemetry.sdk.resources import SERVICE_NAME, HOST_NAME, Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

def init_opentelemetry():
    resource = Resource(attributes={
        SERVICE_NAME: "<your-service-name>",
        HOST_NAME: "<host-name>",
    })

    # Option A: Export over gRPC
    span_processor = BatchSpanProcessor(OTLPSpanGrpcExporter(
        endpoint="<endpoint>",
        headers=("Authentication=<token>"),
    ))

    # Option B: Export over HTTP (uncomment to use)
    # span_processor = BatchSpanProcessor(OTLPSpanHttpExporter(
    #     endpoint="<endpoint>",
    # ))

    trace_provider = TracerProvider(
        resource=resource,
        active_span_processor=span_processor,
    )
    trace.set_tracer_provider(trace_provider)

Paso 3: Creación de spans

Después de la inicialización, obtenga un rastreador y cree spans para realizar el seguimiento de las operaciones.

tracer = trace.get_tracer(__name__)

# Context manager pattern
with tracer.start_as_current_span("child_span") as child_span:
    print("hello world")

Anide spans para representar relaciones padre-hijo:

def outer_method():
    tracer = trace.get_tracer(__name__)
    with tracer.start_as_current_span("parent_span") as parent_span:
        inner_method()

def inner_method():
    tracer = trace.get_tracer(__name__)
    with tracer.start_as_current_span("child_span") as child_span:
        print("hello world")

Paso 4: Obtención del ID de rastreo y del ID de span

Extraiga el ID de rastreo y el ID de span del contexto de span actual. Estos identificadores son útiles para correlacionar registros con rastreos.

ctx = trace.get_current_span().get_span_context()
trace_id = '{trace:032x}'.format(trace=ctx.trace_id)
span_id = '{span:016x}'.format(span=ctx.span_id)
print(trace_id)
print(span_id)

Paso 5: Propagación de metadatos personalizados con la API Baggage

La API Baggage de OpenTelemetry propaga pares clave-valor a través de los spans dentro de un rastreo. Utilice baggage para pasar metadatos —como IDs de usuario, IDs de inquilino o contexto de solicitud— entre servicios.

from opentelemetry import trace, baggage

def baggage_and_attribute_usage():
    tracer = trace.get_tracer(__name__)

    # Set baggage at the global level
    global_ctx = baggage.set_baggage("key", "value_from_global_ctx")

    # Create a span with custom attributes
    with tracer.start_as_current_span(
        name='baggage_parent_span',
        attributes={'attribute_key': 'value'},
    ) as baggage_parent_span:

        # Set baggage in the parent context
        parent_ctx = baggage.set_baggage("key", "value_from_parent_ctx")

        with tracer.start_as_current_span(
            name='baggage_child_span',
            context=parent_ctx,
        ) as baggage_child_span:

            # Set baggage in the child context
            child_ctx = baggage.set_baggage("key", "value_from_child_ctx")

    # Read baggage values from each context
    print(baggage.get_baggage("key", global_ctx))   # value_from_global_ctx
    print(baggage.get_baggage("key", parent_ctx))    # value_from_parent_ctx
    print(baggage.get_baggage("key", child_ctx))     # value_from_child_ctx

Paso 6: Ejecución y verificación

python manual.py

Una vez que la aplicación se ejecute, verifique los datos de rastreo en la consola de ARMS. Siga los pasos descritos en la sección Verificación del reporte de rastreo dentro de Instrumentación automática.

Paso 1: Instalación de dependencias

pip install django
pip install requests
pip install opentelemetry-sdk
pip install opentelemetry-instrumentation-django
pip install opentelemetry-exporter-otlp

Paso 2: Creación de un proyecto y una aplicación Django

1. Cree un proyecto AutoAndManualDemo:

      django-admin startproject AutoAndManualDemo

2. Cree una aplicación HelloWorld dentro del proyecto:

      cd AutoAndManualDemo
   
      # Create a HelloWorld application in the project.
      python manage.py startapp helloworld

Paso 3: Adición de spans personalizados al código

Importe la API de rastreo de OpenTelemetry y cree spans alrededor de las operaciones a las que desea dar seguimiento.

El siguiente ejemplo de vista de Django agrega dos spans personalizados (hello_world_span y time_span) además de los spans creados automáticamente por el complemento de instrumentación de Django. Modifique el archivo helloworld/views.py:

from django.http import HttpResponse
from opentelemetry import trace
from datetime import datetime

def hello_world_view(request):
    tracer = trace.get_tracer(__name__)

    with tracer.start_as_current_span("hello_world_span") as hello_world_span:
        result = "Hello World!  Current Time =" + str(get_time())
        return HttpResponse(result)

def get_time():
    now = datetime.now()
    tracer = trace.get_tracer(__name__)
    with tracer.start_as_current_span("time_span") as time_span:
        return now.strftime("%H:%M:%S")

Paso 4: Modificación del archivo urls.py

1. Cree un archivo helloworld/urls.py y agregue el siguiente código:

      from django.urls import path
   
      from . import views
   
      urlpatterns = [
          path('', views.hello_world_view, name='helloworld')
      ]

2. Agregue el patrón de URL al archivo AutoAndManualDemo/AutoAndManualDemo/urls.py:

      from django.contrib import admin
      from django.urls import path, include
   
      urlpatterns = [
       path('admin/', admin.site.urls),
       path('helloworld/', include('helloworld.urls')),
      ]

Paso 5: Configuración del proveedor de rastreo

Cree un módulo de inicialización que configure el exportador y el proveedor de rastreo. Agregue el siguiente código al código de inicialización de OpenTelemetry en el archivo manual.py. Importe este módulo al inicio de su aplicación (por ejemplo, en manage.py o en su punto de entrada WSGI/ASGI).

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
# To use HTTP instead, uncomment the following line and comment out the gRPC import:
# from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.resources import SERVICE_NAME, HOST_NAME, Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter

resource = Resource(attributes={
    SERVICE_NAME: "<your-service-name>",
    HOST_NAME: "<host-name>",
})

trace.set_tracer_provider(TracerProvider(resource=resource))

# Export traces over gRPC
trace.get_tracer_provider().add_span_processor(
    BatchSpanProcessor(OTLPSpanExporter(
        endpoint="<endpoint>",
        headers="Authentication=<token>",  # Required for gRPC only
    ))
)

# Also print traces to the console (useful for debugging)
trace.get_tracer_provider().add_span_processor(
    BatchSpanProcessor(ConsoleSpanExporter())
)

Paso 6: Ejecución y verificación

python manage.py runserver --noreload

  pip install grpcio

Envíe una solicitud a http://127.0.0.1:8000/helloworld/ y verifique los datos de rastreo en la consola de ARMS. Siga los pasos descritos en la sección Verificación del reporte de rastreo dentro de Instrumentación automática.