ddtrace es el cliente de rastreo de Datadog para Ruby. Se utiliza para rastrear solicitudes a medida que circulan a través de servidores web, bases de datos y microservicios, para que los desarrolladores tengan una amplia visibilidad de los cuellos de botella y las solicitudes problemáticas.

Para empezar

Si estás actualizando desde una versión 0.x, consulta nuestra guía de actualización.

Para ver la documentación general de APM, consulta nuestra [documentación de configuración][setup docs].

Para obtener más información sobre el aspecto de APM una vez que la aplicación envía información a Datadog, consulta [Términos y conceptos][visualization docs].

Para ver la documentación de la API de biblioteca, consulta nuestra [documentación de YARD][yard docs].

Para contribuir, consulta las [directrices para contribuciones][contribution docs] y la [guía de desarrollo][development docs].

Requisitos de compatibilidad

Para ver una lista completa de la compatibilidad de Datadog con la biblioteca de Ruby, consulta los requisitos de compatibilidad.

Instalación

Añadir la función de rastreo a tu aplicación Ruby sólo requiere unos pocos pasos:

1. Configuración del rastreo en el Datadog Agent
2. Instrumentación de tu solicitud
3. Conexión de tu aplicación al Datadog Agent

Configuración del rastreo en el Datadog Agent

Antes de instalar ddtrace, instala el Datadog Agent, al que ddtrace enviará datos de rastreo.

Luego, configura el Datadog Agent para aceptar trazas (traces). Para ello:

• Configura DD_APM_ENABLED=true en el entorno del Agent.

O

• Añade apm_enabled: true al archivo de configuración del Agent.

Además, en entornos contenedorizados…

• Configura DD_APM_NON_LOCAL_TRAFFIC=true en el entorno del Agent.

O

• Añade apm_non_local_traffic: true en el archivo de configuración del Agent.

Consulta las instrucciones de configuración específicas para Docker, Kubernetes, Amazon ECS o Fargate para asegurarte de que el Agent está configurado para recibir trazas (traces) en un entorno contenedorizado.

Configuración del consumo de datos de rastreo

Por defecto, el Datadog Agent escuchará trazas (traces) vía HTTP en el puerto 8126.

Puedes cambiar el protocolo o el puerto en que el Agent escucha datos de rastreo utilizando lo siguiente:

Para HTTP sobre TCP:

• Configura DD_APM_RECEIVER_PORT=<port> en el entorno del Agent.

O

• Añade apm_config: receiver_port: <port> al archivo de configuración del Agent

Para sockets de dominio Unix (UDS):

• Configura DD_APM_RECEIVER_SOCKET=<path-to-socket-file>.

O

• Añade apm_config: receiver_socket: <path-to-socket-file> al archivo de configuración del Agent

Instrumentación de tu solicitud

Aplicaciones Rails o Hanami

1. Añade la gema ddtrace a tu archivo Gemfile:

   source 'https://rubygems.org'
   gem 'ddtrace', require: 'ddtrace/auto_instrument'
   

2. Instala la gema con bundle install.

3. Crea un archivo config/initializers/datadog.rb que contenga:

   Datadog.configure do |c|
     # Add additional configuration here.
     # Activate integrations, change tracer settings, etc...
   end
   

   Con este bloque puedes:

   • Añadir parámetros de configuración adicionales
   • Activar o reconfigurar la instrumentación

Otras aplicaciones Ruby

Si tu aplicación no utiliza las gemas compatibles (Rails o Hanami) anteriores, puedes configurarla de la siguiente manera:

1. Añade la gema ddtrace a tu archivo Gemfile:

   source 'https://rubygems.org'
   gem 'ddtrace'
   

2. Instala la gema con bundle install.

3. require cualquier biblioteca o marco compatible que deba instrumentarse.

4. Añade require 'ddtrace/auto_instrument' a tu aplicación. Nota: Esto debe hacerse después de requerir cualquier bibliotecas o marco compatible.

   # Example frameworks and libraries
   require 'sinatra'
   require 'faraday'
   require 'redis'
   
   require 'ddtrace/auto_instrument'
   

5. Añade un bloque de configuración a tu aplicación:

   Datadog.configure do |c|
     # Add additional configuration here.
     # Activate integrations, change tracer settings, etc...
   end
   

   Con este bloque puedes:

   • Añadir parámetros de configuración adicionales
   • Activar o reconfigurar la instrumentación

Configuración de OpenTracing

1. Añade la gema ddtrace a tu archivo Gemfile:

   source 'https://rubygems.org'
   gem 'ddtrace'
   

2. Instala la gema con bundle install.

3. En tu archivo de configuración de OpenTracing, añade lo siguiente:

   require 'opentracing'
   require 'datadog/tracing'
   require 'datadog/opentracer'
   
   # Activate the Datadog tracer for OpenTracing
   OpenTracing.global_tracer = Datadog::OpenTracer::Tracer.new
   

4. Añade un bloque de configuración a tu aplicación:

   Datadog.configure do |c|
     # Configure the Datadog tracer here.
     # Activate integrations, change tracer settings, etc...
     # By default without additional configuration,
     # no additional integrations will be traced, only
     # what you have instrumented with OpenTracing.
   end
   

   Con este bloque puedes:

   • Añadir parámetros de configuración de Datadog adicionales
   • Activar o reconfigurar la instrumentación de Datadog

Configuración de OpenTelemetry

Puedes enviar trazas de OpenTelemetry directamente al Datadog Agent (sin ddtrace) mediante OTLP. Para obtener más detalles, consulta nuestra documentación sobre consumo de OTLP en el Datadog Agent.

Conexión de tu aplicación al Datadog Agent

Por defecto, ddtrace se conectará al Agent utilizando la primera configuración disponible en la lista de prioridades:

1. A través de cualquier parámetro de configuración proporcionado explícitamente (nombre de host/puerto/transporte)
2. A través del socket de dominio Unix (UDS) localizado en /var/run/datadog/apm.socket
3. A través de HTTP sobre TCP a 127.0.0.1:8126

Si tu Datadog Agent escucha en cualquiera de estas localizaciones, no debería ser necesario realizar ninguna otra configuración.

Si tu Agent se ejecuta en un host o contenedor diferente al de tu aplicación o si quieres enviar trazas (traces) utilizando un protocolo diferente, debes configurar tu aplicación en consecuencia.

• Cómo enviar datos de rastreo al Agent vía HTTP sobre TCP
• Cómo enviar datos de rastreo al Agent a través del socket de dominio Unix (UDS)

Pasos finales de la instalación

Tras la configuración, tus servicios aparecerán en la página de servicios APM en unos minutos. Obtén más información sobre [el uso de la interfaz de usuario APM][visualization docs].

Instrumentación manual

Si no utilizas una instrumentación de marco compatible, es posible que quieras instrumentar tu código manualmente.

Para rastrear cualquier código Ruby, puedes utilizar el método Datadog::Tracing.trace:

Datadog::Tracing.trace(name, **options) do |span, trace|
  # Envuelve el código que quieras instrumentar con este bloque
  # También puedes modificar el tramo (span) aquí.
  # Por ejemplo, cambiar el nombre del recurso, configurar etiquetas (tags), etc...
end

Donde name debe ser una String que describa el tipo genérico de operación que se está realizando (por ejemplo 'web.request' o 'request.parse')

Y options son los siguientes argumentos de palabra clave opcionales:

Se recomienda especialmente configurar service y resource como mínimo. El l Datadog Agent descartará cualquier tramo sin un service o resource como nil.

Ejemplo de instrumentación manual en acción:

get '/posts' do
  Datadog::Tracing.trace('web.request', service: 'my-blog', resource: 'GET /posts') do |span|
    # Traza llamada por activerecord
    Datadog::Tracing.trace('posts.fetch') do
      @posts = Posts.order(created_at: :desc).limit(10)
    end

    # Añade algunas etiquetas de APM
    span.set_tag('http.method', request.request_method)
    span.set_tag('posts.count', @posts.length)

    # Rastrea la representación de la plantilla
    Datadog::Tracing.trace('template.render') do
      erb :index
    end
  end
end

Rastreo asíncrono

Puede que no siempre sea posible envolver un bloque de código con Datadog::Tracing.trace. Es posible que algunas instrumentaciones basadas en eventos o notificaciones sólo te avisen cuando comienza o termina un evento.

Para rastrear estas operaciones, puedes rastrear codificar de forma asíncrona llamando a Datadog::Tracing.trace sin un bloque:

# Algunos marcos de instrumentación llaman después de que termina un evento...
def db_query(start, finish, query)
  span = Datadog::Tracing.trace('database.query', start_time: start)
  span.resource = query
  span.finish(finish)
end

Llamar a Datadog::Tracing.trace sin un bloque hará que la función devuelva uns Datadog::Tracing::SpanOperation que está iniciada, pero no terminada. Puedes modificar este tramo como prefieras y luego cerrarlo finish.

No debes dejar ningún tramo sin terminar. Si queda algún tramo abierto cuando termina el rastreo, se descartará la traza. Puedes activar el modo de depuración para comprobar si existen advertencias, si sospechas que esto podría estar ocurriendo.

Para evitar esta situación al gestionar el inicio/fin de eventos, puedes utilizar Datadog::Tracing.active_span para obtener el tramo activo en ese momento.

# Por ej. ActiveSupport::Llamadas de notificación cuando empieza un evento
def start(name, id, payload)
  # Inicia un tramo
  Datadog::Tracing.trace(name)
end

# Por ej. ActiveSupport::Llamadas de notificación cuando termina un evento
def finish(name, id, payload)
  # Busca el tramo activo en ese momento (thread-safe)
  current_span = Datadog::Tracing.active_span
  unless current_span.nil?
    current_span.resource = payload[:query]
    current_span.finish
  end
end

Enriquecimiento de trazas a partir de métodos anidados

Puedes etiquetar información adicional al tramo activo en ese momento utilizando cualquier método. Ten en cuenta, sin embargo, que si se llama al método y no hay ningún tramo activo en ese momento, el active_span será nulo.

# Por ej. agregando etiquetas al tramo activo

current_span = Datadog::Tracing.active_span
current_span.set_tag('my_tag', 'my_value') unless current_span.nil?

También puedes obtener la traza activa en ese momento utilizando el método active_trace. Este método devolverá nil si no hay ninguna traza activa.

# Por ej. accediendo a la traza activa

current_trace = Datadog::Tracing.active_trace

Instrumentación de la integración

Muchas de los bibliotecas y marcos más populares son compatibles desde el primer momento, por lo que pueden instrumentarse de forma automática. Aunque no se activan automáticamente, pueden activarse y configurarse fácilmente a través de la API Datadog.configure:

Datadog.configure do |c|
  # Activa y configura una integración
  c.tracing.instrument :integration_name, **options
end

Las options son argumentos de palabra clave para configuraciones específicas de las integraciones.

Para ver la lista de las integraciones disponibles y sus versiones compatibles, consulta la compatibilidad de la integración con Ruby.

Para ver la lista de las opciones de configuración para las integraciones disponibles, consulta:

CI Visibility

Para Datadog CI Visibility, la instrumentación de bibliotecas puede activarse y configurarse a través de la siguiente API Datadog.configure:

Datadog.configure do |c|
  # Activa y configura una integración
  c.ci.instrument :integration_name, **options
end

Las options son argumentos de palabra clave para configuraciones específicas de las integraciones.

Para ver la lista de las integraciones disponibles y sus versiones compatibles, consulta la compatibilidad de la integración de CI con Ruby.

Action Cable

La integración Action Cable rastrea mensajes emitidos y acciones de canales.

Puedes habilitarlo a través de Datadog.configure:

require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :action_cable
end

Action Mailer

La integración Action Mailer proporciona rastreo para las acciones Rails 5 de Action Mailer.

Puedes habilitarlo a través de Datadog.configure:

require 'ddtrace'
Datadog.configure do |c|
  c.tracing.instrument :action_mailer, **options
end

Las options son los siguientes argumentos de palabra clave:

Action Pack

La mayoría de las veces, Action Pack se configura como parte de Rails, pero puede activarse por separado:

require 'actionpack'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :action_pack
end

Action View

La mayoría de las veces, Action View se configura como parte de Rails, pero puede activarse por separado:

require 'actionview'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :action_view, **options
end

Las options son los siguientes argumentos de palabra clave:

Active Job

La mayoría de las veces, Active Job se configura como parte de Rails, pero puede activarse por separado:

require 'active_job'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :active_job
end

ExampleJob.perform_later

Serializadores de Active Model

La integración de serializadores de Active Model rastrea el evento serialize para la versión 0.9 y superiores y el evento render para la versión 0.10 y superiores.

require 'active_model_serializers'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :active_model_serializers
end

my_object = MyModel.new(name: 'my object')
ActiveModelSerializers::SerializableResource.new(test_obj).serializable_hash

Active Record

La mayoría de las veces, Active Record se configura como parte de un marco web (Rails, Sinatra…), pero puede configurarse solo:

require 'tmpdir'
require 'sqlite3'
require 'active_record'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :active_record, **options
end

Dir::Tmpname.create(['test', '.sqlite']) do |db|
  conn = ActiveRecord::Base.establish_connection(adapter: 'sqlite3',
                                                 database: db)
  conn.connection.execute('SELECT 42') # traced!
end

Las options son los siguientes argumentos de palabra clave:

Configuración de los parámetros de rastreo por base de datos

Puedes configurar parámetros de rastreo por conexión de base de datos utilizando la opción describes:

# Proporciona una opción `:describes` con una clave de conexión.
# Cualquiera de las siguientes claves son aceptables y equivalentes entre sí.
# Si se proporciona un bloque, éste devuelve un objeto Parámetros que
# acepta cualquiera de las opciones de configuración enumeradas anteriormente.

Datadog.configure do |c|
  # Símbolo que coincide con tu conexión de base de datos en config/database.yml
  # Sólo disponible si utilizas Rails con ActiveRecord.
  c.tracing.instrument :active_record, describes: :secondary_database, service_name: 'secondary-db'

  # Patrón de configuración de bloque.
  c.tracing.instrument :active_record, describes: :secondary_database do |second_db|
second_db.service_name = 'secondary-db'
  end

  # Cadena de conexión con los siguientes parámetros de conexión:
  # adaptador, nombre de usuario, host, puerto, base de datos
  # Los demás campos se ignoran.
  c.tracing.instrument :active_record, describes: 'mysql2://root@127.0.0.1:3306/mysql', service_name: 'secondary-db'

  # Hash con los siguientes parámetros de conexión:
  # adaptador, nombre de usuario, host, puerto, base de datos
  # Los demás campos se ignoran.
  c.tracing.instrument :active_record, describes: {
      adapter: 'mysql2',
      host: '127.0.0.1',
      port: '3306',
      database: 'mysql',
      username: 'root
    },
    service_name: 'secondary-db'

  # Si utilizas la gema `makara`, es posible emparejar el `role` de conexión:
  c.tracing.instrument :active_record, describes: { makara_role: 'primary' }, service_name: 'primary-db'
  c.tracing.instrument :active_record, describes: { makara_role: 'replica' }, service_name: 'secondary-db'
end

También puedes crear configuraciones basadas en la coincidencia parcial de los campos de conexión de la base de datos:

Datadog.configure do |c|
  # Coincide con cualquier conexión en el host `127.0.0.1`.
  c.tracing.instrument :active_record, describes: { host:  '127.0.0.1' }, service_name: 'local-db'

  # Coincide con cualquier conexión `mysql2`.
  c.tracing.instrument :active_record, describes: { adapter: 'mysql2'}, service_name: 'mysql-db'

  # Coincide con cualquier conexión `mysql2` con la base de datos `reports`.
  #
  # En caso de varias configuraciones `describe` coincidentes, se aplicará la última.
  # En este caso, se configurará una conexión con `mysql` del adaptador y `reports` de la base de datos
  # `service_name: 'reports-db'`, y no con `service_name: 'mysql-db'`.
  c.tracing.instrument :active_record, describes: { adapter: 'mysql2', database:  'reports'}, service_name: 'reports-db'
end

Cuando varias configuraciones de describes coincidan con una conexión, se aplicará la última regla configurada que coincida.

Si ActiveRecord rastrea un evento que utiliza una conexión que coincide con una clave definida por describes, utilizará los parámetros de rastreo asignados a esa conexión. Si la conexión no coincide con ninguna de las conexiones descritas, utilizará los parámetros predeterminados definidos por c.tracing.instrument :active_record.

Active Support

La mayoría de las veces, Active Support se configura como parte de Rails, pero puede activarse por separado:

require 'activesupport'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :active_support, **options
end

cache = ActiveSupport::Cache::MemoryStore.new
cache.read('city')

Las options son los siguientes argumentos de palabra clave:

AWS

La integración con AWS rastrea cada interacción (por ejemplo, llamadas a la API) a través de servicios AWS (S3, ElastiCache, etc.).

require 'aws-sdk'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :aws, **options
end

# Perform traced call
Aws::S3::Client.new.list_buckets

Las options son los siguientes argumentos de palabra clave:

Concurrent Ruby

La integración con Concurrent Ruby añade compatibilidad para la propagación de contexto cuando se utiliza ::Concurrent::Future y Concurrent::Async, y asegura que el código rastreado dentro de Future#execute y Concurrent::Async#async tendrá el conjunto de elementos principales correcto.

Para activar tu integración, utiliza el método Datadog.configure:

# Dentro del inicializador Rails initializer o equivalente
Datadog.configure do |c|
  # Corrige mediante parches ::Concurrent::Future para que utilice ExecutorService que propaga el contexto
  c.tracing.instrument :concurrent_ruby
end

# Transfiere contexto al código ejecutado dentro de Concurrent::Future
Datadog::Tracing.trace('outer') do
  Concurrent::Future.execute { Datadog::Tracing.trace('inner') { } }.wait
end

# Transfiere contexto al código ejecutado dentro de Concurrent::Async
class MyClass
  include ConcurrentAsync

  def foo
    Datadog::Tracing.trace('inner') { }
  end
end

Datadog::Tracing.trace('outer') do
  MyClass.new.async.foo
end

Cucumber

La integración con Cucumber rastrea todas las ejecuciones de escenarios y pasos cuando se utiliza el marco cucumber.

Para activar tu integración, utiliza el método Datadog.configure:

require 'cucumber'
require 'ddtrace'

# Configura la integración con Cucumber predeterminada
Datadog.configure do |c|
  c.ci.instrument :cucumber, **options
end

# Ejemplo de cómo adjuntar etiquetas del escenario al tramo activo
Around do |scenario, block|
  active_span = Datadog.configuration[:cucumber][:tracer].active_span
  unless active_span.nil?
    scenario.tags.filter { |tag| tag.include? ':' }.each do |tag|
      active_span.set_tag(*tag.name.split(':', 2))
    end
  end
  block.call
end

Las options son los siguientes argumentos de palabra clave:

Dalli

La integración con Dalli rastreará todas las llamadas a tu servidor memcached:

require 'dalli'
require 'ddtrace'

# Configura el comportamiento de rastreo predeterminado de Dalli
Datadog.configure do |c|
  c.tracing.instrument :dalli, **options
end

# Configura el comportamiento de rastreo de Dalli para un solo cliente
client = Dalli::Client.new('localhost:11211', **options)
client.set('abc', 123)

Las options son los siguientes argumentos de palabra clave:

DelayedJob

La integración con DelayedJob utiliza ganchos de ciclo de vida para rastrear ejecuciones y colas de tareas.

Puedes activarlo a través de Datadog.configure:

require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :delayed_job, **options
end

Las options son los siguientes argumentos de palabra clave:

Elasticsearch

La integración con Elasticsearch rastreará cualquier llamada a perform_request en el objeto Client:

require 'elasticsearch/transport'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :elasticsearch, **options
end

# Realiza una consulta a Elasticsearch
client = Elasticsearch::Client.new url: 'http://127.0.0.1:9200'
response = client.perform_request 'GET', '_cluster/health'

# En caso de que quieras anular la configuración global de una instancia de cliente determinada
Datadog.configure_onto(client.transport, **options)

Las options son los siguientes argumentos de palabra clave:

Ethon

La integración con ethon rastrea cualquier solicitud HTTP a través de objetos Easy o Multi . Ten en cuenta que este integración también admite bibliotecas Typhoeus, basadas en Ethon.

require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :ethon, **options

  # también puedes especificar un nombre de servicio diferente para nombres de hosts que coinciden con una expresión regular (regex)
  c.tracing.instrument :ethon, describes: /user-[^.]+\.example\.com/ do |ethon|
    ethon.service_name = 'user.example.com'
    ethon.split_by_domain = false # Only necessary if split_by_domain is true by default
  end
end

Las options son los siguientes argumentos de palabra clave:

Excon

La integración de excon está disponible a través del middleware ddtrace:

require 'excon'
require 'ddtrace'

# Configura el comportamiento de rastreo predeterminado de Excon
Datadog.configure do |c|
  c.tracing.instrument :excon, **options

  # también puedes especificar un nombre de servicio diferente para nombres de hosts que coinciden con una expresión regular (regex)
  c.tracing.instrument :excon, describes: /user-[^.]+\.example\.com/ do |excon|
    excon.service_name = 'user.example.com'
    excon.split_by_domain = false # Only necessary if split_by_domain is true by default
  end
end

connection = Excon.new('https://example.com')
connection.get

Las options son los siguientes argumentos de palabra clave:

Configurar las conexiones para utilizar diferentes configuraciones

Si utilizas varias conexiones con Excon, puedes dar a cada una de ellas diferentes parámetros, configurando sus constructores con middleware:

# Envuelve el stack tecnológico de middleware predeterminado con el middleware de rastreo de Datadog
Excon.new(
  'http://example.com',
  middlewares: Datadog::Tracing::Contrib::Excon::Middleware.with(options).around_default_stack
)

# Inserta el middleware dentro de un stack tecnológico de middleware personalizado.
# NOTA: ¡El middleware de rastreo debe insertarse después del ResponseParser!
Excon.new(
  'http://example.com',
  middlewares: [
    Excon::Middleware::ResponseParser,
    Datadog::Tracing::Contrib::Excon::Middleware.with(options),
    Excon::Middleware::Idempotent
  ]
)

Donde options es un Hash que contiene cualquiera de los parámetros enumerados en la tabla anterior.

Faraday

La integración de faraday está disponible a través del middleware ddtrace:

require 'faraday'
require 'ddtrace'

# Configura el comportamiento de rastreo predeterminado de Faraday
Datadog.configure do |c|
  c.tracing.instrument :faraday, **options

  # también puedes especificar un nombre de servicio diferente para nombres de hosts que coinciden con una expresión regular (regex)
  c.tracing.instrument :faraday, describes: /user-[^.]+\.example\.com/ do |faraday|
    faraday.service_name = 'user.example.com'
    faraday.split_by_domain = false # Only necessary if split_by_domain is true by default
  end
end

# En caso de que quieras anular la configuración global de una instancia de cliente determinada
connection = Faraday.new('https://example.com') do |builder|
  builder.use(:ddtrace, **options)
  builder.adapter Faraday.default_adapter
end

connection.get('/foo')

Las options son los siguientes argumentos de palabra clave:

Grape

La integración de Grape añade la instrumentación a los endpoints y filtros de Grape. Esta integración puede funcionar en conjunto con otras integraciones como Rack y Rails.

Para activar tu integración, utiliza el método Datadog.configure antes de definir tu aplicación Grape:

# api.rb
require 'grape'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :grape, **options
end

# Luego, define tu aplicación
class RackTestingAPI < Grape::API
  desc 'main endpoint'
  get :success do
    'Hello world!'
  end
end

Las options son los siguientes argumentos de palabra clave:

GraphQL

La integración de GraphQL activa la instrumentación para las consultas de GraphQL.

Para activar tu integración, utiliza el método Datadog.configure:

# En el inicializador Rails o equivalente
Datadog.configure do |c|
  c.tracing.instrument :graphql, schemas: [YourSchema], **options
end

# Luego, ejecuta una consulta GraphQL
YourSchema.execute(query, variables: {}, context: {}, operation_name: nil)

El método instrument :graphql acepta los siguientes parámetros. Se pueden sustituir opciones adicionales por options:

Configuración manual de esquemas de GraphQL

Si prefieres configurar individualmente los parámetros del rastreador para un esquema (por ejemplo, si tienes varios esquemas con diferentes nombres de servicios), en la definición del esquema, puedes añadir lo siguiente utilizando la API de GraphQL:

# Esquema basado en clases
class YourSchema < GraphQL::Schema
  use(
    GraphQL::Tracing::DataDogTracing,
    service: 'graphql'
  )
end

# Esquema .define-style
YourSchema = GraphQL::Schema.define do
  use(
    GraphQL::Tracing::DataDogTracing,
    service: 'graphql'
  )
end

O puedes modificar un esquema ya definido:

# Esquema basado en clases
YourSchema.use(
    GraphQL::Tracing::DataDogTracing,
    service: 'graphql'
)

# Esquema .define-style
YourSchema.define do
  use(
    GraphQL::Tracing::DataDogTracing,
    service: 'graphql'
  )
end

NO instrument :graphql en Datadog.configure si eliges la configuración manual, para evitar el doble rastreo. Estas dos formas de configurar el rastreo de GraphQL se consideran mutuamente excluyentes.

gRPC

La integración de grpc añade interceptores de cliente y servidor, que se ejecutan como middleware antes de ejecutar la llamada al procedimiento remoto del servicio. Como las aplicaciones gRPC suelen estar distribuidas, la integración comparte información de rastreo entre el cliente y el servidor.

Para configurar tu integración, utiliza el método Datadog.configure de la siguiente manera:

require 'grpc'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :grpc, **options
end

# Lado del servidor
server = GRPC::RpcServer.new
server.add_http2_port('localhost:50051', :this_port_is_insecure)
server.handle(Demo)
server.run_till_terminated

# Lado del cliente
client = Demo.rpc_stub_class.new('localhost:50051', :this_channel_is_insecure)
client.my_endpoint(DemoMessage.new(contents: 'hello!'))

Las options son los siguientes argumentos de palabra clave:

Aviso de obsolescencia:

• error_handler será eliminado. Utiliza server_error_handler en su lugar.

Configurar clientes para que utilicen diferentes parámetros

En situaciones en las que haya varios clientes que llamen a varios servicios distintos, puedes pasar el interceptor de Datadog directamente, de la siguiente manera:

configured_interceptor = Datadog::Tracing::Contrib::GRPC::DatadogInterceptor::Client.new do |c|
  c.service_name = "Alternate"
end

alternate_client = Demo::Echo::Service.rpc_stub_class.new(
  'localhost:50052',
  :this_channel_is_insecure,
  :interceptors => [configured_interceptor]
)

La integración se asegurará de que configured_interceptor defina una configuración de rastreo única para esa instancia de cliente.

hanami

La integración de hanami instrumentará el enrutamiento, la acción y la representación de tu aplicación hanami. Para habilitar la instrumentación de hanami, se recomienda instrumentar automáticamente con

gem 'ddtrace', require: 'ddtrace/auto_instrument'

y crear un archivo inicializador en tu carpeta config/initializers:

# config/initializers/datadog.rb
Datadog.configure do |c|
  c.tracing.instrument :hanami, **options
end

Las options son los siguientes argumentos de palabra clave:

http.rb

La integración de http.rb rastreará cualquier llamada HTTP a través de la gema http.rb.

require 'http'
require 'ddtrace'
Datadog.configure do |c|
  c.tracing.instrument :httprb, **options
  # también puedes especificar un nombre de servicio diferente para nombres de hosts que coinciden con una expresión regular (regex)
  c.tracing.instrument :httprb, describes: /user-[^.]+\.example\.com/ do |httprb|
    httprb.service_name = 'user.example.com'
    httprb.split_by_domain = false # Only necessary if split_by_domain is true by default
  end
end

Las options son los siguientes argumentos de palabra clave:

httpclient

La integración de httpclient rastreará cualquier llamada HTTP a través de la gema httpclient.

require 'httpclient'
require 'ddtrace'
Datadog.configure do |c|
  c.tracing.instrument :httpclient, **options
  # también puedes especificar un nombre de servicio diferente para nombres de hosts que coinciden con una expresión regular (regex)
  c.tracing.instrument :httpclient, describes: /user-[^.]+\.example\.com/ do |httpclient|
    httpclient.service_name = 'user.example.com'
    httpclient.split_by_domain = false # Only necessary if split_by_domain is true by default
  end
end

Las options son los siguientes argumentos de palabra clave:

httpx

httpx conserva su propia integración con ddtrace:

require "ddtrace"
require "httpx/adapters/datadog"

Datadog.configure do |c|
  c.tracing.instrument :httpx

  # también puedes especificar un nombre de servicio diferente para nombres de hosts que coinciden con una expresión regular (regex)
  c.tracing.instrument :httpx, describes: /user-[^.]+\.example\.com/ do |http|
    http.service_name = 'user.example.com'
    http.split_by_domain = false # Only necessary if split_by_domain is true by default
  end
end

Kafka

La integración de Kafka proporciona un rastreo de la gema ruby-kafka:

Puedes habilitarla a través de Datadog.configure:

require 'active_support/notifications' # required to enable 'ruby-kafka' instrumentation
require 'kafka'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :kafka
end

Minitest

La integración con Minitest rastrea todas las ejecuciones de tests cuando se utiliza el marco para tests minitest.

Para activar tu integración, utiliza el método Datadog.configure:

require 'minitest'
require 'ddtrace'

# Configura la integración predeterminada con Minitest
Datadog.configure do |c|
  c.ci.instrument :minitest, **options
end

Las options son los siguientes argumentos de palabra clave:

MongoDB

La integración rastrea cualquier Command que se envía desde el controlador de Ruby MongoDB a un clúster de MongoDB. Por extensión, los Object Document Mappers (ODM) como Mongoid se instrumentan automáticamente si utilizan el controlador oficial de Ruby. Para activar la integración, simplemente:

require 'mongo'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :mongo, **options
end

# Crea un cliente MongoDB y utilízalo como de costumbre
client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'artists')
collection = client[:people]
collection.insert_one({ name: 'Steve' })

# En caso de que quieras anular la configuración global de una instancia de cliente determinada
Datadog.configure_onto(client, **options)

Las options son los siguientes argumentos de palabra clave:

Configuración de los parámetros de rastreo por conexión

Puedes configurar los parámetros de rastreo por conexión a través de la opción describes:

# Proporciona una opción `:describes` con una clave de conexión.
# Cualquiera de las siguientes claves son aceptables y equivalentes unas con otras.
# Si se proporciona un bloque, genera un objeto Parámetros que
# acepta cualquiera de las opciones de configuración enumeradas anteriormente.

Datadog.configure do |c|
  # Cadena de conexión de red
  c.tracing.instrument :mongo, describes: '127.0.0.1:27017', service_name: 'mongo-primary'

  # Expresión regular de conexión de red
  c.tracing.instrument :mongo, describes: /localhost.*/, service_name: 'mongo-secondary'
end

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'artists')
collection = client[:people]
collection.insert_one({ name: 'Steve' })
# La llamada rastreada pertenecerá al servicio `mongo-primary`

client = Mongo::Client.new([ 'localhost:27017' ], :database => 'artists')
collection = client[:people]
collection.insert_one({ name: 'Steve' })
# La llamada rastreada pertenecerá al servicio `mongo-secondary`

Cuando varias configuraciones de describes coincidan con una conexión, se aplicará la última regla configurada que coincida.

MySQL2

La integración de MySQL2 rastrea cualquier comando SQL enviado a través de la gema mysql2.

require 'mysql2'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :mysql2, **options
end

client = Mysql2::Client.new(:host => "localhost", :username => "root")
client.query("SELECT * FROM users WHERE group='x'")

Las options son los siguientes argumentos de palabra clave:

Net/HTTP

La integración de Net/HTTP rastreará cualquier llamada HTTP utilizando el módulo estándar lib Net::HTTP.

require 'net/http'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :http, **options

  # también puedes especificar un nombre de servicio diferente para nombres de hosts que coinciden con una expresión regular (regex)
  c.tracing.instrument :http, describes: /user-[^.]+\.example\.com/ do |http|
    http.service_name = 'user.example.com'
    http.split_by_domain = false # Only necessary if split_by_domain is true by default
  end
end

Net::HTTP.start('127.0.0.1', 8080) do |http|
  request = Net::HTTP::Get.new '/index'
  response = http.request(request)
end

content = Net::HTTP.get(URI('http://127.0.0.1/index.html'))

Las options son los siguientes argumentos de palabra clave:

Si quieres configurar cada objeto de conexión individualmente, puedes utilizar Datadog.configure_onto como se indica a continuación:

client = Net::HTTP.new(host, port)
Datadog.configure_onto(client, **options)

OpenSearch

La integración de OpenSearch rastreará cualquier llamada a perform_request en el objeto Client:

require 'opensearch'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :opensearch, **options
end

# Realiza una consulta a OpenSearch
client = OpenSearch::Client.new(
  host: 'https://localhost:9200',
  user: 'user',
  password: 'password',
)
client.cluster.health

Las options son los siguientes argumentos de palabra clave:

Postgres

La integración de Postgres rastrea cualquier comando SQL enviado a través de la gema pg.

• exec, exec_params, exec_prepared;
• async_exec, async_exec_params, async_exec_prepared; o,
• sync_exec, sync_exec_params, sync_exec_prepared

require 'pg'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :pg, **options
end

Las options son los siguientes argumentos de palabra clave:

Presto

La integración de Presto rastrea cualquier comando SQL enviado a través de la gema presto-client.

require 'presto-client'
require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :presto, **options
end

client = Presto::Client.new(
  server: "localhost:8880",
  ssl: {verify: false},
  catalog: "native",
  schema: "default",
  time_zone: "US/Pacific",
  language: "English",
  http_debug: true,
)

client.run("select * from system.nodes")

Las options son los siguientes argumentos de palabra clave:

Qless

La integración con Qless utiliza ganchos de ciclo de vida para rastrear ejecuciones de tareas.

Para añadir el rastreo a una tarea Qless:

require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :qless, **options
end

Las options son los siguientes argumentos de palabra clave:

Que

La integración de Que es un middleware que rastrea ejecuciones de tareas.

Puedes habilitarla a través de Datadog.configure:

require 'ddtrace'

Datadog.configure do |c|
  c.tracing.instrument :que, **options
end

Las options son los siguientes argumentos de palabra clave: