logstash logger
1.0.0
LogStashLogger estende a classe Logger do Ruby para registrar diretamente no Logstash. Ele suporta gravação em várias saídas no formato logstash JSON. Esta é uma melhoria em relação à gravação em um arquivo ou syslog, pois o Logstash pode receber os dados estruturados diretamente.
Pode gravar diretamente em um ouvinte logstash por meio de uma conexão UDP ou TCP/SSL.
Pode gravar em um arquivo, Redis, Kafka, Kinesis, Firehose, um soquete unix, syslog, stdout ou stderr.
O Logger pode receber uma mensagem de string, um hash, um LogStash::Event , um objeto ou uma string JSON como entrada.
Os eventos são preenchidos automaticamente com mensagem, carimbo de data/hora, host e gravidade.
Grava no formato logstash JSON, mas também oferece suporte a outros formatos.
Pode gravar em várias saídas.
As mensagens de log são armazenadas em buffer e reenviadas automaticamente se houver um problema de conexão.
Integra-se facilmente com Rails por meio de configuração.
Adicione esta linha ao Gemfile da sua aplicação:
gem 'logstash-logger'
E então execute:
$ bundle
Ou instale você mesmo como:
$ gem install logstash-logger
require 'logstash-logger'# O padrão é UDP em 0.0.0.0logger = LogStashLogger.new(porta: 5228)# Especifique o host e o tipo (UDP ou TCP) explicitamenteudp_logger = LogStashLogger.new(type: :udp, host: 'localhost' , porta: 5228)tcp_logger = LogStashLogger.new(tipo::tcp, host: 'localhost', porta: 5229)# Outros tipos de loggersfile_logger = LogStashLogger.new(tipo: :file, caminho: 'log/development.log', sincronização: true)unix_logger = LogStashLogger.new(tipo: :unix, caminho: '/tmp/sock')syslog_logger = LogStashLogger.new(type: :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)# Use um formatador diferentecee_logger = LogStashLogger.new(
tipo: :tcp,
host: 'logsene-receiver-syslog.sematext.com',
porta: 514,
formatador: :cee_syslog)custom_formatted_logger = LogStashLogger.new(
tipo: :redis,
formatador: MyCustomFormatter)lambda_formatted_logger = LogStashLogger.new(
digite: :stdout,
formatador: ->(severidade, hora, nome do programa, msg) { "[#{nome do programa}] #{msg}" })ruby_default_formatter_logger = LogStashLogger.new(
digite: :arquivo,
caminho: 'log/development.log',
formatador: ::Logger::Formatter)# Envia mensagens para múltiplas saídas. Cada saída terá o mesmo formato.# Syslog não pode ser uma saída porque requer um logger separado.multi_delegating_logger = LogStashLogger.new(
tipo: :multi_delegador,
saídas: [{ tipo:: arquivo, caminho: 'log/development.log' },{ tipo:: udp, host: 'localhost', porta: 5228 }
])# Equilibra mensagens entre diversas saídas.# Funciona da mesma forma que multi delegador, mas escolhe aleatoriamente uma saída para enviar cada mensagem.balancer_logger = LogStashLogger.new(
tipo:: balanceador,
saídas: [{ tipo: :udp, host: 'host1', porta: 5228 },{ tipo: :udp, host: 'host2', porta: 5228 }
])# Envie mensagens para vários registradores.# Use isto se precisar enviar formatos diferentes para saídas diferentes.# Se precisar registrar no syslog, você deve usar this.multi_logger = LogStashLogger.new(
tipo: :multi_logger,
saídas: [{ tipo:: arquivo, caminho: 'log/development.log', formatador: ::Logger::Formatter },{ tipo: :tcp, host: 'localhost', porta: 5228, formatador: :json }
])# As seguintes mensagens são gravadas na porta UDP 5228:logger.info 'test'# {"message":"test","@timestamp":"2014-05-22T09:37:19.204-07:00", "@version":"1","severity":"INFO","host":"[hostname]"}logger.error '{"message": "error"}'# {"message":"error","@timestamp":"2014-05-22T10:10:55.877-07:00","@version":"1","severity":" ERRO","host":"[hostname]"}mensagem logger.debug: 'test', foo: 'bar'# {"message":"test","foo":"bar","@timestamp":"2014-05-22T09:43:24.004-07:00","@version":"1","gravidade" :"DEBUG","host":"[hostname]"}logger.warn LogStash::Event.new(message: 'test', foo: 'bar')# {"message":"test","foo":"bar","@timestamp":"2014-05-22T16:44:37.364Z","@version":"1","severity":"AVISO ","host":"[hostname]"}# Tagged logginglogger.tagged('foo') { logger.fatal('bar') }# {"message":"bar","@timestamp":"2014-05-26T20:35:14.685-07:00","@version":"1","severity":"FATAL","host" :"[nome do host]","tags":["foo"]} Você pode usar um URI para configurar seu logstash logger em vez de um hash. Isso é útil em ambientes como o Heroku, onde você pode querer ler os valores de configuração do ambiente. O esquema de URI é type://host:port/path?key=value . Alguns exemplos de configurações de URI são fornecidos abaixo.
udp://localhost:5228 tcp://localhost:5229 unix:///tmp/socket file:///path/to/file redis://localhost:6379 kafka://localhost:9092 stdout:/ stderr:/
Passe o URI para o seu logstash logger assim:
# Leia o URI de um variávellogger de ambiente = LogStashLogger.new(uri: ENV['LOGSTASH_URI'])
Para que o logstash receba e analise corretamente os eventos, você precisará configurar e executar um ouvinte que use o codec json_lines . Por exemplo, para receber eventos por UDP na porta 5228:
entrada {
udp {host => "0.0.0.0"porta => 5228codec => json_lines
}} As entradas de arquivo e Redis devem usar o codec json . Para obter mais informações, leia a documentação do Logstash.
Consulte o diretório de amostras para obter mais amostras de configuração.
Se você estiver usando TCP, existe a opção de adicionar um certificado SSL ao hash de opções na inicialização.
LogStashLogger.new(tipo::tcp, porta: 5228, ssl_certificate: "/caminho/para/certificate.crt")
O certificado SSL e a chave podem ser gerados usando
openssl req -x509 -batch -nodes -newkey rsa:2048 -keyout logstash.key -out logstash.crt
Você também pode ativar o SSL sem certificado:
LogStashLogger.new(tipo::tcp, porta: 5228, ssl_enable: true)
Especifique um contexto SSL para ter mais controle sobre o comportamento. Por exemplo, defina o modo de verificação:
ctx = OpenSSL::SSL::SSLContext.newctx.set_params(verify_mode: OpenSSL::SSL::VERIFY_NONE)LogStashLogger.new(tipo: :tcp, porta: 5228, ssl_context: ctx)
A seguinte configuração do Logstash é necessária para SSL:
entrada {
tcp {host => "0.0.0.0"porta => 5228codec => json_linesssl_enable => truessl_cert => "/path/to/certificate.crt"ssl_key => "/path/to/key.key"
}} A verificação de nome de host está habilitada por padrão. Sem configuração adicional, o nome do host fornecido para :host será usado para verificar a identidade do certificado do servidor.
Se você não passar um :ssl_context ou passar um valor falsey para a opção :verify_hostname , a verificação do nome do host não ocorrerá.
Verifique o nome do host na opção :host
ctx = OpenSSL::SSL::SSLContext.newctx.cert = '/caminho/para/cert.pem'ctx.verify_mode = OpenSSL::SSL::VERIFY_PEERLogStashLogger.new tipo: :tcp, host: 'logstash.example.com' porta: 5228, contexto_ssl:ctx
Verifique um nome de host diferente da opção :host
LogStashLogger.novo tipo: :tcp, anfitrião: '1.2.3.4' porta: 5228, ssl_context:ctx, verificar_hostname: 'servidor.exemplo.com'
Desabilitar explicitamente a verificação de nome de host
LogStashLogger.novo tipo: :tcp, anfitrião: '1.2.3.4' porta: 5228, ssl_context:ctx, verificar_hostname: falso
LogStashLogger por padrão registrará um objeto JSON com o formato abaixo.
{ "message":"Alguma mensagem", "@timestamp":"2015-01-29T10:43:32.196-05:00", "@version":"1", "severity":"INFO", "host ":"nome do host"} Alguns aplicativos podem precisar anexar metadados adicionais a cada mensagem. O LogStash::Event pode ser manipulado diretamente especificando um bloco customize_event na configuração LogStashLogger .
config = LogStashLogger.configure do |config| config.customize_event do |event|event["other_field"] = "some_other_value" fim
Essa configuração resultaria na seguinte saída.
{"message": "Alguma mensagem","@timestamp": "2015-01-29T10:43:32.196-05:00","@version": "1","severity": "INFO","host ": "nome do host","other_field": "some_other_value"}Este bloco tem acesso total ao evento, então você pode remover campos, modificar campos existentes, etc. Por exemplo, para remover o carimbo de data/hora padrão:
config = LogStashLogger.configure do |config| config.customize_event do |event|event.remove('@timestamp')
fim Você também pode personalizar eventos por logger, passando um objeto que pode ser chamado (lambda ou proc) para a opção customize_event ao criar um logger:
LogStashLogger.new(customize_event: ->(evento){ evento['other_field'] = 'other_field' })Para dispositivos que estabelecem uma conexão com um serviço remoto, as mensagens de log são armazenadas em buffer internamente e liberadas em um thread em segundo plano. Se houver um problema de conexão, as mensagens serão retidas no buffer e reenviadas automaticamente até que seja bem-sucedido. As saídas que suportam gravação em lote (Redis e Kafka) gravarão mensagens de log em massa do buffer. Esta funcionalidade é implementada usando um fork do Stud::Buffer. Você pode configurar seu comportamento passando as seguintes opções para LogStashLogger:
:buffer_max_items - Número máximo de itens para armazenar em buffer antes da liberação. O padrão é 50.
:buffer_max_interval - Número máximo de segundos de espera entre liberações. O padrão é 5.
:drop_messages_on_flush_error - Descarta mensagens quando há um erro de liberação. O padrão é falso.
:drop_messages_on_full_buffer - Elimina mensagens quando o buffer está cheio. O padrão é verdadeiro.
:sync - Libera o buffer toda vez que uma mensagem é recebida (bloqueio). O padrão é falso.
:buffer_flush_at_exit - Libera mensagens ao sair do programa. O padrão é verdadeiro.
:buffer_logger - Registrador para gravar mensagens de depuração/erro do buffer. O padrão é nenhum.
Você pode desativar o buffer definindo sync = true .
Esteja ciente das seguintes advertências sobre esse comportamento:
É possível que mensagens de log duplicadas sejam enviadas ao tentar novamente. Para saídas como Redis e Kafka que gravam em lotes, todo o lote pode ser reenviado. Se isso for um problema, você poderá adicionar um campo UUID a cada evento para identificá-lo exclusivamente. Você pode fazer isso em um bloco customize_event ou usando o filtro UUID do logstash.
Ainda é possível perder mensagens de log. Ruby não detectará um problema de conexão TCP/UDP imediatamente. Em meus testes, Ruby levou cerca de 4 segundos para perceber que o terminal receptor estava inativo e começar a gerar exceções. Como os ouvintes do logstash sobre TCP/UDP não reconhecem as mensagens recebidas, não é possível saber quais mensagens de log reenviar.
Quando sync está desativada, Ruby pode armazenar dados em buffer internamente antes de gravar no dispositivo IO. É por isso que você pode não ver mensagens gravadas imediatamente em um soquete UDP ou TCP, mesmo que o buffer do LogStashLogger seja liberado periodicamente.
Por padrão, as mensagens são descartadas quando o buffer fica cheio. Isso pode acontecer se a fonte de saída ficar inativa por muito tempo ou se as mensagens de log estiverem sendo recebidas muito rapidamente. Se o seu aplicativo for encerrado repentinamente (por exemplo, por SIGKILL ou queda de energia), todo o buffer será perdido.
Você pode diminuir a probabilidade de perda de mensagens aumentando buffer_max_items (para que mais eventos possam ser mantidos no buffer) e diminuindo buffer_max_interval (para esperar menos tempo entre liberações). Isso aumentará a pressão de memória em seu aplicativo à medida que as mensagens de log se acumulam no buffer, portanto, certifique-se de ter alocado memória suficiente para seu processo.
Se você não quiser perder mensagens quando o buffer ficar cheio, você pode definir drop_messages_on_full_buffer = false . Observe que se o buffer ficar cheio, qualquer mensagem de log recebida será bloqueada, o que pode ser indesejável.
Todas as saídas do registrador suportam uma configuração sync . Isso é análogo à configuração "modo de sincronização" em objetos Ruby IO. Quando definido como true , a saída é liberada imediatamente e não é armazenada em buffer internamente. Normalmente, para dispositivos que se conectam a um serviço remoto, o buffer é bom porque melhora o desempenho e reduz a probabilidade de erros que afetam o programa. Para esses dispositivos, o padrão sync é false e é recomendável deixar o valor padrão. Você pode querer ativar o modo de sincronização para testes, por exemplo, se quiser ver as mensagens de log imediatamente após serem gravadas.
É recomendado ativar o modo de sincronização para saídas de arquivos e soquetes Unix. Isso garante que as mensagens de log de diferentes threads ou processos sejam gravadas corretamente em linhas separadas.
Consulte o nº 44 para obter mais detalhes.
Se ocorrer uma exceção durante a gravação de uma mensagem no dispositivo, a exceção será registrada usando um registrador interno. Por padrão, isso é registrado em $stderr. Você pode alterar o criador de logs de erros definindo LogStashLogger.configuration.default_error_logger ou passando seu próprio objeto de criador de logs na chave de configuração :error_logger ao instanciar um LogStashLogger.
LogStashLogger fornece suporte para silenciamento de logger estilo Rails. A implementação foi extraída do Rails, mas não possui dependências, portanto pode ser usada fora de uma aplicação Rails. A interface é a mesma do Rails:
logger.silence(nível_temporário) faça ...fim
Por padrão, LogStashLogger cria um logger que estende a classe Logger integrada do Ruby. Se você precisar de uma implementação de criador de logs diferente, poderá usar uma classe diferente passando a classe com a opção logger_class .
Observe que para syslog, a classe Syslog::Logger é necessária e não pode ser alterada.
Suporta Rails 4.2 e 5.x.
Por padrão, cada mensagem de log do Rails será gravada no logstash no formato LogStash::Event JSON.
Para eventos logstash mínimos e mais estruturados, experimente uma das seguintes gemas:
logragem
jardineiro
Atualmente, essas gemas geram uma string JSON, que o LogStashLogger analisa. Versões futuras dessas gems poderiam potencialmente ter uma integração mais profunda com LogStashLogger (por exemplo, escrevendo diretamente objetos LogStash::Event ).
Adicione o seguinte ao seu config/environments/production.rb :
# Opcional, o Rails define o padrão como :infoconfig.log_level = :debug# Opcional, o Rails 4 assume como padrão true no desenvolvimento e false em productionconfig.autoflush_log = true# Opcional, use um URI para configurar. Útil em Herokuconfig.logstash.uri = ENV['LOGSTASH_URI']# Opcional. O padrão é: json_lines. Se houver múltiplas saídas,# todas elas compartilharão o mesmo formatador.config.logstash.formatter = :json_lines# Opcional, o logger no qual registrar erros de gravação. O padrão é registrar em $stderrconfig.logstash.error_logger = Logger.new($stderr)# Opcional, número máximo de itens para buffer antes da liberação. O padrão é 50config.logstash.buffer_max_items = 50# Opcional, número máximo de segundos para esperar entre liberações. O padrão é 5config.logstash.buffer_max_interval = 5# Opcional, descarte a mensagem quando ocorrer um erro de conexão. O padrão é falseconfig.logstash.drop_messages_on_flush_error = false# Opcional, descarte mensagens quando o buffer estiver cheio. O padrão é trueconfig.logstash.drop_messages_on_full_buffer = true
# Opcional, o padrão é '0.0.0.0'config.logstash.host = 'localhost'# Opcional, o padrão é :udp.config.logstash.type = :udp# Obrigatório, a porta para conectar toconfig.logstash.port = 5228
# Opcional, o padrão é '0.0.0.0'config.logstash.host = 'localhost'# Obrigatório, a porta para conectar toconfig.logstash.port = 5228# Requiredconfig.logstash.type = :tcp# Opcional, habilita SSLconfig.logstash. ssl_enable = verdadeiro
# Requiredconfig.logstash.type = :unix# Requiredconfig.logstash.path = '/tmp/sock'
Se você estiver no Ruby 1.9, adicione Syslog::Logger v2 ao seu Gemfile:
gem 'SyslogLogger', '2.0'
Se você estiver em Ruby 2+, Syslog::Logger já está incorporado na biblioteca padrão.
# Obrigatórioconfig.logstash.type = :syslog# Opcional. O padrão é 'ruby'config.logstash.program_name = 'MyApp'# Nível de recurso padrão opcional. Só funciona em Ruby 2+config.logstash.facility = Syslog::LOG_LOCAL0
Adicione a gema redis ao seu Gemfile:
gem 'redis'
# Requiredconfig.logstash.type = :redis# Opcional, o padrão será 'logstash' listconfig.logstash.list = 'logstash'# Todas as outras opções são passadas para o cliente Redis# As opções suportadas incluem host, porta, caminho, senha , url# Exemplo:# Opcional, o Redis usará como padrão localhostconfig.logstash.host = 'localhost'# Opcional, o Redis usará como padrão a porta 6379config.logstash.port = 6379
Adicione a gema poseidon ao seu Gemfile:
gem 'poseidon'
# Requiredconfig.logstash.type = :kafka# Opcional, o padrão será 'logstash' topicconfig.logstash.path = 'logstash'# Opcional, o padrão será 'logstash-logger' Producerconfig.logstash.producer = 'logstash-logger '# Opcional, o padrão será localhost:9092 host/portconfig.logstash.hosts = ['localhost:9092']# Opcional, o padrão será 1s backoffconfig.logstash.backoff = 1
Adicione a gema aws-sdk ao seu Gemfile:
# aws-sdk >= 3.0 gem 'aws-sdk-kinesis' # aws-sdk < 3.0 gem 'aws-sdk'
# Requiredconfig.logstash.type = :kinesis# Opcional, o padrão será 'logstash' streamconfig.logstash.stream = 'my-stream-name'# Opcional, o padrão será 'us-east-1'config.logstash.aws_region = 'us-west-2'# Opcional, o padrão será a variável de ambiente AWS_ACCESS_KEY_IDconfig.logstash.aws_access_key_id = 'ASKASKHLD12341'# Opcional, o padrão será a variável de ambiente AWS_SECRET_ACCESS_KEYconfig.logstash.aws_secret_access_key = 'ASKASKHLD1234123412341234'
Adicione a gema aws-sdk ao seu Gemfile:
# aws-sdk >= 3.0 gem 'aws-sdk-firehose' # aws-sdk < 3.0 gem 'aws-sdk'
# Requiredconfig.logstash.type = :firehose# Opcional, o padrão será a entrega 'logstash' streamconfig.logstash.stream = 'my-stream-name'# Opcional, o padrão será a configuração da região padrão da AWS chainconfig.logstash.aws_region = ' us-west-2'# Opcional, o padrão será o provedor de credenciais padrão da AWS chainconfig.logstash.aws_access_key_id = 'ASKASKHLD12341'# Opcional, o padrão será o provedor de credenciais padrão da AWS chainconfig.logstash.aws_secret_access_key = 'ASKASKHLD1234123412341234'
# Requiredconfig.logstash.type = :file# Opcional, o padrão é Rails log pathconfig.logstash.path = 'log/production.log'
# Requiredconfig.logstash.type = :io# Requiredconfig.logstash.io = io
# Requiredconfig.logstash.type = :multi_delegator# Requiredconfig.logstash.outputs = [
{tipo:: arquivo, caminho: 'log/produção.log'
},
{tipo::udp,porta: 5228,host: 'localhost'
}] # Obrigatórioconfig.logstash.type = :multi_logger# Obrigatório. Cada criador de logs pode ter seu próprio formatador.config.logstash.outputs = [
{tipo: :arquivo,caminho: 'log/produção.log',formatter: ::Logger::Formatter
},
{tipo::udp,porta: 5228,host: 'localhost'
}]Em aplicativos da web, você pode registrar dados de solicitações HTTP (como cabeçalhos) usando o middleware RequestStore. O exemplo a seguir assume Rails.
# em Gemfilegem 'request_store'
# em application.rbLogStashLogger.configure faça |config| config.customize_event do |event|event["session_id"] = RequestStore.store[:load_balancer_session_id] fim
# em 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
Se seu aplicativo for bifurcado (como é comum em muitos servidores web), você precisará gerenciar a limpeza de recursos em suas instâncias do LogStashLogger. O método de instância #reset está disponível para esta finalidade. Aqui está um exemplo de configuração para vários servidores web comuns usados com Rails:
Passageiro:
::PhusionPassenger.on_event(:starting_worker_process) do |forked| Rails.logger.resetend
Puma:
# Em config/puma.rbon_worker_boot faça Rails.logger.resetend
Unicórnio
# Em config/unicorn.rbafter_fork faça |server, trabalhador| Rails.logger.resetend
Verificado para trabalhar com:
Ressonância magnética Ruby 2.2 - 2.5
JRuby 9.x
Rubínio
Versões Ruby <2.2 são EOL e não são mais suportadas.
Depende das suas necessidades específicas, mas a maioria dos aplicativos deve usar o padrão (UDP). Aqui estão as vantagens e desvantagens de cada tipo:
O UDP é mais rápido que o TCP porque é assíncrono (dispare e esqueça). No entanto, isso significa que as mensagens de log podem ser descartadas. Isso é adequado para muitas aplicações.
O TCP verifica se cada mensagem foi recebida por meio de comunicação bidirecional. Ele também oferece suporte a SSL para transmissão segura de mensagens de log em uma rede. Isso pode tornar seu aplicativo lento se o ouvinte TCP estiver sob carga pesada.
Um arquivo é simples de usar, mas você terá que se preocupar com a rotação do log e com a falta de espaço em disco.
Escrever em um soquete Unix é mais rápido do que escrever em uma porta TCP ou UDP, mas só funciona localmente.
Escrever no Redis é bom para configurações distribuídas que geram muitos logs. No entanto, você terá outra parte móvel e terá que se preocupar com a falta de memória do Redis.
Escrever em stdout é recomendado apenas para fins de depuração.
Para uma discussão mais detalhada sobre UDP vs. TCP, recomendo a leitura deste artigo: UDP vs.
Se você estiver usando um dispositivo suportado por um objeto Ruby IO (como um arquivo, soquete UDP ou soquete TCP), esteja ciente de que Ruby mantém seu próprio buffer interno. Apesar do LogStashLogger armazenar mensagens em buffer e liberá-las periodicamente, os dados gravados no objeto IO podem ser armazenados em buffer internamente pelo Ruby indefinidamente e podem nem mesmo ser gravados até que o programa termine. Se isso incomoda você ou você precisa ver as mensagens de log imediatamente, seu único recurso é definir a opção sync: true .
Seu aplicativo provavelmente está tentando registrar dados que não estão codificados de maneira válida. Quando isso acontecer, a biblioteca JSON padrão do Ruby gerará uma exceção. Você pode superar isso trocando um codificador JSON diferente, como Oj. Use a gema oj_mimic_json para usar Oj para geração de JSON.
Heroku recomenda instalar o rails_12factor para que os logs sejam enviados para STDOUT. Infelizmente, isso substitui o LogStashLogger, evitando que os logs sejam enviados ao destino configurado. A solução é remover rails_12factor do seu Gemfile.
Provavelmente, isso não é um problema com LogStashLogger, mas sim uma jóia diferente alterando o nível de log de Rails.logger . Isso é especialmente provável se você estiver usando um servidor threaded como o Puma, já que as gems geralmente alteram o nível de log do Rails.logger de uma maneira não segura para threads. Consulte o nº 17 para obter mais informações.
Se você estiver usando a saída UDP e gravando em um ouvinte logstash, provavelmente encontrará um bug na implementação UDP do ouvinte logstash. Não há nenhuma solução conhecida no momento. Consulte o nº 43 para obter mais informações.
Uma desvantagem conhecida do uso de TCP ou UDP é o limite de 65.535 bytes no tamanho total da mensagem. Para solucionar esse problema, você terá que truncar a mensagem definindo o tamanho máximo da mensagem:
LogStashLogger.configure do |config| config.max_message_size=2000fim
Isso truncará apenas o campo message do Evento LogStash. Portanto, certifique-se de definir o tamanho máximo da mensagem significativamente menor que 65.535 bytes para liberar espaço para outros campos.
Rails 3.2, MRI Ruby <2.2 e JRuby 1.7 não são mais suportados, pois foram EOL. Se você estiver em uma versão mais antiga do Ruby, precisará usar 0.24 ou inferior.
A chave do evento source foi substituída pelo host para corresponder melhor ao logstash mais recente.
O construtor (host, port, type) foi descontinuado em favor de um construtor de hash de opções.
LogStash::Event usa o formato v1 a partir da versão 1.2+. Se estiver usando a v1, você precisará instalar o LogStashLogger versão 0.4+. Isso não é compatível com versões anteriores do antigo LogStash::Event v1.1.5, que usa o formato v0.
Versões anteriores desta gem (<= 0.2.1) implementavam apenas uma conexão TCP. Versões mais recentes (>= 0,3) também implementam UDP e usam-no como o novo padrão. Esteja ciente de que se você estiver usando o construtor padrão e ainda precisar de TCP, você deve adicionar um argumento adicional:
# Agora o padrão é UDP em vez de TCPlogger = LogStashLogger.new('localhost', 5228)# Especifique explicitamente TCP em vez de UDPlogger = LogStashLogger.new('localhost', 5228, :tcp)David Butler
pctj101
Gary Rennie
Nick Ethier
Arron Mabrey
Jan Schulte
Kurt Preston
Chris Blatchley
Félix Bechstein
Vadim Kazakov
Anil Rhemtulla
Nikita Vorobei
bombeiro1919
Mike Gunderloy
Vitaly Gorodetsky
Courtland Caldwell
Bibek Shrestha
Alex Ianus
Craig leu
vidro
Bin Lan
João Fernandes
LegalElvis
Sergei Pyankov
Alec Hoey
Alexei Krasnoperov
Gabriel de Oliveira
Vladislav Syabruk
Matus Vácula
Garfo
Crie sua ramificação de recursos ( git checkout -b my-new-feature )
Confirme suas alterações ( git commit -am 'Add some feature' )
Empurre para o branch ( git push origin my-new-feature )
Criar nova solicitação pull
