Woodman

Il était une fois…

un moteur de recherche

pour les opérateurs WAP

Implémentation en C++

Trouver la meilleure réponse ?

Règles de filtrage

• ET logique sur les mots-clés entrés
• Position dans le dictionnaire opérateur
• Popularité du service
• Période d’activation
• Liens sponsorisés
• Aléatoire
• …

Questions récurrentes

• “0 réponse pour une recherche sur "paris js", pourquoi ?”
• “Hier, 0 réponse, aujourd’hui 1 réponse, pourquoi ?”
• “Le serveur en prod vient juste de planter, pourquoi ?”
• “Ca marche pas…”

Retour vers le futur…

2014 – 100% JavaScript

console.log

Pas de console.log

Tout est dans la config

woodman.load({
  "loggers": [ … ],   // What to log depending on provenance
  "appenders": [ … ], // Where to log and how
  "filters": [ … ]    // Additional filters, if needed
});
            

Le raccourci "console"

woodman.load({
  loggers: [{
    root: true,
    level: 'log',
    appenders: [ 'theconsole' ]
  }],
  appenders: [{
    name: 'theconsole',
    type: 'Console',
    appendStrings: false,
    layout: {
      type: 'PatternLayout',
      pattern: '%date{yyyy-MM-dd HH:mm:ss} [%logger] %message%n'
    }
  }]
});
            

Changer le niveau

woodman.load({
  loggers: [{
    root: true,
    level: 'warn',
    appenders: [ 'theconsole' ]
  }],
  appenders: [ … ]
});
            

var logger = woodman.getLogger('slides');
logger.log('Un log filtré');
logger.info('Une info filtrée');
logger.warn('Une alerte affichée');
logger.error('Une erreur affichée');
            

Faire taire un module

woodman.load({
  loggers: [
    { level: 'log',  root: true, appenders: [ 'theconsole' ] },
    { level: 'off',  name: 'slides' },
    { level: 'warn', name: 'slides.shout' }
  ],
  appenders: [ … ]
});
            

var logger = woodman.getLogger('slides');
var sublogger = woodman.getLogger('slides.sub');
var shoutlogger = woodman.getLogger('slides.shout');
logger.warn('Cette alerte est filtrée');
sublogger.warn('Cette alerte d’un sous-module est filtrée');
shoutlogger.warn('Cette alerte du sous-module "shout" n’est pas filtrée');
            

Envoyer les traces avec Socket.IO

woodman.load({
  loggers: [{
    level: 'log', root: true,
    appenders: [ 'theconsole', 'remoteserver' ] }
  ],
  appenders: [
    { name: 'theconsole', … },
    { name: 'remoteserver',
      type: 'SocketAppender',
      url: 'http://localhost:40031',
      layout: {
        type: 'PatternLayout',
        pattern: '%date{ISO8601} [%level] %logger - %message'
      }
    }
  ]
});
            

(sous réserve d’avoir un serveur Socket.IO qui tourne !)

Tout est possible

Les paramètres peuvent se combiner.

On peut s’y perdre…

mais la configuration change rarement.

Et surtout…

le code de l’application ne change pas !

Supprimer les logs avant mise en prod

Le précompilateur de Woodman supprime tout ou une partie des appels à Woodman présents dans du code javascript.

npm install woodman
node woodman/precompile/precompiler.js {JSFILE}
node woodman/precompile/precompiler.js {JSFOLDER} {OUTPUTFOLDER}
node woodman/precompile/precompiler.js {JSFILE} {OUTPUTFILE} --verbose
node woodman/precompile/precompiler.js {JSFILE} --keep warn,error
            

Usage

Usage: node precompiler.js [options] <input> [output]

  Description:
    Removes calls to Woodman from a JavaScript file or folder.

  Parameters:
    input   Full path to the JS file or folder to update.
    output  Full path to the JS file or folder to create.
            Precompiler outputs the result to the console otherwise.

  Options:
    -h, --help          Outputs usage information.
    -k, --keep <levels> Keeps specified trace levels in updated file(s).
                        Comma-separated values.
                        Possible values: "log", "info", "warn", "error". 
                        Defaults to an empty list.
    -v, --verbose       Trace precompiler execution.
            

Le précompilateur gère correctement…

• les arborescences de fichiers
• les modules AMD
• les modules Node.js
• les appels aux fonctions de Woodman
• les conditions d’utilisation "normales" de la librairie

En interne

• Esprima pour générer l’arbre AST
• Falafel pour ré-écrire le code
• 5 passes sont nécessaires
• ~10 secondes sur un fichier conséquent
• … peut casser le code dans certaines conditions

Tracer l’exécution d’une requête ?

Un serveur HTTP traite plusieurs requêtes en parallèle.
Comment séparer les logs ?

But

• Assigner un ID à une requête HTTP
• accessible partout dans le code
• sans devoir trimballer cet ID partout

Facile sous Apache, IIS via le local thread storage.
Equivalent sous Node.js ?

Les domaines dans Node.js

// Create two domains with an ID
var domain = require('domain');
var firstDomain = domain.create();
var secondDomain = domain.create();
firstDomain.id = 'first';
secondDomain.id = 'second';

// Some function to execute
var func = function () { … };

// Run function in both domains
firstDomain.run(func);
secondDomain.run(func);
            

Pattern %domain dans Woodman

// Tell Woodman to log the message with the domain ID to the console.
var woodman = require('woodman');
var logger = woodman.getLogger();
woodman.load('console Got "%message" from %domain domain.%n');

// Async function that logs two messages using Woodman.
// The function does not know anything about its underlying domain.
var func = function () {
  logger.log('sync message');
  setTimeout(function () {
    logger.log('async message');
  }, 0);
};
            

Pattern %domain dans Woodman

Got "sync message" from first domain.
Got "sync message" from second domain.
Got "async message" from first domain.
Got "async message" from second domain.
            

Exemple de serveur HTTP

var connect = require('connect');
var domain = require('domain');
var woodman = require('woodman');
var logger = woodman.getLogger();
var requestID = 1;

var app = connect()
  .use(function (req, res, next) {
    // Code below extends connect-domain (MIT license)
    // https://github.com/baryshev/connect-domain
    var reqDomain = domain.create();
    reqDomain.id = requestID++;
    reqDomain.bind(res);
    res.on('finish', function () {
      reqDomain.dispose();
    });
    reqDomain.on('error', function (err) {
      reqDomain.dispose();
      next(err);
    });
    reqDomain.run(next);
  })
  .use(function (req, res) {
    logger.log('start request processing');
    setTimeout(function () {
      logger.log('end request processing');
      res.end('Hello, see console');
    }, 2000);
  })
  .use(function (err, req, res, next) {
    res.end(err.message);
  });

woodman.load('console request %domain - %message%n');
app.listen(3000);