Como posso comparar $ {HOST} e $ {HOST_FROM} (ou por que $ {HOST}! = $ {HOST})?

Question

Eu tenho uma configuração que pode ser resumida da seguinte forma:

service --> syslog-ng relay --> syslog-ng server

No servidor syslog-ng , eu teria o log organizado da seguinte forma:

/var/log/ ----> syslog-ng server local log files...
           \--> ${FROM_HOST}/ 
                 \---> Syslog-ng relay host log files...
                 \---> ${HOST}/
                        \---> Service log files...

• Registros gerados localmente no servidor syslog-ng localizado em seu local padrão, / var / log .
• Logs gerados em uma retransmissão em um subdiretório contendo o nome do relé, / var / log / $ {FROM_HOST} .
• Registros gerados por um serviço em um subdiretório de seu relé associado, / var / log / $ {FROM_HOST} / $ {HOST}

Eu criei a seguinte configuração no host do servidor syslog-ng :

@version: 3.7
@include "scl.conf"

options {
    dns-cache-hosts("/etc/hosts");
    keep-hostname(yes);
    use-dns(persist_only);
};

...(removed)...

# syslog-ng server local logs, works fine.
log {
    source(local_src);
    local_file();
};

# syslog-ng relays, never matches.
log {
    source(remote_src);
    filter { host("${HOST_FROM}", type(string)); };
    local_file(subdir("${HOST_FROM}/"));
};

# Services, works fine but also matches syslog-ng relays.
log {
    source(remote_src);
    filter { not host("${HOST_FROM}", type(string)); };
    local_file(subdir("${HOST_FROM}/$(sanitize $HOST)/"));
};

Para informações local_file() é um bloco de log personalizado, tendo como parâmetro o subdiretório onde armazenar entradas de registros.

Os host() é descrito como comparando seu parâmetro com $ {HOST} . Minha idéia estava lá para usar $ {HOST} (o autor da mensagem do syslog) e $ {HOST_FROM} (o último salto da mensagem do syslog):

• Se eles forem iguais, a mensagem foi gerada pelo relé syslog-ng .
• Se forem diferentes, a mensagem foi gerada por um serviço.

No entanto, o teste host("${HOST_FROM}", type(string)) sempre falha, mesmo que o caminho gerado não mostre qualquer diferença entre os valores de $ {HOST} e $ {HOST_FROM} (por exemplo, dado um relé chamado therelay , os registros de retransmissão serão armazenados abaixo de / var / log / therelay / therelay / (expansão de / var / log / $ {HOST_FROM} / $ (sanitize $ HOST) / ).

Eu tentei remover a sanitização, para interpretar o padrão como um regexp em vez de uma string bruta, adicione .* no início e no final do padrão enquanto um regexp, refaz todos esses testes enquanto substitui host("${HOST_FROM}") por match("${HOST_FROM}", value(HOST)) , mas nada parece funcionar.

Na verdade, mesmo host("${HOST}") (comparando $ {HOST} com ele mesmo) parece nunca corresponder.

Substituir o filtro por filter { host(".*"); }; , no entanto, força corretamente essa entrada para corresponder.

Este é o comportamento esperado? Como posso comparar o conteúdo de $ {HOST} e $ {HOST_FROM} ?

    

Answer 1

Não tenho certeza se essa é a melhor resposta, por isso deixo minha pergunta em aberto por enquanto.

Parece que as macros não são expandidas em funções de filtro, provavelmente devido a uma otimização de velocidade como o uso de um " um pouco mais lento " específica sintaxe parece necessária em tal caso.

host("${HOST_FROM}") corresponderá apenas a um host literalmente chamado $ {HOST_FROM} , o que provavelmente não acontecerá em circunstâncias normais.

O teste certo a fazer parece ser o filtro definido abaixo:

filter { "${HOST}" == "${HOST_FROM}" };

Embora essa sintaxe possa ser menos eficiente, acho que essa é a única maneira de comparar o conteúdo de duas macros.