logstash logger
1.0.0
LogStashLogger extiende la clase Logger de Ruby para iniciar sesión directamente en Logstash. Admite la escritura en varias salidas en formato JSON logstash. Esta es una mejora con respecto a la escritura en un archivo o syslog, ya que Logstash puede recibir los datos estructurados directamente.
Puede escribir directamente en un oyente logstash a través de una conexión UDP o TCP/SSL.
Puede escribir en un archivo, Redis, Kafka, Kinesis, Firehose, un socket Unix, syslog, stdout o stderr.
Logger puede tomar un mensaje de cadena, un hash, un LogStash::Event , un objeto o una cadena JSON como entrada.
Los eventos se completan automáticamente con mensaje, marca de tiempo, host y gravedad.
Escribe en formato logstash JSON, pero también admite otros formatos.
Puede escribir en múltiples salidas.
Los mensajes de registro se almacenan en un búfer y se reenvían automáticamente si hay un problema de conexión.
Se integra fácilmente con Rails mediante configuración.
Agregue esta línea al Gemfile de su aplicación:
gem 'logstash-logger'
Y luego ejecuta:
$ bundle
O instálelo usted mismo como:
$ gem install logstash-logger
require 'logstash-logger'# El valor predeterminado es UDP en 0.0.0.0logger = LogStashLogger.new(puerto: 5228)# Especifica el host y el tipo (UDP o TCP) explícitamenteudp_logger = LogStashLogger.new(tipo::udp, host: 'localhost' , puerto: 5228)tcp_logger = LogStashLogger.new(tipo: :tcp, host: 'localhost', puerto: 5229)# Otros tipos de loggersfile_logger = LogStashLogger.new(tipo:: archivo, ruta: 'log/development.log', sincronización: true)unix_logger = LogStashLogger.new(tipo::unix, ruta: '/tmp/sock')syslog_logger = LogStashLogger.new(tipo: :syslog)redis_logger = LogStashLogger.new(tipo: :redis)kafka_logger = LogStashLogger.new(tipo: :kafka)stdout_logger = LogStashLogger.new(tipo: :stdout)stderr_logger = LogStashLogger.new(tipo: :stderr)io_logger = LogStashLogger.new(tipo: :io, io: io)# Utilice un formato diferente cee_logger = LogStashLogger.nuevo(
escriba: :tcp,
anfitrión: 'logsene-receiver-syslog.sematext.com',
puerto: 514,
formateador: :cee_syslog)custom_formatted_logger = LogStashLogger.new(
tipo: :redis,
formateador: MyCustomFormatter)lambda_formatted_logger = LogStashLogger.new(
tipo: :stdout,
formateador: ->(severidad, tiempo, nombre de programa, mensaje) { "[#{nombre de programa}] #{msg}" })ruby_default_formatter_logger = LogStashLogger.new(
tipo: :archivo,
ruta: 'log/development.log',
formateador: ::Logger::Formatter)# Enviar mensajes a múltiples salidas. Cada salida tendrá el mismo formato.# Syslog no puede ser una salida porque requiere un logger.multi_delegating_logger = LogStashLogger.new(
tipo: :multi_delegator,
salidas: [{ tipo: :archivo, ruta: 'log/development.log' },{ tipo: :udp, host: 'localhost', puerto: 5228 }
])# Equilibra mensajes entre varias salidas.# Funciona igual que el delegador múltiple, pero elige aleatoriamente una salida para enviar cada mensaje.balancer_logger = LogStashLogger.new(
tipo: :equilibrador,
salidas: [{ tipo: :udp, host: 'host1', puerto: 5228 },{ tipo: :udp, host: 'host2', puerto: 5228 }
])# Enviar mensajes a múltiples registradores.# Use esto si necesita enviar diferentes formatos a diferentes salidas.# Si necesita iniciar sesión en syslog, debe usar this.multi_logger = LogStashLogger.new(
escriba: :multi_logger,
salidas: [{ tipo: :archivo, ruta: 'log/development.log', formateador: ::Logger::Formatter },{ tipo: :tcp, host: 'localhost', puerto: 5228, formateador: :json }
])# Los siguientes mensajes se escriben en el puerto UDP 5228:logger.info 'test'# {"message":"test","@timestamp":"2014-05-22T09:37:19.204-07:00", "@version":"1","severity":"INFO","host":"[nombre de host]"}logger.error '{"message": "error"}'# {"message":"error","@timestamp":"2014-05-22T10:10:55.877-07:00","@version":"1","severity":"ERROR","host" :"[nombre de host]"}mensaje de logger.debug: 'prueba', foo: 'barra'# {"message":"test","foo":"bar","@timestamp":"2014-05-22T09:43:24.004-07:00","@version":"1","severidad" :"DEBUG","host":"[nombre de host]"}logger.warn LogStash::Event.new(mensaje: 'prueba', foo: 'bar')# {"message":"test","foo":"bar","@timestamp":"2014-05-22T16:44:37.364Z","@version":"1","severity":"ADVERTENCIA ","host":"[nombre de host]"}# Etiquetado logginglogger.tagged('foo') { logger.fatal('bar') }# {"message":"bar","@timestamp":"2014-05-26T20:35:14.685-07:00","@version":"1","severity":"FATAL","host" :"[nombre de host]","tags":["foo"]} Puede utilizar un URI para configurar su registrador logstash en lugar de un hash. Esto es útil en entornos como Heroku, donde es posible que desee leer los valores de configuración del entorno. El esquema de URI es type://host:port/path?key=value . A continuación se proporcionan algunos ejemplos de configuraciones de URI.
udp://localhost:5228 tcp://localhost:5229 unix:///tmp/socket file:///path/to/file redis://localhost:6379 kafka://localhost:9092 stdout:/ stderr:/
Pase el URI a su registrador logstash de esta manera:
# Leer el URI de una variable de entornologger = LogStashLogger.new(uri: ENV['LOGSTASH_URI'])
Para que logstash reciba y analice correctamente los eventos, deberá configurar y ejecutar un detector que utilice el códec json_lines . Por ejemplo, para recibir eventos a través de UDP en el puerto 5228:
aporte {
udp {host => "0.0.0.0" puerto => 5228codec => json_lines
}} Las entradas de archivos y Redis deberían usar el códec json en su lugar. Para obtener más información, lea los documentos de Logstash.
Consulte el directorio de ejemplos para obtener más ejemplos de configuración.
Si está utilizando TCP, existe la opción de agregar un certificado SSL al hash de opciones al inicializar.
LogStashLogger.new(tipo: :tcp, puerto: 5228, ssl_certificate: "/ruta/a/certificado.crt")
El certificado SSL y la clave se pueden generar usando
openssl req -x509 -batch -nodes -newkey rsa:2048 -keyout logstash.key -out logstash.crt
También puede habilitar SSL sin certificado:
LogStashLogger.new (tipo: tcp, puerto: 5228, ssl_enable: verdadero)
Especifique un contexto SSL para tener más control sobre el comportamiento. Por ejemplo, configure el modo de verificación:
ctx = OpenSSL::SSL::SSLContext.newctx.set_params(verify_mode: OpenSSL::SSL::VERIFY_NONE)LogStashLogger.new(tipo: :tcp, puerto: 5228, ssl_context: ctx)
Se requiere la siguiente configuración de Logstash para SSL:
aporte {
tcp {host => "0.0.0.0"port => 5228codec => json_linesssl_enable => truessl_cert => "/path/to/certificate.crt"ssl_key => "/path/to/key.key"
}} La verificación del nombre de host está habilitada de forma predeterminada. Sin configuración adicional, el nombre de host proporcionado a :host se utilizará para verificar la identidad del certificado del servidor.
Si no pasa :ssl_context o pasa un valor falso a la opción :verify_hostname , la verificación del nombre de host no se producirá.
Verifique el nombre de host desde la opción :host
ctx = OpenSSL::SSL::SSLContext.newctx.cert = '/path/to/cert.pem'ctx.verify_mode = OpenSSL::SSL::VERIFY_PEERLogStashLogger.new escriba: :tcp, anfitrión: 'logstash.ejemplo.com' puerto: 5228, contexto_ssl: ctx
Verifique un nombre de host diferente de la opción :host
LogStashLogger.nuevo escriba: :tcp, anfitrión: '1.2.3.4' puerto: 5228, contexto_ssl: ctx, verificar_nombre de host: 'servidor.ejemplo.com'
Deshabilitar explícitamente la verificación del nombre de host
LogStashLogger.nuevo escriba: :tcp, anfitrión: '1.2.3.4' puerto: 5228, contexto_ssl: ctx, verificar_nombre de host: falso
LogStashLogger de forma predeterminada registrará un objeto JSON con el formato siguiente.
{ "message":"Algún mensaje", "@timestamp":"2015-01-29T10:43:32.196-05:00", "@version":"1", "severity":"INFO", "host ":"nombre de host"} Es posible que algunas aplicaciones necesiten adjuntar metadatos adicionales a cada mensaje. LogStash::Event se puede manipular directamente especificando un bloque customize_event en la configuración de LogStashLogger .
config = LogStashLogger.configure hacer |config| config.customize_event do |evento|evento["otro_campo"] = "algún_otro_valor" final
Esta configuración daría como resultado el siguiente resultado.
{"message": "Algún mensaje","@timestamp": "2015-01-29T10:43:32.196-05:00","@version": "1","severity": "INFO","host ": "nombre de host","otro_campo": "algún_otro_valor"}Este bloque tiene acceso completo al evento, por lo que puedes eliminar campos, modificar campos existentes, etc. Por ejemplo, para eliminar la marca de tiempo predeterminada:
config = LogStashLogger.configure hacer |config| config.customize_event hacer |evento|event.remove('@marca de tiempo')
final También puede personalizar eventos por registrador pasando un objeto invocable (lambda o proc) a la opción customize_event al crear un registrador:
LogStashLogger.new(customize_event: ->(event){ evento['otro_campo'] = 'otro_campo' })Para los dispositivos que establecen una conexión a un servicio remoto, los mensajes de registro se almacenan internamente y se descargan en un hilo en segundo plano. Si hay un problema de conexión, los mensajes se mantienen en el búfer y se reenvían automáticamente hasta que se realiza correctamente. Las salidas que admiten la escritura por lotes (Redis y Kafka) escribirán mensajes de registro de forma masiva desde el búfer. Esta funcionalidad se implementa utilizando una bifurcación de Stud::Buffer. Puede configurar su comportamiento pasando las siguientes opciones a LogStashLogger:
:buffer_max_items: número máximo de elementos que se almacenarán en el búfer antes de vaciarlos. El valor predeterminado es 50.
:buffer_max_interval: número máximo de segundos que se deben esperar entre descargas. El valor predeterminado es 5.
:drop_messages_on_flush_error: elimina mensajes cuando hay un error de descarga. El valor predeterminado es falso.
:drop_messages_on_full_buffer: elimina mensajes cuando el búfer está lleno. El valor predeterminado es verdadero.
:sync: vacía el búfer cada vez que se recibe un mensaje (bloqueo). El valor predeterminado es falso.
:buffer_flush_at_exit: borra los mensajes al salir del programa. El valor predeterminado es verdadero.
:buffer_logger: registrador en el que escribir mensajes de error/depuración del búfer. El valor predeterminado es ninguno.
Puede desactivar el almacenamiento en búfer configurando sync = true .
Tenga en cuenta las siguientes advertencias sobre este comportamiento:
Es posible que se envíen mensajes de registro duplicados al volver a intentarlo. Para salidas como Redis y Kafka que escriben en lotes, se podría reenviar todo el lote. Si esto es un problema, puede agregar un campo UUID a cada evento para identificarlo de forma única. Puede hacer esto en un bloque customize_event o utilizando el filtro UUID de logstash.
Aún es posible perder mensajes de registro. Ruby no detectará un problema de conexión TCP/UDP inmediatamente. En mis pruebas, Ruby tardó unos 4 segundos en notar que el extremo receptor estaba inactivo y comenzar a generar excepciones. Dado que los oyentes de logstash a través de TCP/UDP no reconocen los mensajes recibidos, no es posible saber qué mensajes de registro reenviar.
Cuando sync está desactivada, Ruby puede almacenar datos en el buffer internamente antes de escribirlos en el dispositivo IO. Esta es la razón por la que es posible que no vea mensajes escritos inmediatamente en un socket UDP o TCP, aunque el búfer de LogStashLogger se vacíe periódicamente.
De forma predeterminada, los mensajes se descartan cuando el búfer se llena. Esto puede suceder si la fuente de salida está inactiva durante demasiado tiempo o si los mensajes de registro se reciben demasiado rápido. Si su aplicación finaliza repentinamente (por ejemplo, por SIGKILL o un corte de energía), se perderá todo el búfer.
Puede hacer que la pérdida de mensajes sea menos probable aumentando buffer_max_items (para que se puedan retener más eventos en el búfer) y disminuyendo buffer_max_interval (para esperar menos tiempo entre descargas). Esto aumentará la presión de la memoria en su aplicación a medida que los mensajes de registro se acumulen en el búfer, así que asegúrese de haber asignado suficiente memoria a su proceso.
Si no desea perder mensajes cuando el búfer se llene, puede configurar drop_messages_on_full_buffer = false . Tenga en cuenta que si el búfer se llena, cualquier mensaje de registro entrante se bloqueará, lo que podría no ser deseable.
Todas las salidas del registrador admiten una configuración sync . Esto es análogo a la configuración del "modo de sincronización" en los objetos Ruby IO. Cuando se establece en true , la salida se vacía inmediatamente y no se almacena en el búfer internamente. Normalmente, para dispositivos que se conectan a un servicio remoto, el almacenamiento en búfer es algo bueno porque mejora el rendimiento y reduce la probabilidad de que se produzcan errores que afecten al programa. Para estos dispositivos, el valor predeterminado sync es false y se recomienda dejar el valor predeterminado. Es posible que desee activar el modo de sincronización para realizar pruebas, por ejemplo, si desea ver los mensajes de registro inmediatamente después de escribirlos.
Se recomienda activar el modo de sincronización para salidas de archivos y sockets Unix. Esto garantiza que los mensajes de registro de diferentes subprocesos o procesos se escriban correctamente en líneas separadas.
Consulte el n.° 44 para obtener más detalles.
Si se produce una excepción al escribir un mensaje en el dispositivo, la excepción se registra mediante un registrador interno. De forma predeterminada, esto se registra en $stderr. Puede cambiar el registrador de errores configurando LogStashLogger.configuration.default_error_logger o pasando su propio objeto de registro en la clave de configuración :error_logger al crear una instancia de un LogStashLogger.
LogStashLogger brinda soporte para el silenciamiento de registradores estilo Rails. La implementación se extrajo de Rails, pero no tiene dependencias, por lo que se puede usar fuera de una aplicación Rails. La interfaz es la misma que en Rails:
logger.silence(nivel_temporal) hacer ...fin
De forma predeterminada, LogStashLogger crea un registrador que extiende la clase Logger integrada en Ruby. Si necesita una implementación de registrador diferente, puede usar una clase diferente pasando la clase con la opción logger_class .
Tenga en cuenta que para syslog, la clase Syslog::Logger es necesaria y no se puede cambiar.
Soporta Rails 4.2 y 5.x.
De forma predeterminada, cada mensaje de registro de Rails se escribirá en logstash en formato LogStash::Event JSON.
Para eventos logstash mínimos y más estructurados, pruebe una de las siguientes gemas:
lograr
jardinero
Actualmente, estas gemas generan una cadena JSON, que luego LogStashLogger analiza. Las versiones futuras de estas gemas podrían tener una integración más profunda con LogStashLogger (por ejemplo, escribiendo directamente objetos LogStash::Event ).
Agregue lo siguiente a su config/environments/production.rb :
# Opcional, Rails establece el valor predeterminado en :infoconfig.log_level = :debug# Opcional, Rails 4 por defecto es verdadero en desarrollo y falso en producciónconfig.autoflush_log = true# Opcional, use un URI para configurar. Útil en Herokuconfig.logstash.uri = ENV['LOGSTASH_URI']# Opcional. El valor predeterminado es: json_lines. Si hay varias salidas,# todas compartirán el mismo formatter.config.logstash.formatter = :json_lines# Opcional, el registrador en el que registrar los errores de escritura. El valor predeterminado es iniciar sesión en $stderrconfig.logstash.error_logger = Logger.new($stderr)# Opcional, número máximo de elementos para almacenar en el buffer antes de vaciarlos. El valor predeterminado es 50config.logstash.buffer_max_items = 50# Opcional, número máximo de segundos para esperar entre descargas. El valor predeterminado es 5config.logstash.buffer_max_interval = 5# Opcional, elimine el mensaje cuando se produzca un error de conexión. El valor predeterminado es falseconfig.logstash.drop_messages_on_flush_error = false# Opcional, descartar mensajes cuando el búfer esté lleno. El valor predeterminado es trueconfig.logstash.drop_messages_on_full_buffer = true
# Opcional, el valor predeterminado es '0.0.0.0'config.logstash.host = 'localhost'# Opcional, el valor predeterminado es :udp.config.logstash.type = :udp# Requerido, el puerto para conectarse aconfig.logstash.port = 5228
# Opcional, el valor predeterminado es '0.0.0.0'config.logstash.host = 'localhost'# Requerido, el puerto para conectarse aconfig.logstash.port = 5228# Requeridoconfig.logstash.type = :tcp# Opcional, habilita SSLconfig.logstash. ssl_enable = verdadero
# Requiredconfig.logstash.type = :unix# Requiredconfig.logstash.path = '/tmp/sock'
Si estás en Ruby 1.9, agrega Syslog::Logger v2 a tu Gemfile:
gem 'SyslogLogger', '2.0'
Si estás en Ruby 2+, Syslog::Logger ya está integrado en la biblioteca estándar.
# Requiredconfig.logstash.type = :syslog# Opcional. El valor predeterminado es 'ruby'config.logstash.program_name = 'MyApp'# Nivel de instalación predeterminado opcional. Sólo funciona en Ruby 2+config.logstash.facility = Syslog::LOG_LOCAL0
Agrega la gema redis a tu Gemfile:
gem 'redis'
# Requiredconfig.logstash.type = :redis# Opcional, el valor predeterminado será 'logstash' listconfig.logstash.list = 'logstash'# Todas las demás opciones se pasan al cliente Redis# Las opciones admitidas incluyen host, puerto, ruta y contraseña , url# Ejemplo:# Opcional, Redis usará de manera predeterminada localhostconfig.logstash.host = 'localhost'# Opcional, Redis usará de manera predeterminada el puerto 6379config.logstash.port = 6379
Agrega la gema Poseidón a tu Gemfile:
gem 'poseidon'
# Requiredconfig.logstash.type = :kafka# Opcional, por defecto será 'logstash' topicconfig.logstash.path = 'logstash'# Opcional, por defecto será 'logstash-logger' Producerconfig.logstash.producer = 'logstash-logger '# Opcional, el valor predeterminado será localhost:9092 host/portconfig.logstash.hosts = ['localhost:9092']# Opcional, el valor predeterminado a 1s backoffconfig.logstash.backoff = 1
Agregue la gema aws-sdk a su Gemfile:
# aws-sdk >= 3.0 gem 'aws-sdk-kinesis' # aws-sdk < 3.0 gem 'aws-sdk'
# Requiredconfig.logstash.type = :kinesis# Opcional, el valor predeterminado será 'logstash' streamconfig.logstash.stream = 'my-stream-name'# Opcional, el valor predeterminado será 'us-east-1'config.logstash.aws_region = 'us-west-2'# Opcional, el valor predeterminado será la variable de entorno AWS_ACCESS_KEY_IDconfig.logstash.aws_access_key_id = 'ASKASKHLD12341'# Opcional, por defecto será la variable de entorno AWS_SECRET_ACCESS_KEYconfig.logstash.aws_secret_access_key = 'ASKASKHLD1234123412341234'
Agregue la gema aws-sdk a su Gemfile:
# aws-sdk >= 3.0 gem 'aws-sdk-firehose' # aws-sdk < 3.0 gem 'aws-sdk'
# Requiredconfig.logstash.type = :firehose# Opcional, por defecto será la entrega 'logstash' streamconfig.logstash.stream = 'my-stream-name'# Opcional, por defecto será la configuración de región predeterminada de AWS chainconfig.logstash.aws_region = ' us-west-2'# Opcional, el valor predeterminado será el proveedor de credenciales predeterminado de AWS chainconfig.logstash.aws_access_key_id = 'ASKASKHLD12341'# Opcional, el valor predeterminado será el proveedor de credenciales predeterminado de AWS chainconfig.logstash.aws_secret_access_key = 'ASKASKHLD1234123412341234'
# Requiredconfig.logstash.type = :file# Opcional, por defecto es el registro de Rails pathconfig.logstash.path = 'log/production.log'
# Requiredconfig.logstash.type = :io# Requiredconfig.logstash.io = io
# Requiredconfig.logstash.type = :multi_delegator# Requiredconfig.logstash.outputs = [
{tipo:: archivo, ruta: 'log/production.log'
},
{tipo: :udp,puerto: 5228,host: 'localhost'
}] # Requiredconfig.logstash.type = :multi_logger# Requerido. Cada registrador puede tener su propio formatter.config.logstash.outputs = [
{tipo: :archivo,ruta: 'log/production.log',formateador: ::Logger::Formateador
},
{tipo: :udp,puerto: 5228,host: 'localhost'
}]En las aplicaciones web, puede registrar datos de solicitudes HTTP (como encabezados) utilizando el middleware RequestStore. El siguiente ejemplo asume Rails.
# en Gemfilegem 'request_store'
# en application.rbLogStashLogger.configure hacer |config| config.customize_event hacer |evento|evento["session_id"] = RequestStore.store[:load_balancer_session_id] final
# en app/controllers/application_controller.rbbefore_filter :track_load_balancer_session_iddef track_load_balancer_session_id RequestStore.store[:load_balancer_session_id] = request.headers["X-LOADBALANCER-SESSIONID"]end
Si su aplicación se bifurca (como es común con muchos servidores web), necesitará administrar los recursos de limpieza en sus instancias de LogStashLogger. Para ello está disponible el método de instancia #reset . A continuación se muestra una configuración de ejemplo para varios servidores web comunes utilizados con Rails:
Pasajero:
::PhusionPassenger.on_event(:starting_worker_process) hacer |bifurcado| Rails.logger.resetear
Puma:
# En config/puma.rbon_worker_boot hacer Rails.logger.resetear
Unicornio
# En config/unicorn.rbafter_fork haga |servidor, trabajador| Rails.logger.resetear
Verificado para trabajar con:
RMN Rubí 2.2 - 2.5
JRuby 9.x
Rubinio
Las versiones de Ruby < 2.2 están en EOL y ya no son compatibles.
Depende de sus necesidades específicas, pero la mayoría de las aplicaciones deberían usar el valor predeterminado (UDP). Estas son las ventajas y desventajas de cada tipo:
UDP es más rápido que TCP porque es asíncrono (dispara y olvida). Sin embargo, esto significa que los mensajes de registro podrían eliminarse. Esto está bien para muchas aplicaciones.
TCP verifica que todos los mensajes se hayan recibido mediante comunicación bidireccional. También admite SSL para la transmisión segura de mensajes de registro a través de una red. Esto podría ralentizar su aplicación si el oyente TCP está bajo una gran carga.
Un archivo es fácil de usar, pero tendrá que preocuparse por la rotación de registros y por quedarse sin espacio en el disco.
Escribir en un socket Unix es más rápido que escribir en un puerto TCP o UDP, pero sólo funciona localmente.
Escribir en Redis es bueno para configuraciones distribuidas que generan toneladas de registros. Sin embargo, tendrá otra parte móvil y tendrá que preocuparse de que Redis se quede sin memoria.
Solo se recomienda escribir en la salida estándar para fines de depuración.
Para una discusión más detallada sobre UDP vs TCP, recomiendo leer este artículo: UDP vs TCP
Si está utilizando un dispositivo respaldado por un objeto Ruby IO (como un archivo, un socket UDP o un socket TCP), tenga en cuenta que Ruby mantiene su propio búfer interno. A pesar de que LogStashLogger almacena los mensajes en el buffer y los vacía periódicamente, Ruby puede almacenar en el buffer internamente los datos escritos en el objeto IO de forma indefinida y es posible que ni siquiera se escriban hasta que finalice el programa. Si esto le molesta o necesita ver los mensajes de registro inmediatamente, su único recurso es configurar la opción sync: true .
Probablemente su aplicación esté intentando registrar datos que no están codificados de forma válida. Cuando esto sucede, la biblioteca JSON estándar de Ruby generará una excepción. Es posible que puedas solucionar esto cambiando un codificador JSON diferente, como Oj. Utilice la gema oj_mimic_json para utilizar Oj para la generación de JSON.
Heroku recomienda instalar rails_12factor para que los registros se envíen a STDOUT. Lamentablemente, esto anula LogStashLogger, lo que impide que los registros se envíen a su destino configurado. La solución es eliminar rails_12factor de su Gemfile.
Lo más probable es que esto no sea un problema con LogStashLogger, sino más bien una gema diferente que cambia el nivel de registro de Rails.logger . Esto es especialmente probable si estás usando un servidor con subprocesos como Puma, ya que las gemas a menudo cambian el nivel de registro de Rails.logger de una manera que no es segura para subprocesos. Consulte el n.° 17 para obtener más información.
Si está utilizando salida UDP y escribiendo en un oyente logstash, lo más probable es que encuentre un error en la implementación UDP del oyente logstash. No existe ninguna solución conocida en este momento. Consulte el n.º 43 para obtener más información.
Un inconveniente conocido del uso de TCP o UDP es el límite de 65535 bytes en el tamaño total del mensaje. Para solucionar este problema, deberá truncar el mensaje configurando el tamaño máximo del mensaje:
LogStashLogger.configure hacer |config| config.max_message_size = 2000fin
Esto truncará solo el campo message del evento LogStash. Así que asegúrese de establecer el tamaño máximo de mensaje significativamente menor que 65535 bytes para dejar espacio para otros campos.
Rails 3.2, MRI Ruby < 2.2 y JRuby 1.7 ya no son compatibles, ya que han alcanzado su EOL. Si tiene una versión anterior de Ruby, necesitará usar 0.24 o inferior.
La clave del evento source se reemplazó con host para que coincida mejor con el último logstash.
El constructor (host, port, type) ha quedado obsoleto en favor de un constructor hash de opciones.
LogStash::Event utiliza el formato v1 a partir de la versión 1.2+. Si está utilizando la versión 1, deberá instalar LogStashLogger versión 0.4+. Esto no es compatible con el antiguo LogStash::Event v1.1.5, que utiliza el formato v0.
Las versiones anteriores de esta gema (<= 0.2.1) solo implementaron una conexión TCP. Las versiones más recientes (>= 0.3) también implementan UDP y lo utilizan como nuevo valor predeterminado. Tenga en cuenta que si está utilizando el constructor predeterminado y aún necesita TCP, debe agregar un argumento adicional:
# Ahora el valor predeterminado es UDP en lugar de TCPlogger = LogStashLogger.new('localhost', 5228)# Especifique explícitamente TCP en lugar de UDPlogger = LogStashLogger.new('localhost', 5228, :tcp)David mayordomo
pctj101
Gary Rennie
Nick Ethier
Arron Mabrey
Jan Schulte
kurt preston
Chris Blatchley
Felix Bechstein
Vadim Kazakov
Anil Rhemtulla
Nikita Vorobei
chico de fuego1919
Mike Gunderloy
Vitaly Gorodetsky
Courtland Caldwell
Bibek Shrestha
Alex Ianus
Craig Leer
vidrio
Bin Lan
Joao Fernandez
CoolElvis
Serguéi Pyankov
Alec Hoey
Alexey Krasnoperov
Gabriel de Oliveira
Vladislav Syabruk
matus vacula
bifurcarlo
Crea tu rama de funciones ( git checkout -b my-new-feature )
Confirme sus cambios ( git commit -am 'Add some feature' )
Empujar a la rama ( git push origin my-new-feature )
Crear nueva solicitud de extracción
