Processadores de mutação de string

Esta seção contém informações sobre os processadores de mutação de string que você pode usar com um transformador de eventos de log.

Sumário

• lowerCaseString

• upperCaseString

• splitString

• substituteString

• trimString

lowerCaseString

O processador lowerCaseString converte uma string em sua versão em minúsculas.

Campo	Description	Obrigatório?	Padrão	Limites
withKeys	Uma lista de chaves a serem convertidas em letras minúsculas	Sim		Máximo de entradas: 10

Exemplo

Observe o exemplo de evento de logs a seguir:

{
    "outer_key": {
        "inner_key": "INNER_VALUE"
    }
}

A configuração do transformador é esta, usando lowerCaseString com parseJSON:

[
    {
        "parseJSON": {}
    },
    {
        "lowerCaseString": {
            "withKeys":["outer_key.inner_key"]
        }
    }
]

O evento de logs transformado seria o seguinte.

{
  "outer_key": {
    "inner_key": "inner_value"
  }
}

upperCaseString

O processador upperCaseString converte uma string em sua versão em maiúsculas.

Campo	Description	Obrigatório?	Padrão	Limites
withKeys	Uma lista de chaves a serem convertidas em maiúsculas	Sim		Máximo de entradas: 10

Exemplo

Observe o exemplo de evento de logs a seguir:

{
    "outer_key": {
        "inner_key": "inner_value"
    }
}

A configuração do transformador é esta, usando upperCaseString com parseJSON:

[
    {
        "parseJSON": {}
    },
    {
        "upperCaseString": {
            "withKeys":["outer_key.inner_key"]
        }
    }
]

O evento de logs transformado seria o seguinte.

{
  "outer_key": {
    "inner_key": "INNER_VALUE"
  }
}

splitString

O processador splitString é um tipo de processador de mutação de string que divide um campo em uma matriz usando um caractere delimitador.

Campo	Description	Obrigatório?	Padrão	Limites
entries	Matriz de entradas. Cada item na matriz deve conter os campos source e delimiter.	Sim		Máximo de entradas: 10
origem	A chave do valor do campo a ser dividido	Sim		Tamanho máximo: 128
delimitador	A string delimitadora onde dividir o valor do campo	Sim		Tamanho máximo: 128

Exemplo 1

Observe o exemplo de evento de logs a seguir:

[
    {
        "parseJSON": {}
    },
    {
        "splitString": {
            "entries": [
                {
                    "source": "outer_key.inner_key",
                    "delimiter": "_"
                }
            ]
        }
    }
]

A configuração do transformador é esta, usando splitString com parseJSON:

[
     {
        "parseJSON": {}
    },
    {
         "splitString": {
            "entries": [
                {
                    "source": "outer_key.inner_key",
                    "delimiter": "_"
                }
            ]
        }
    }
]

O evento de logs transformado seria o seguinte.

{
  "outer_key": {
    "inner_key": [
      "inner",
      "value"
    ]
  }
}

Exemplo 2

O delimitador para dividir a string pode ter vários caracteres.

Observe o exemplo de evento de logs a seguir:

{
    "outer_key": {
        "inner_key": "item1, item2, item3"
    }
}

A configuração do transformador é a seguinte:

[
     {
        "parseJSON": {}
    },
    {
         "splitString": {
            "entries": [
                {
                    "source": "outer_key.inner_key",
                    "delimiter": ", "
                }
            ]
        }
    }
]

O evento de logs transformado seria o seguinte.

{
  "outer_key": {
    "inner_key": [
      "item1",
      "item2",
      "item3"
    ]
  }
}

substituteString

O processador substituteString é um tipo de processador de mutação de string que combina o valor de uma chave com uma expressão regular e substitui todas as correspondências por uma string de substituição.

Campo	Description	Obrigatório?	Padrão	Limites
entries	Matriz de entradas. Cada item na matriz deve conter os campos source, from e to.	Sim		Máximo de entradas: 10
origem	A chave do campo a ser modificado	Sim		Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
from	A string de expressão regular a ser substituída. Caracteres regex especiais, como [ e ], devem ser escapados usando \\ ao usar aspas duplas e com \ ao usar aspas simples ou quando configurados a partir do Console de gerenciamento da AWS. Para obter mais informações, consulte o Padrão de classe no site da Oracle. Você pode agrupar um padrão em (...) para criar um grupo de captura numerado e criar grupos de captura denominados (?P<group_name>...) que possam ser referenciados no campo to.	Sim		Tamanho máximo: 128
para	A string a ser substituída para cada correspondência de from. Podem ser usadas referências anteriores para os grupos de captura. Use o formulário $n para grupos numerados como $1, e use ${group_name} para grupos nomeados, como ${my_group}.>	Sim		Tamanho máximo: 128 Número máximo de referências anteriores: 10 Número máximo de referências anteriores duplicadas: 2

Exemplo 1

Observe o exemplo de evento de logs a seguir:

{
    "outer_key": {
        "inner_key1": "[]",
        "inner_key2": "123-345-567",
        "inner_key3": "A cat takes a catnap."
    }
}

A configuração do transformador é esta, usando substituteString com parseJSON:

[
    {
        "parseJSON": {}
    },
    {
        "substituteString": {
            "entries": [
                {
                    "source": "outer_key.inner_key1",
                    "from": "\\[\\]",
                    "to": "value1"
                },
                {
                    "source": "outer_key.inner_key2",
                    "from": "[0-9]{3}-[0-9]{3}-[0-9]{3}",
                    "to": "xxx-xxx-xxx"            
                },
                {
                    "source": "outer_key.inner_key3",
                    "from": "cat",
                    "to": "dog"            
                }
            ]
        }
    }
]

O evento de logs transformado seria o seguinte.

{
  "outer_key": {
    "inner_key1": "value1",
    "inner_key2": "xxx-xxx-xxx",
    "inner_key3": "A dog takes a dognap."
  }
}

Exemplo 2

Observe o exemplo de evento de logs a seguir:

{
    "outer_key": {
        "inner_key1": "Tom, Dick, and Harry",
        "inner_key2": "arn:aws:sts::123456789012:assumed-role/MyImportantRole/MySession"
    }
}

A configuração do transformador é esta, usando substituteString com parseJSON:

[
    {
        "parseJSON": {}
    },
    {
        "substituteString": {
            "entries": [
                {
                    "source": "outer_key.inner_key1",
                    "from": "(\w+), (\w+), and (\w+)",
                    "to": "$1 and $3"            
                },
                {
                    "source": "outer_key.inner_key2",
                    "from": "^arn:aws:sts::(?P<account_id>\\d{12}):assumed-role/(?P<role_name>[\\w+=,.@-]+)/(?P<role_session_name>[\\w+=,.@-]+)$",
                    "to": "${account_id}:${role_name}:${role_session_name}"
                }
            ]
        }
    }
]

O evento de logs transformado seria o seguinte.

{
  "outer_key": {
    "inner_key1": "Tom and Harry",
    "inner_key2": "123456789012:MyImportantRole:MySession"
  }
}

trimString

O processador trimString remove o espaço em branco do início e do fim de uma chave.

Campo	Description	Obrigatório?	Padrão	Limites
withKeys	Uma lista de chaves a serem tratadas	Sim		Máximo de entradas: 10

Exemplo

Observe o exemplo de evento de logs a seguir:

{
    "outer_key": {
        "inner_key": "   inner_value  "
    }
}

A configuração do transformador é esta, usando trimString com parseJSON:

[
    {
        "parseJSON": {}
    },
    {
        "trimString": {
            "withKeys":["outer_key.inner_key"]
        }
    }
]

O evento de logs transformado seria o seguinte.

{
  "outer_key": {
    "inner_key": "inner_value"
  }
}