logstash logger
1.0.0
LogStashLogger étend la classe Logger de Ruby pour se connecter directement à Logstash. Il prend en charge l'écriture sur diverses sorties au format logstash JSON. Il s'agit d'une amélioration par rapport à l'écriture dans un fichier ou un syslog puisque Logstash peut recevoir directement les données structurées.
Peut écrire directement sur un écouteur logstash via une connexion UDP ou TCP/SSL.
Peut écrire dans un fichier, Redis, Kafka, Kinesis, Firehose, un socket Unix, syslog, stdout ou stderr.
Logger peut prendre un message de chaîne, un hachage, un LogStash::Event , un objet ou une chaîne JSON en entrée.
Les événements sont automatiquement renseignés avec le message, l'horodatage, l'hôte et la gravité.
Écrit au format logstash JSON, mais prend également en charge d'autres formats.
Peut écrire sur plusieurs sorties.
Les messages du journal sont mis en mémoire tampon et automatiquement renvoyés en cas de problème de connexion.
S'intègre facilement à Rails via la configuration.
Ajoutez cette ligne au Gemfile de votre application :
gem 'logstash-logger'
Et puis exécutez :
$ bundle
Ou installez-le vous-même en tant que :
$ gem install logstash-logger
require 'logstash-logger'# La valeur par défaut est UDP sur 0.0.0.0logger = LogStashLogger.new(port : 5228)# Spécifiez explicitement l'hôte et le type (UDP ou TCP)udp_logger = LogStashLogger.new(type : :udp, host : 'localhost' , port : 5228)tcp_logger = LogStashLogger.new(type : :tcp, hôte : 'localhost', port : 5229)# Autres types de loggersfile_logger = LogStashLogger.new(type : :file, chemin : 'log/development.log', sync : true)unix_logger = LogStashLogger.new(type : :unix, chemin : '/tmp/sock')syslog_logger = LogStashLogger.new(type : :syslog)redis_logger = LogStashLogger.new(type : :redis)kafka_logger = LogStashLogger.new(type : :kafka)stdout_logger = LogStashLogger.new(type : :stdout)stderr_logger = LogStashLogger.new(type : :stderr)io_logger = LogStashLogger.new(type : :io, io: io)# Utiliser un autre formattercee_logger = LogStashLogger.new(
tapez : tcp,
hôte : 'logsene-receiver-syslog.sematext.com',
port : 514,
formateur : cee_syslog)custom_formatted_logger = LogStashLogger.new(
tapez : redis,
formateur : MyCustomFormatter)lambda_formatted_logger = LogStashLogger.new(
tapez : stdout,
formateur : ->(gravité, heure, nom du programme, msg) { "[#{nom du programme}] #{msg}" })ruby_default_formatter_logger = LogStashLogger.new(
tapez : fichier,
chemin : 'log/development.log',
formateur : :Logger::Formatter)# Envoyer des messages à plusieurs sorties. Chaque sortie aura le même format.# Syslog ne peut pas être une sortie car il nécessite un logger distinct.multi_delegating_logger = LogStashLogger.new(
tapez : multi_delegator,
sorties : [{ type : :file, chemin : 'log/development.log' },{ type : udp, hôte : 'localhost', port : 5228 }
])# Équilibre les messages entre plusieurs sorties.# Fonctionne de la même manière que multi-délégué, mais choisit au hasard une sortie pour envoyer chaque message.balancer_logger = LogStashLogger.new(
tapez: :équilibreur,
sorties : [{ type : :udp, hôte : 'host1', port : 5228 },{ type : :udp, hôte : 'host2', port : 5228 }
])# Envoyer des messages à plusieurs enregistreurs.# Utilisez ceci si vous devez envoyer différents formats à différentes sorties.# Si vous devez vous connecter à syslog, vous devez utiliser this.multi_logger = LogStashLogger.new(
tapez : multi_logger,
sorties : [{ type : :file, chemin : 'log/development.log', formateur : ::Logger::Formatter },{ type : :tcp, hôte : 'localhost', port : 5228, formateur : :json }
])# Les messages suivants sont écrits sur le port UDP 5228 :logger.info 'test'# {"message":"test","@timestamp":"2014-05-22T09:37:19.204-07:00", "@version": "1", "severity": "INFO", "hôte": "[nom d'hôte]"}logger.error '{"message": "erreur"}'# {"message": "erreur", @timestamp "2014-05-22T10: 10: 55.877-07:00", "@version": "1", "gravité": "erreur", "hôte" :"[nom d'hôte]"}message logger.debug : 'test', foo : 'bar'# {"message": "test", "foo": "bar", "@timestamp": "2014-05-22T09:43:24.004-07:00", "@version": "1", "gravité" :"DEBUG","host":"[nom d'hôte]"}logger.warn LogStash::Event.new(message : 'test', foo : 'bar')# {"message": "test", "foo": "bar", "@timestamp": "2014-05-22T16:44:37.364Z", "@version": "1", "severity": "WARN ","host":"[nom d'hôte]"}# Tagged logginglogger.tagged('foo') { logger.fatal('bar') }# {"message": "bar", "@timestamp": "2014-05-26T20: 35: 14.685-07:00", "@version": "1", "severity": "FATAL", "hôte" :"[nom d'hôte]","tags":["foo"]} Vous pouvez utiliser un URI pour configurer votre enregistreur logstash au lieu d'un hachage. Ceci est utile dans des environnements tels que Heroku où vous souhaiterez peut-être lire les valeurs de configuration de l'environnement. Le schéma d'URI est type://host:port/path?key=value . Quelques exemples de configurations d'URI sont donnés ci-dessous.
udp://localhost:5228 tcp://localhost:5229 unix:///tmp/socket file:///path/to/file redis://localhost:6379 kafka://localhost:9092 stdout:/ stderr:/
Transmettez l'URI dans votre enregistreur logstash comme ceci :
# Lire l'URI depuis une variable d'environnementlogger = LogStashLogger.new(uri: ENV['LOGSTASH_URI'])
Pour que logstash reçoive et analyse correctement les événements, vous devrez configurer et exécuter un écouteur qui utilise le codec json_lines . Par exemple, pour recevoir des événements via UDP sur le port 5228 :
saisir {
udp {hôte => "0.0.0.0" port => 5228codec => json_lines
}} Les entrées File et Redis doivent plutôt utiliser le codec json . Pour plus d'informations, lisez la documentation Logstash.
Consultez le répertoire des exemples pour plus d’exemples de configuration.
Si vous utilisez TCP, vous avez la possibilité d'ajouter un certificat SSL au hachage des options lors de l'initialisation.
LogStashLogger.new(type : :tcp, port : 5228, ssl_certificate : "/path/to/certificate.crt")
Le certificat SSL et la clé peuvent être générés à l'aide de
openssl req -x509 -batch -nodes -newkey rsa:2048 -keyout logstash.key -out logstash.crt
Vous pouvez également activer SSL sans certificat :
LogStashLogger.new (type : :tcp, port : 5228, ssl_enable : true)
Spécifiez un contexte SSL pour avoir plus de contrôle sur le comportement. Par exemple, définissez le mode de vérification :
ctx = OpenSSL :: SSL :: SSLContext.newctx.set_params (verify_mode : OpenSSL :: SSL :: VERIFY_NONE) LogStashLogger.new (type : : tcp, port : 5228, ssl_context : ctx)
La configuration Logstash suivante est requise pour SSL :
saisir {
tcp {hôte => "0.0.0.0"port => 5228codec => json_linesssl_enable => truessl_cert => "/path/to/certificate.crt"ssl_key => "/path/to/key.key"
}} La vérification du nom d'hôte est activée par défaut. Sans autre configuration, le nom d'hôte fourni à :host sera utilisé pour vérifier l'identité du certificat du serveur.
Si vous ne transmettez pas de :ssl_context ou ne transmettez pas une valeur falsey à l'option :verify_hostname , la vérification du nom d'hôte n'aura pas lieu.
Vérifiez le nom d'hôte à partir de l'option :host
ctx = OpenSSL :: SSL :: SSLContext.newctx.cert = '/path/to/cert.pem'ctx.verify_mode = OpenSSL :: SSL :: VERIFY_PEERLogStashLogger.new tapez : tcp, hôte : 'logstash.example.com' port : 5228, ssl_context : ctx
Vérifiez un nom d'hôte différent de l'option :host
LogStashLogger.new tapez : tcp, hôte : '1.2.3.4' port : 5228, ssl_context : ctx, verify_hostname : 'server.example.com'
Désactiver explicitement la vérification du nom d'hôte
LogStashLogger.new tapez : tcp, hôte : '1.2.3.4' port : 5228, ssl_context : ctx, verify_hostname : false
LogStashLogger enregistrera par défaut un objet JSON avec le format ci-dessous.
{ "message": "Un message", "@timestamp": "2015-01-29T10:43:32.196-05:00", "@version": "1", "gravité": "INFO", "hôte ":"nom d'hôte"} Certaines applications peuvent devoir joindre des métadonnées supplémentaires à chaque message. Le LogStash::Event peut être manipulé directement en spécifiant un bloc customize_event dans la configuration LogStashLogger .
config = LogStashLogger.configure faire |config| config.customize_event do |event|event["other_field"] = "some_other_value" fin
Cette configuration donnerait le résultat suivant.
{"message": "Un message", @timestamp": "2015-01-29T10:43:32.196-05:00", "@version": "1", "severity": "INFO", "hôte" ": "nom d'hôte","other_field": "some_other_value"}Ce bloc a un accès complet à l'événement, vous pouvez donc supprimer des champs, modifier des champs existants, etc. Par exemple, pour supprimer l'horodatage par défaut :
config = LogStashLogger.configure faire |config| config.customize_event faire |event|event.remove('@timestamp')
fin Vous pouvez également personnaliser les événements pour chaque enregistreur en passant un objet appelable (lambda ou proc) à l'option customize_event lors de la création d'un enregistreur :
LogStashLogger.new(customize_event : ->(event){ event['other_field'] = 'other_field' })Pour les appareils qui établissent une connexion à un service distant, les messages de journal sont mis en mémoire tampon en interne et vidés dans un thread d'arrière-plan. En cas de problème de connexion, les messages sont conservés dans le tampon et automatiquement renvoyés jusqu'à ce que l'opération réussisse. Les sorties prenant en charge l'écriture par lots (Redis et Kafka) écriront les messages de journal en masse à partir du tampon. Cette fonctionnalité est implémentée à l'aide d'un fork de Stud::Buffer. Vous pouvez configurer son comportement en passant les options suivantes à LogStashLogger :
:buffer_max_items - Nombre maximum d'éléments à mettre en mémoire tampon avant le vidage. La valeur par défaut est 50.
:buffer_max_interval - Nombre maximum de secondes à attendre entre les vidages. La valeur par défaut est 5.
:drop_messages_on_flush_error - Supprime les messages en cas d'erreur de vidage. La valeur par défaut est false.
:drop_messages_on_full_buffer - Supprime les messages lorsque le tampon est plein. La valeur par défaut est vrai.
:sync - Vider le tampon à chaque fois qu'un message est reçu (blocage). La valeur par défaut est false.
:buffer_flush_at_exit - Vide les messages lors de la sortie du programme. La valeur par défaut est vrai.
:buffer_logger - Enregistreur dans lequel écrire les messages de débogage/erreur du tampon. La valeur par défaut est Aucun.
Vous pouvez désactiver la mise en mémoire tampon en définissant sync = true .
Veuillez tenir compte des mises en garde suivantes concernant ce comportement :
Il est possible que des messages de journal en double soient envoyés lors d'une nouvelle tentative. Pour les sorties comme Redis et Kafka qui écrivent par lots, l'intégralité du lot peut être renvoyée. Si cela pose un problème, vous pouvez ajouter un champ UUID à chaque événement pour l'identifier de manière unique. Vous pouvez le faire soit dans un bloc customize_event , soit en utilisant le filtre UUID de logstash.
Il est toujours possible de perdre les messages du journal. Ruby ne détectera pas immédiatement un problème de connexion TCP/UDP. Lors de mes tests, il a fallu environ 4 secondes à Ruby pour remarquer que le récepteur était en panne et commencer à déclencher des exceptions. Étant donné que les écouteurs Logstash sur TCP/UDP n'accusent pas réception des messages reçus, il n'est pas possible de savoir quels messages de journal renvoyer.
Lorsque sync est désactivée, Ruby peut mettre les données en mémoire tampon en interne avant d'écrire sur le périphérique IO. C'est pourquoi vous ne verrez peut-être pas les messages écrits immédiatement sur un socket UDP ou TCP, même si le tampon de LogStashLogger est périodiquement vidé.
Par défaut, les messages sont supprimés lorsque le tampon est plein. Cela peut se produire si la source de sortie est indisponible pendant trop longtemps ou si les messages de journal sont reçus trop rapidement. Si votre application se termine soudainement (par exemple, par SIGKILL ou une panne de courant), l'intégralité du tampon sera perdue.
Vous pouvez rendre la perte de message moins probable en augmentant buffer_max_items (afin que davantage d'événements puissent être conservés dans le tampon) et en diminuant buffer_max_interval (pour attendre moins de temps entre les vidages). Cela augmentera la pression mémoire sur votre application à mesure que les messages de journal s'accumulent dans le tampon, alors assurez-vous d'avoir alloué suffisamment de mémoire à votre processus.
Si vous ne voulez pas perdre de messages lorsque le tampon est plein, vous pouvez définir drop_messages_on_full_buffer = false . Notez que si le tampon est plein, tout message de journal entrant sera bloqué, ce qui pourrait être indésirable.
Toutes les sorties de l'enregistreur prennent en charge un paramètre sync . Ceci est analogue au paramètre « mode de synchronisation » sur les objets Ruby IO. Lorsqu'elle est définie sur true , la sortie est immédiatement vidée et n'est pas mise en mémoire tampon en interne. Normalement, pour les appareils qui se connectent à un service distant, la mise en mémoire tampon est une bonne chose car elle améliore les performances et réduit le risque d'erreurs affectant le programme. Pour ces appareils, sync est par défaut false et il est recommandé de laisser la valeur par défaut. Vous souhaiterez peut-être activer le mode de synchronisation à des fins de test, par exemple si vous souhaitez voir les messages du journal immédiatement après leur écriture.
Il est recommandé d'activer le mode de synchronisation pour les sorties de fichiers et de socket Unix. Cela garantit que les messages de journal provenant de différents threads ou processus sont écrits correctement sur des lignes distinctes.
Voir #44 pour plus de détails.
Si une exception se produit lors de l'écriture d'un message sur le périphérique, l'exception est enregistrée à l'aide d'un enregistreur interne. Par défaut, cela se connecte à $stderr. Vous pouvez modifier l'enregistreur d'erreurs en définissant LogStashLogger.configuration.default_error_logger , ou en transmettant votre propre objet enregistreur dans la clé de configuration :error_logger lors de l'instanciation d'un LogStashLogger.
LogStashLogger prend en charge la mise sous silence des enregistreurs de style Rails. L'implémentation a été extraite de Rails, mais n'a aucune dépendance, elle peut donc être utilisée en dehors d'une application Rails. L'interface est la même que dans Rails :
logger.silence (temporary_level) faire ...fin
Par défaut, LogStashLogger crée un enregistreur qui étend la classe Logger intégrée à Ruby. Si vous avez besoin d'une implémentation différente de l'enregistreur, vous pouvez utiliser une classe différente en transmettant la classe avec l'option logger_class .
Notez que pour syslog, la classe Syslog::Logger est requise et ne peut pas être modifiée.
Prend en charge Rails 4.2 et 5.x.
Par défaut, chaque message du journal Rails sera écrit dans logstash au format LogStash::Event JSON.
Pour des événements logstash minimaux et plus structurés, essayez l'une des gemmes suivantes :
journalisation
jardinier
Actuellement, ces gemmes génèrent une chaîne JSON, que LogStashLogger analyse ensuite. Les futures versions de ces gemmes pourraient potentiellement avoir une intégration plus profonde avec LogStashLogger (par exemple en écrivant directement des objets LogStash::Event ).
Ajoutez ce qui suit à votre config/environments/production.rb :
# Facultatif, Rails définit la valeur par défaut sur :infoconfig.log_level = :debug# Facultatif, Rails 4 par défaut est true en développement et false en productionconfig.autoflush_log = true# Facultatif, utilisez un URI pour configurer. Utile sur Herokuconfig.logstash.uri = ENV['LOGSTASH_URI']# Facultatif. La valeur par défaut est :json_lines. S'il y a plusieurs sorties,# elles partageront toutes la même formatter.config.logstash.formatter = :json_lines# Facultatif, l'enregistreur dans lequel enregistrer les erreurs d'écriture. Par défaut, la journalisation est $stderrconfig.logstash.error_logger = Logger.new($stderr)# Facultatif, nombre maximum d'éléments à mettre en mémoire tampon avant le vidage. La valeur par défaut est 50config.logstash.buffer_max_items = 50# Facultatif, nombre maximum de secondes à attendre entre les vidages. La valeur par défaut est 5config.logstash.buffer_max_interval = 5# Facultatif, supprimez le message lorsqu'une erreur de connexion se produit. La valeur par défaut est falseconfig.logstash.drop_messages_on_flush_error = false# Facultatif, supprime les messages lorsque le tampon est plein. La valeur par défaut est trueconfig.logstash.drop_messages_on_full_buffer = true
# Facultatif, par défaut '0.0.0.0'config.logstash.host = 'localhost'# Facultatif, par défaut :udp.config.logstash.type = :udp# Obligatoire, le port auquel se connecter àconfig.logstash.port = 5228
# Facultatif, par défaut '0.0.0.0'config.logstash.host = 'localhost'# Obligatoire, le port auquel se connecter àconfig.logstash.port = 5228# Requiredconfig.logstash.type = :tcp# Facultatif, active SSLconfig.logstash. ssl_enable = vrai
# Requiredconfig.logstash.type = :unix# Requiredconfig.logstash.path = '/tmp/sock'
Si vous utilisez Ruby 1.9, ajoutez Syslog::Logger v2 à votre Gemfile :
gem 'SyslogLogger', '2.0'
Si vous utilisez Ruby 2+, Syslog::Logger est déjà intégré à la bibliothèque standard.
# Requiredconfig.logstash.type = :syslog# Facultatif. La valeur par défaut est 'ruby'config.logstash.program_name = 'MyApp'# Niveau d'installation par défaut facultatif. Fonctionne uniquement dans Ruby 2+config.logstash.facility = Syslog::LOG_LOCAL0
Ajoutez la gemme Redis à votre Gemfile :
gem 'redis'
# Requiredconfig.logstash.type = :redis# Facultatif, sera par défaut le 'logstash' listconfig.logstash.list = 'logstash'# Toutes les autres options sont transmises au client Redis# Les options prises en charge incluent l'hôte, le port, le chemin, le mot de passe , url# Exemple :# Facultatif, Redis sera par défaut localhostconfig.logstash.host = 'localhost'# Facultatif, Redis sera par défaut le port 6379config.logstash.port = 6379
Ajoutez la gemme Poséidon à votre Gemfile :
gem 'poseidon'
# Requiredconfig.logstash.type = :kafka# Facultatif, sera par défaut le 'logstash' topicconfig.logstash.path = 'logstash'# Facultatif, sera par défaut le 'logstash-logger' producteurconfig.logstash.producer = 'logstash-logger '# Facultatif, sera par défaut localhost:9092 host/portconfig.logstash.hosts = ['localhost:9092']# Facultatif, sera par défaut 1s backoffconfig.logstash.backoff = 1
Ajoutez la gem aws-sdk à votre Gemfile :
# aws-sdk >= 3.0 gem 'aws-sdk-kinesis' # aws-sdk < 3.0 gem 'aws-sdk'
# Requiredconfig.logstash.type = :kinesis# Facultatif, sera par défaut 'logstash' streamconfig.logstash.stream = 'my-stream-name'# Facultatif, sera par défaut 'us-east-1'config.logstash.aws_region = 'us-west-2'# Facultatif, sera par défaut la variable d'environnement AWS_ACCESS_KEY_IDconfig.logstash.aws_access_key_id = 'ASKASKHLD12341'# Facultatif, sera par défaut la variable d'environnement AWS_SECRET_ACCESS_KEYconfig.logstash.aws_secret_access_key = 'ASKASKHLD1234123412341234'
Ajoutez la gem aws-sdk à votre Gemfile :
# aws-sdk >= 3.0 gem 'aws-sdk-firehose' # aws-sdk < 3.0 gem 'aws-sdk'
# Requiredconfig.logstash.type = :firehose# Facultatif, sera par défaut la livraison 'logstash' streamconfig.logstash.stream = 'my-stream-name'# Facultatif, sera par défaut la configuration de région AWS par défaut chainconfig.logstash.aws_region = ' us-west-2'# Facultatif, sera par défaut le fournisseur d'informations d'identification par défaut AWS chainconfig.logstash.aws_access_key_id = 'ASKASKHLD12341'# Facultatif, sera par défaut le fournisseur d'informations d'identification par défaut AWS chainconfig.logstash.aws_secret_access_key = 'ASKASKHLD1234123412341234'
# Requiredconfig.logstash.type = :file# Facultatif, par défaut Rails log pathconfig.logstash.path = 'log/production.log'
# Requiredconfig.logstash.type = :io# Requiredconfig.logstash.io = io
# Requiredconfig.logstash.type = :multi_delegator# Requiredconfig.logstash.outputs = [
{type : fichier, chemin : 'log/production.log'
},
{type : :udp,port : 5228,hôte : 'localhost'
}] # Requiredconfig.logstash.type = :multi_logger# Obligatoire. Chaque enregistreur peut avoir son propre formatter.config.logstash.outputs = [
{type : fichier,chemin : 'log/production.log',formatter : :Logger::Formatter
},
{type : :udp,port : 5228,hôte : 'localhost'
}]Dans les applications Web, vous pouvez enregistrer les données des requêtes HTTP (telles que les en-têtes) à l'aide du middleware RequestStore. L'exemple suivant suppose Rails.
# dans Gemfilegem 'request_store'
# dans application.rbLogStashLogger.configure do |config| config.customize_event do |event|event["session_id"] = RequestStore.store[:load_balancer_session_id] fin
# dans 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"]fin
Si votre application se divise (comme c'est souvent le cas avec de nombreux serveurs Web), vous devrez gérer le nettoyage des ressources sur vos instances LogStashLogger. La méthode d'instance #reset est disponible à cet effet. Voici un exemple de configuration pour plusieurs serveurs Web courants utilisés avec Rails :
Passager:
::PhusionPassenger.on_event(:starting_worker_process) faire |forked| Rails.logger.resetend
Puma:
# Dans config/puma.rbon_worker_boot, faites Rails.logger.resetend
Licorne
# Dans config/unicorn.rbafter_fork, faites |server, worker| Rails.logger.resetend
Vérifié pour fonctionner avec :
IRM Rubis 2.2 - 2.5
JRuby 9.x
Rubinius
Les versions Ruby <2.2 sont EOL et ne sont plus prises en charge.
Cela dépend de vos besoins spécifiques, mais la plupart des applications doivent utiliser la valeur par défaut (UDP). Voici les avantages et inconvénients de chaque type :
UDP est plus rapide que TCP car il est asynchrone (tirer et oublier). Cependant, cela signifie que les messages du journal pourraient être supprimés. Cela convient à de nombreuses applications.
TCP vérifie que chaque message a été reçu via une communication bidirectionnelle. Il prend également en charge SSL pour la transmission sécurisée des messages de journal sur un réseau. Cela pourrait ralentir considérablement l'exploration de votre application si l'écouteur TCP est soumis à une forte charge.
Un fichier est simple à utiliser, mais vous devrez vous soucier de la rotation des journaux et du manque d’espace disque.
L'écriture sur un socket Unix est plus rapide que l'écriture sur un port TCP ou UDP, mais ne fonctionne que localement.
L'écriture sur Redis est idéale pour les configurations distribuées qui génèrent des tonnes de journaux. Cependant, vous aurez une autre pièce mobile et devrez vous soucier du manque de mémoire de Redis.
L'écriture sur la sortie standard n'est recommandée qu'à des fins de débogage.
Pour une discussion plus détaillée sur UDP vs TCP, je vous recommande de lire cet article : UDP vs TCP
Si vous utilisez un périphérique soutenu par un objet Ruby IO (tel qu'un fichier, un socket UDP ou un socket TCP), sachez que Ruby conserve son propre tampon interne. Malgré le fait que LogStashLogger met les messages en mémoire tampon et les vide périodiquement, les données écrites dans l'objet IO peuvent être mises en mémoire tampon par Ruby en interne indéfiniment, et peuvent même ne pas être écrites avant la fin du programme. Si cela vous dérange ou si vous avez besoin de voir les messages du journal immédiatement, votre seul recours est de définir l'option sync: true .
Votre application tente probablement de consigner des données qui ne sont pas codées de manière valide. Lorsque cela se produit, la bibliothèque JSON standard de Ruby déclenche une exception. Vous pourrez peut-être surmonter ce problème en remplaçant un autre encodeur JSON tel que Oj. Utilisez la gemme oj_mimic_json pour utiliser Oj pour la génération JSON.
Heroku recommande d'installer rails_12factor afin que les journaux soient envoyés à STDOUT. Malheureusement, cela remplace LogStashLogger, empêchant l'envoi des journaux vers leur destination configurée. La solution consiste à supprimer rails_12factor de votre Gemfile.
Ce n'est probablement pas un problème avec LogStashLogger, mais plutôt un joyau différent modifiant le niveau de journalisation de Rails.logger . Cela est particulièrement probable si vous utilisez un serveur threadé tel que Puma, car les gemmes modifient souvent le niveau de journalisation de Rails.logger d'une manière non thread-safe. Voir #17 pour plus d'informations.
Si vous utilisez la sortie UDP et écrivez sur un écouteur logstash, vous rencontrez probablement un bogue dans l'implémentation UDP de l'écouteur logstash. Il n’existe aucun correctif connu pour le moment. Voir #43 pour plus d'informations.
Un inconvénient connu de l’utilisation de TCP ou UDP est la limite de 65 535 octets sur la taille totale des messages. Pour contourner ce problème, vous devrez tronquer le message en définissant la taille maximale du message :
LogStashLogger.configure faire |config| config.max_message_size = 2000fin
Cela tronquera uniquement le champ message de l'événement LogStash. Assurez-vous donc de définir la taille maximale du message à une valeur nettement inférieure à 65 535 octets pour laisser de la place à d'autres champs.
Rails 3.2, MRI Ruby < 2.2 et JRuby 1.7 ne sont plus pris en charge, car ils ont été EOL. Si vous utilisez une ancienne version de Ruby, vous devrez utiliser la version 0.24 ou inférieure.
La clé d'événement source a été remplacée par host pour mieux correspondre au dernier logstash.
Le constructeur (host, port, type) est obsolète au profit d'un constructeur de hachage d'options.
LogStash::Event utilise le format v1 à partir de la version 1.2+. Si vous utilisez la v1, vous devrez installer LogStashLogger version 0.4+. Ceci n'est pas rétrocompatible avec l'ancien LogStash::Event v1.1.5, qui utilise le format v0.
Les versions antérieures de cette gemme (<= 0.2.1) implémentaient uniquement une connexion TCP. Les versions plus récentes (>= 0.3) implémentent également UDP et l'utilisent comme nouvelle valeur par défaut. Veuillez noter que si vous utilisez le constructeur par défaut et que vous avez toujours besoin de TCP, vous devez ajouter un argument supplémentaire :
# Désormais, la valeur par défaut est UDP au lieu de TCPlogger = LogStashLogger.new('localhost', 5228)# Spécifiez explicitement TCP au lieu de UDPlogger = LogStashLogger.new('localhost', 5228, :tcp)David Butler
pctj101
Gary Rennie
Nick Éthier
Arron Mabrey
Jan Schulte
Kurt Preston
Chris Blatchley
Félix Bechstein
Vadim Kazakov
Anil Rhemtulla
Nikita Vorobeï
garçon de feu1919
Mike Gunderloy
Vitali Gorodetski
Courtland Caldwell
Bibek Shrestha
Alex Ianus
Craig Lire
verre
Bin Lan
João Fernandes
CoolElvis
Sergueï Piankov
Alec Hoey
Alexeï Krasnoperov
Gabriel de Oliveira
Vladislav Syabrouk
Matus Vacula
Fourchette-le
Créez votre branche de fonctionnalités ( git checkout -b my-new-feature )
Validez vos modifications ( git commit -am 'Add some feature' )
Pousser vers la branche ( git push origin my-new-feature )
Créer une nouvelle demande de tirage
