Desenvolver plug-ins personalizados

Você está lendo a documentação do Apigee Edge.
Acesse a documentação da Apigee X. info

Edge Microgateway v. 3.3.x

Público-alvo

Este tópico é destinado a desenvolvedores que querem estender os recursos do Edge Microgateway escrevendo plug-ins personalizados. Se você quiser escrever um novo plug-in, é necessário ter experiência com JavaScript e Node.js.

O que é um plug-in personalizado do Edge Microgateway?

Um plug-in é um módulo Node.js que adiciona funcionalidade ao Edge Microgateway. Os módulos de plug-in seguem um padrão consistente e são armazenados em um local conhecido pelo Edge Microgateway, permitindo que sejam descobertos e executados automaticamente. Vários plug-ins predefinidos são fornecidos quando você instala o Edge Microgateway. Isso inclui plug-ins para autenticação, restrição de picos, cota e análise. Esses plug-ins estão descritos em Usar plug-ins.

É possível adicionar novos recursos e funcionalidades ao microrrecurso escrevendo plug-ins personalizados. Por padrão, o Edge Microgateway é essencialmente um proxy de passagem seguro que transmite solicitações e respostas inalteradas para e de serviços de destino. Com os plug-ins personalizados, é possível interagir de forma programática com as solicitações e respostas que passam pelo microrrecurso.

Onde colocar o código do plug-in personalizado

Uma pasta para plug-ins personalizados está incluída na instalação do Edge Microgateway aqui:

[prefix]/lib/node_modules/edgemicro/node_modules/microgateway-plugins

em que [prefix] é o diretório de prefixo npm, conforme descrito em "Onde o Edge Microgateway está instalado?" em Instalar o Edge Microgateway.

É possível mudar esse diretório padrão de plug-ins. Consulte Onde encontrar plug-ins.

Analisar os plug-ins predefinidos

Antes de tentar desenvolver seu próprio plug-in, verifique se nenhum dos plug-ins predefinidos atende aos seus requisitos. Esses plug-ins estão localizados em:

[prefix]/lib/node_modules/edgemicro/node_modules/microgateway-plugins

em que [prefix] é o diretório de prefixo npm. Consulte também "Onde o Edge Microgateway é instalado" em Instalar o Edge Microgateway.

Para mais detalhes, consulte também Plug-ins predefinidos fornecidos com o Edge Microgateway.

Escrever um plug-in simples

Nesta seção, vamos mostrar as etapas necessárias para criar um plug-in simples. Esse plug-in substitui os dados de resposta (sejam eles quais forem) pela string "Hello, World!" e a imprime no terminal.

1. Se o Edge Microgateway estiver em execução, interrompa-o agora:
   

   edgemicro stop

2. cd para o diretório de plug-ins personalizados:

   cd [prefix]/lib/node_modules/edgemicro/plugins

   em que [prefix] é o diretório de prefixo npm, conforme descrito em "Onde o Edge Microgateway está instalado?" em Instalar o Edge Microgateway.

3. Crie um projeto de plug-in chamado response-override e cd até ele:
   

   mkdir response-override && cd response-override

4. Crie um novo projeto Node.js:
   

   npm init

   Pressione "Return" várias vezes para aceitar os padrões.
5. Use um editor de texto para criar um arquivo chamado index.js.
6. Copie o código a seguir em index.js e salve o arquivo.
   

   'use strict';
   var debug = require('debug')
   
   module.exports.init = function(config, logger, stats) {
   
     return {
      
       ondata_response: function(req, res, data, next) {
         debug('***** plugin ondata_response');
         next(null, null);
       },
       
       onend_response: function(req, res, data, next) {
         debug('***** plugin onend_response');
         next(null, "Hello, World!\n\n");
       }
     };
   }

7. Agora que você criou um plug-in, é necessário adicioná-lo à configuração do Edge Microgateway. Abra o arquivo $HOME/.edgemicro/[org]-[env]-config.yaml, em que org e env são os nomes da sua organização e do ambiente do Edge.
8. Adicione o plug-in response-override ao elemento plugins:sequence conforme mostrado abaixo.
   

         ...
         
         plugins:
           dir: ../plugins
           sequence:
             - oauth
             - response-override
             
         ...

9. Reinicie o Edge Microgateway.
10. Chamar uma API pelo Edge Microgateway. Essa chamada de API pressupõe que você configurou a mesma configuração do tutorial com segurança de chave de API, conforme descrito em Configurar e configurar o Edge Microgateway:
    

    curl -H 'x-api-key: uAM4gBSb6YoMvTHfx5lXJizYIpr5Jd' http://localhost:8000/hello/echo
    Hello, World!

Anatomia de um plug-in

O exemplo de plug-in do Edge Microgateway a seguir ilustra o padrão a ser seguido ao desenvolver seus próprios plug-ins. O código-fonte do plug-in de exemplo discutido nesta seção está em plugins/header-uppercase/index.js.

• Os plug-ins são módulos NPM padrão com um package.json e um index.js na pasta raiz.
• Um plug-in precisa exportar uma função init().
• A função init() usa três argumentos: config, logger e stats. Esses argumentos são descritos em Argumentos da função init() do plug-in.
• init() retorna um objeto com manipuladores de funções nomeados que são chamados quando determinados eventos ocorrem durante o ciclo de vida de uma solicitação.

Funções de manipulador de eventos

Um plug-in precisa implementar algumas ou todas essas funções de manipulador de eventos. A implementação dessas funções é de sua responsabilidade. Qualquer função é opcional, e um plug-in típico implementa pelo menos um subconjunto delas.

Solicitar manipuladores de eventos de fluxo

Essas funções são chamadas em eventos de solicitação no Edge Microgateway.

• onrequest
• ondata_request
• onend_request
• onclose_request
• onerror_request

onrequest Função

Chamado no início da solicitação do cliente. Essa função é disparada quando o primeiro byte da solicitação é recebido pelo Edge Microgateway. Essa função dá acesso aos cabeçalhos de solicitação, ao URL, aos parâmetros de consulta e ao método HTTP. Se você chamar "next" com um primeiro argumento verdadeiro (como uma instância de "Error"), o processamento da solicitação será interrompido e uma solicitação de destino não será iniciada.

Exemplo:

onrequest: function(req, res, next) {
      debug('plugin onrequest');
      req.headers['x-foo-request-start'] = Date.now();
      next();
    }

ondata_request Função

Chamado quando um bloco de dados é recebido do cliente. Transmite dados de solicitação para o próximo plug-in na sequência. O valor retornado do último plug-in na sequência é enviado para a meta. Um caso de uso típico, mostrado abaixo, é transformar os dados da solicitação antes de enviá-los ao destino.

Exemplo:

ondata_request: function(req, res, data, next) {
      debug('plugin ondata_request ' + data.length);
      var transformed = data.toString().toUpperCase();
      next(null, transformed);
    }

onend_request Função

Chamado quando todos os dados da solicitação são recebidos do cliente.

Exemplo:

onend_request: function(req, res, data, next) {
      debug('plugin onend_request');
      next(null, data);
    }

onclose_request função

Indica que a conexão do cliente foi fechada. Você pode usar essa função em casos em que a conexão do cliente não é confiável. Ele é chamado quando a conexão de soquete com o cliente é encerrada.

Exemplo:

onclose_request: function(req, res, next) {
      debug('plugin onclose_request');
      next();
    }

onerror_request função

Chamado se houver um erro ao receber a solicitação do cliente.

Exemplo:

onerror_request: function(req, res, err, next) {
      debug('plugin onerror_request ' + err);
      next();
    }

Manipuladores de eventos de fluxo de resposta

Essas funções são chamadas em eventos de resposta no Edge Microgateway.

• onresponse
• ondata_response
• onend_response
• onclose_response
• onerror_response

onresponse função

Chamado no início da resposta de destino. Essa função é disparada quando o primeiro byte da resposta é recebido pelo Edge Microgateway. Essa função dá acesso aos cabeçalhos de resposta e ao código de status.

Exemplo:

onresponse: function(req, res, next) {      
    debug('plugin onresponse');     
    res.setHeader('x-foo-response-time', Date.now() - req.headers['x-foo-request-start'])    
    next();    
}

Função ondata_response

Chamado quando um bloco de dados é recebido do destino.

Exemplo:

ondata_response: function(req, res, data, next) {
      debug('plugin ondata_response ' + data.length);
      var transformed = data.toString().toUpperCase();
      next(null, transformed);
    }

Função onend_response

Chamado quando todos os dados de resposta foram recebidos do destino.

Exemplo:

onend_response: function(req, res, data, next) {
      debug('plugin onend_response');
      next(null, data);
    }

onclose_response função

Indica que a conexão de destino foi fechada. É possível usar essa função em casos em que a conexão de destino não é confiável. Ele é chamado quando a conexão de soquete com o destino é fechada.

Exemplo:

onclose_response: function(req, res, next) {
      debug('plugin onclose_response');
      next();
    }

Função onerror_response

Chamado se houver um erro ao receber a resposta de destino.

Exemplo:

onerror_response: function(req, res, err, next) {
      debug('plugin onerror_response ' + err);
      next();
    }

O que você precisa saber sobre as funções de manipulador de eventos do plug-in

As funções de manipulador de eventos do plug-in são chamadas em resposta a eventos específicos que ocorrem enquanto o Edge Microgateway processa uma determinada solicitação de API.

• Cada um dos manipuladores de função init() (ondata_request, ondata_response etc.) precisa chamar o callback next() quando o processamento for concluído. Se você não chamar next(), o processamento será interrompido e a solicitação será suspensa.
• O primeiro argumento de next() pode ser um erro que fará com que o processamento da solicitação seja encerrado.
• Os manipuladores ondata_ e onend_ precisam chamar next() com um segundo argumento que contém os dados a serem transmitidos para o destino ou o cliente. Esse argumento pode ser nulo se o plug-in estiver armazenando em buffer e não tiver dados suficientes para transformar no momento.
• Uma única instância do plug-in é usada para atender a todas as solicitações e respostas. Se um plug-in quiser manter o estado por solicitação entre as chamadas, ele poderá salvar esse estado em uma propriedade adicionada ao objeto request (req) fornecido, cujo tempo de vida é a duração da chamada de API.
• Tome cuidado para detectar todos os erros e chame next() com o erro. Se você não chamar next(), a chamada de API vai ficar pendente.
• Tenha cuidado para não introduzir vazamentos de memória, já que isso pode afetar o desempenho geral do Edge Microgateway e causar falhas se ele ficar sem memória.
• Siga o modelo do Node.js e não execute tarefas com uso intenso de computação na linha de execução principal, porque isso pode afetar negativamente o desempenho do Edge Microgateway.

Sobre a função init() do plug-in

Nesta seção, descrevemos os argumentos transmitidos à função init(): config, logger e stats.

config

Os dados de configuração obtidos pela fusão do arquivo de configuração do Edge Microgateway com os dados baixados do Apigee Edge são colocados em um objeto chamado config.

Para adicionar um parâmetro de configuração chamado param com o valor foo a um plug-in chamado response-override, coloque isso no arquivo default.yaml:

response-override:
    param: foo

Em seguida, você pode acessar o parâmetro no código do plug-in desta forma:

// Called when response data is received
    ondata_response: function(req, res, data, next) {
      debug('***** plugin ondata_response');
      debug('***** plugin ondata_response: config.param: ' + config.param);
      next(null, data);
    },

Nesse caso, você verá "foo" impresso na saída de depuração do plug-in:

Sun, 13 Dec 2015 21:25:08 GMT plugin:response-override ***** plugin ondata_response: config.param: foo

Você pode acessar a configuração mesclada do microgateway e os dados baixados do Apigee Edge no objeto filho config.emgConfigs. Por exemplo, é possível acessar esses dados de configuração na função init da seguinte forma:

module.exports.init = function(config, logger, stats) {
   let emgconfigs = config.emgConfigs;

Confira abaixo um exemplo de dados que o emgConfigs contém:

{
    edgemicro:
    {
        port: 8000,
        max_connections: 1000,
        config_change_poll_interval: 600,
        logging:
        {
            level: 'error',
            dir: '/var/tmp',
            stats_log_interval: 60,
            rotate_interval: 24,
            stack_trace: false
        },
        plugins: { sequence: [Array] },
        global: { org: 'Your Org', env: 'test' }
    },
    headers:
    {
        'x-forwarded-for': true,
        'x-forwarded-host': true,
        'x-request-id': true,
        'x-response-time': true,
        via: true
    },
    proxies:
    [    {
                max_connections: 1000,
                name: 'edgemicro_delayed',
                revision: '1',
                proxy_name: 'default',
                base_path: '/edgemicro_delayed',
                target_name: 'default',
                url: 'https://httpbin.org/delay/10',
                timeout: 0
            }
    ],
    product_to_proxy: { EdgeMicroTestProduct: [ 'edgemicro-auth','edgemicro_delayed',] },
    product_to_scopes: {prod4: [ 'Admin', 'Guest', 'Student' ] },
    product_to_api_resource: { EdgeMicroTestProduct: [ '/*' ] },
    _hash: 0,
    keys: { key: 'Your key', secret: 'Your key ' },
    uid: 'Internally generated uuid',
    targets: []
  }

logger

O registrador do sistema. O registrador atualmente usado exporta essas funções, em que o objeto pode ser uma string, uma solicitação HTTP, uma resposta HTTP ou uma instância de erro.

• info(object, message)
• warn(object, message)
• error(object, message)
• trace(object, message)
• debug(object, message)

stats

Um objeto que contém contagens de solicitações, respostas, erros e outras estatísticas agregadas relacionadas às solicitações e respostas que fluem por uma instância de microrrede.

• treqErrors: o número de solicitações de segmentação com erros.
• treqErrors: o número de respostas de destino com erros.
• statusCodes: um objeto que contém contagens de códigos de resposta:

{
  1: number of target responses with 1xx response codes
  2: number of target responses with 2xx response codes
  3: number of target responses with 3xx response codes
  4: number of target responses with 4xx response codes
  5: number of target responses with 5xx response codes
  }
  

• requests: o número total de solicitações.
• respostas: o número total de respostas.
• connections: o número de conexões de destino ativas.

Sobre a função next()

Todos os métodos de plug-in precisam chamar next() para continuar processando o próximo método na série. Caso contrário, o processo do plug-in vai ficar travado. No ciclo de vida da solicitação, o primeiro método chamado é onRequest(). O próximo método a ser chamado é ondata_request(). No entanto, ondata_request é chamado apenas se a solicitação incluir dados, como no caso, por exemplo, de uma solicitação POST. O próximo método chamado será onend_request(), que é chamado quando o processamento da solicitação é concluído. As funções onerror_* só são chamadas em caso de erro e permitem que você processe os erros com código personalizado, se quiser.

Digamos que os dados sejam enviados na solicitação e ondata_request() seja chamado. Observe que a função chama next() com dois parâmetros:

next(null, data);

Por convenção, o primeiro parâmetro é usado para transmitir informações de erro, que podem ser processadas em uma função subsequente na cadeia. Ao definir como null, um argumento falso, estamos dizendo que não há erros e que o processamento da solicitação deve prosseguir normalmente. Se esse argumento for verdadeiro (como um objeto de erro), o processamento da solicitação será interrompido e a solicitação será enviada ao destino.

O segundo parâmetro transmite os dados da solicitação para a próxima função na cadeia. Se você não fizer nenhum processamento adicional, os dados da solicitação serão transmitidos inalterados para o destino da API. No entanto, você tem a chance de modificar os dados da solicitação dentro desse método e transmitir a solicitação modificada para o destino. Por exemplo, se os dados da solicitação forem XML e o destino esperar JSON, adicione código ao método ondata_request() que (a) mude o Content-Type do cabeçalho da solicitação para application/json e converta os dados da solicitação para JSON usando o método que você quiser. Por exemplo, use um conversor xml2json do Node.js obtido do NPM.

Confira como isso pode ser feito:

ondata_request: function(req, res, data, next) {
  debug('****** plugin ondata_request');
  var translated_data = parser.toJson(data);
  next(null, translated_data);
},

Nesse caso, os dados da solicitação (que são considerados XML) são convertidos em JSON, e os dados transformados são transmitidos via next() para a próxima função na cadeia de solicitações, antes de serem transmitidos para o destino de back-end.

Você pode adicionar outra instrução de depuração para imprimir os dados transformados para fins de depuração. Exemplo:

ondata_request: function(req, res, data, next) {
  debug('****** plugin ondata_request');
  var translated_data = parser.toJson(data);
  debug('****** plugin ondata_response: translated_json: ' + translated_json);
  next(null, translated_data);
},

Sobre a ordem de execução do gerenciador de plug-ins

Se você escreve plug-ins para o Edge Microgateway, precisa entender a ordem em que os manipuladores de eventos do plug-in são executados.

É importante lembrar que, quando você especifica uma sequência de plug-ins no arquivo de configuração do Edge Microgateway, os gerenciadores de solicitações são executados em ordem crescente, enquanto os gerenciadores de respostas são executados em ordem decrescente.

O exemplo a seguir foi criado para ajudar você a entender essa sequência de execução.

1. Criar três plug-ins simples

Considere o seguinte plug-in. Tudo o que ele faz é imprimir a saída do console quando os manipuladores de eventos são chamados:

plugins/plugin-1/index.js

module.exports.init = function(config, logger, stats) {

  return {

    onrequest: function(req, res, next) {
      console.log('plugin-1: onrequest');
      next();
    },

    onend_request: function(req, res, data, next) {
      console.log('plugin-1: onend_request');
      next(null, data);
    },

    ondata_response: function(req, res, data, next) {
      console.log('plugin-1: ondata_response ' + data.length);
      next(null, data);
    },

    onend_response: function(req, res, data, next) {
      console.log('plugin-1: onend_response');
      next(null, data);
    }
  };
}

Agora, crie mais dois plug-ins, plugin-2 e plugin-3, com o mesmo código. A única diferença é que você precisa mudar as instruções console.log() para plugin-2 e plugin-3, respectivamente.

2. Revisar o código do plug-in

As funções de plug-in exportadas em <microgateway-root-dir>/plugins/plugin-1/index.js são manipuladores de eventos que são executados em momentos específicos durante o processamento de solicitação e resposta. Por exemplo, onrequest executa o primeiro byte dos cabeçalhos de solicitação recebidos. Já onend_response é executado depois que o último byte de dados de resposta é recebido.

Confira o gerenciador ondata_response. Ele é chamado sempre que um bloco de dados de resposta é recebido. É importante saber que os dados de resposta não são necessariamente recebidos de uma só vez. Em vez disso, os dados podem ser recebidos em partes de comprimento arbitrário.

3. Adicione os plug-ins à sequência de plug-ins

Continuando com este exemplo, vamos adicionar os plug-ins à sequência de plug-ins no arquivo de configuração do Edge Microgateway (~./edgemicro/config.yaml) da seguinte maneira. A sequência é importante. Ele define a ordem em que os gerenciadores de plug-ins são executados.

  plugins:
    dir: ../plugins
    sequence:
      - plugin-1
      - plugin-2
      - plugin-3
  

4. Examinar a saída de depuração

Agora, vamos analisar a saída que seria produzida quando esses plug-ins são chamados. Há alguns pontos importantes a serem observados:

• A sequência de plug-ins no arquivo de configuração do Edge Microgateway (~./edgemicro/config.yaml) especifica a ordem em que os gerenciadores de eventos são chamados.
• Os manipuladores de solicitações são chamados em ordem crescente (a ordem em que aparecem na sequência de plug-ins: 1, 2, 3).
• Os manipuladores de respostas são chamados em ordem descendente: 3, 2, 1.
• O manipulador ondata_response é chamado uma vez para cada bloco de dados que chega. Neste exemplo (saída mostrada abaixo), dois blocos são recebidos.

Confira um exemplo de saída de depuração produzida quando esses três plug-ins estão em uso e uma solicitação é enviada pelo Edge Microgateway. Observe a ordem em que os manipuladores são chamados:

  plugin-1: onrequest
  plugin-2: onrequest
  plugin-3: onrequest

  plugin-1: onend_request
  plugin-2: onend_request
  plugin-3: onend_request

  plugin-3: ondata_response 931
  plugin-2: ondata_response 931
  plugin-1: ondata_response 931

  plugin-3: ondata_response 1808
  plugin-3: onend_response

  plugin-2: ondata_response 1808
  plugin-2: onend_response

  plugin-1: ondata_response 1808
  plugin-1: onend_response

Resumo

Entender a ordem em que os manipuladores de plug-in são chamados é muito importante ao tentar implementar funcionalidades personalizadas de plug-in, como acumular e transformar dados de solicitação ou resposta.

Os gerenciadores de solicitações são executados na ordem em que os plug-ins são especificados no arquivo de configuração do Edge Microgateway, e os gerenciadores de respostas são executados na ordem oposta.

Sobre o uso de variáveis globais em plug-ins

Cada solicitação para o Edge Microgateway é enviada à mesma instância de um plug-in. Portanto, o estado de uma segunda solicitação de outro cliente vai substituir a primeira. A única maneira segura de salvar o estado do plug-in é armazenando-o em uma propriedade no objeto de solicitação ou resposta (cuja vida útil é limitada à da solicitação).

Como reescrever URLs de destino em plug-ins

Adicionado na v2.3.3

É possível substituir o URL de destino padrão em um plug-in de forma dinâmica modificando estas variáveis no código do plug-in: req.targetHostname e req.targetPath.

Adicionado na v2.4.x

Você também pode substituir a porta do endpoint de destino e escolher entre HTTP e HTTPS. Modifique estas variáveis no código do plug-in: req.targetPort e req.targetSecure. Para escolher HTTPS, defina req.targetSecure como true. Para HTTP, defina como false. Se você definir req.targetSecure como true, consulte esta discussão em um tópico para mais informações.

Removido na versão: v3.3.3

O plug-in de exemplo chamado eurekaclient foi removido do Edge Microgateway na versão 3.3.3. Consulte as Notas da versão.

A remoção desse recurso não afeta a funcionalidade principal do microrreceptáculo do Edge nem a reescrita de URLs de destino. É possível configurar a pesquisa dinâmica de endpoints e substituir variáveis de destino como req.targetHostname, req.targetPath, req.targetPort e req.targetSecure no nível do plug-in. Consulte Reescrever URLs de destino em plug-ins.

Plug-ins de exemplo

Esses plug-ins são fornecidos com a instalação do Edge Microgateway. Você pode encontrá-los na instalação do Edge Microgateway aqui:

[prefix]/lib/node_modules/edgemicro/plugins

em que [prefix] é o diretório de prefixo npm, conforme descrito em "Onde o Edge Microgateway está instalado?" em Instalar o Edge Microgateway.

accumulate-request

Esse plug-in acumula partes de dados do cliente em uma propriedade de matriz anexada ao objeto de solicitação. Quando todos os dados da solicitação são recebidos, a matriz é concatenada em um buffer que é transmitido ao próximo plug-in na sequência. Ele precisa ser o primeiro na sequência para que os plug-ins subsequentes recebam os dados de solicitação acumulados.

module.exports.init = function(config, logger, stats) {

  function accumulate(req, data) {

    if (!req._chunks) req._chunks = [];
    req._chunks.push(data);

  }

  return {

    ondata_request: function(req, res, data, next) {

      if (data && data.length > 0) accumulate(req, data);

      next(null, null);

    },


    onend_request: function(req, res, data, next) {

      if (data && data.length > 0) accumulate(req, data);

      var content = null;

      if (req._chunks && req._chunks.length) {

        content = Buffer.concat(req._chunks);

      }

      delete req._chunks;

      next(null, content);

    }

  };

}

accumulate-response

Esse plug-in acumula partes de dados do destino em uma propriedade de matriz anexada ao objeto de resposta. Quando todos os dados de resposta são recebidos, a matriz é concatenada em um buffer que é transmitido para o próximo plug-in na sequência. Como esse plug-in opera em respostas, que são processadas em ordem inversa, coloque-o como o último plug-in na sequência.

module.exports.init = function(config, logger, stats) {

  function accumulate(res, data) {
    if (!res._chunks) res._chunks = [];
    res._chunks.push(data);
  }

  return {

    ondata_response: function(req, res, data, next) {
      if (data && data.length > 0) accumulate(res, data);
      next(null, null);
    },

    onend_response: function(req, res, data, next) {
      if (data && data.length > 0) accumulate(res, data);
      var content = Buffer.concat(res._chunks);
      delete res._chunks;
      next(null, content);
    }

  };

}

Plug-in header-uppercase

As distribuições do Edge Microgateway incluem um plug-in de exemplo chamado <microgateway-root-dir>/plugins/header-uppercase. O exemplo inclui comentários descrevendo cada um dos manipuladores de função. Essa amostra faz uma transformação simples dos dados da resposta de destino e adiciona cabeçalhos personalizados à solicitação do cliente e à resposta de destino.

Confira o código-fonte de <microgateway-root-dir>/plugins/header-uppercase/index.js:

'use strict';

var debug = require('debug')('plugin:header-uppercase');

// required
module.exports.init = function(config, logger, stats) {

  var counter = 0;

  return {

    // indicates start of client request
    // request headers, url, query params, method should be available at this time
    // request processing stops (and a target request is not initiated) if
    // next is called with a truthy first argument (an instance of Error, for example)
    onrequest: function(req, res, next) {
      debug('plugin onrequest');
      req.headers['x-foo-request-id'] = counter++;
      req.headers['x-foo-request-start'] = Date.now();
      next();
    },

    // indicates start of target response
    // response headers and status code should be available at this time
    onresponse: function(req, res, next) {
      debug('plugin onresponse');
      res.setHeader('x-foo-response-id', req.headers['x-foo-request-id']);
      res.setHeader('x-foo-response-time', Date.now() - req.headers['x-foo-request-start']);
      next();
    },

    // chunk of request body data received from client
    // should return (potentially) transformed data for next plugin in chain
    // the returned value from the last plugin in the chain is written to the target
    ondata_request: function(req, res, data, next) {
      debug('plugin ondata_request ' + data.length);
      var transformed = data.toString().toUpperCase();
      next(null, transformed);
    },

    // chunk of response body data received from target
    // should return (potentially) transformed data for next plugin in chain
    // the returned value from the last plugin in the chain is written to the client
    ondata_response: function(req, res, data, next) {
      debug('plugin ondata_response ' + data.length);
      var transformed = data.toString().toUpperCase();
      next(null, transformed);
    },

    // indicates end of client request
    onend_request: function(req, res, data, next) {
      debug('plugin onend_request');
      next(null, data);
    },

    // indicates end of target response
    onend_response: function(req, res, data, next) {
      debug('plugin onend_response');
      next(null, data);
    },

    // error receiving client request
    onerror_request: function(req, res, err, next) {
      debug('plugin onerror_request ' + err);
      next();
    },

    // error receiving target response
    onerror_response: function(req, res, err, next) {
      debug('plugin onerror_response ' + err);
      next();
    },

    // indicates client connection closed
    onclose_request: function(req, res, next) {
      debug('plugin onclose_request');
      next();
    },

    // indicates target connection closed
    onclose_response: function(req, res, next) {
      debug('plugin onclose_response');
      next();
    }

  };

}

transform-uppercase

Esse é um plug-in de transformação geral que pode ser modificado para fazer qualquer tipo de transformação que você quiser. Este exemplo simplesmente transforma os dados de resposta e solicitação em maiúsculas.

 */
module.exports.init = function(config, logger, stats) {

  // perform content transformation here
  // the result of the transformation must be another Buffer
  function transform(data) {
    return new Buffer(data.toString().toUpperCase());
  }

  return {

    ondata_response: function(req, res, data, next) {
      // transform each chunk as it is received
      next(null, data ? transform(data) : null);
    },

    onend_response: function(req, res, data, next) {
      // transform accumulated data, if any
      next(null, data ? transform(data) : null);
    },

    ondata_request: function(req, res, data, next) {
      // transform each chunk as it is received
      next(null, data ? transform(data) : null);
    },

    onend_request: function(req, res, data, next) {
      // transform accumulated data, if any
      next(null, data ? transform(data) : null);
    }

  };

}