Exemples de processeurs de télémétrie - Azure Monitor Application Insights pour Java

Article
10/15/2024

Cet article fournit des exemples de processeurs de télémétrie dans Application Insights pour Java, notamment des exemples pour les configurations d’inclusion et d’exclusion. Cela inclut également des exemples pour les processeurs d’attributs et les processeurs d’étendue.

Exemples d’inclusion et d’exclusion d’étendues

Dans cette section, découvrez comment inclure et exclure des étendues. Vous verrez également comment exclure plusieurs étendues et appliquer un traitement sélectif.

Inclure des étendues

Cette section montre comment inclure des étendues pour un processeur d’attributs. Le processeur ne traite pas les étendues qui ne correspondent pas aux propriétés.

Une correspondance exige que le nom de l’étendue soit égal à spanA ou spanB.

Ces étendues correspondent aux propriétés include et les actions de processeur sont appliquées :

Span1 Nom : Attributs « spanA » : {env : dev, test_request : 123, credit_card : 1234}
Span2 Nom : Attributs « spanB » : {env : dev, test_request : false}
Span3 Nom : Attributs « spanA » : {env : 1, test_request : dev, credit_card : 1234}

Cette étendue ne correspond pas aux propriétés include et les actions du processeur ne sont pas appliquées :

Span4 Name: 'spanC' Attributes: {env: dev, test_request: false}

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "attribute",
        "include": {
          "matchType": "strict",
          "spanNames": [
            "spanA",
            "spanB"
          ]
        },
        "actions": [
          {
            "key": "credit_card",
            "action": "delete"
          }
        ]
      }
    ]
  }
}

Exclure des étendues

Cette section montre comment exclure des étendues pour un processeur d’attributs. Ce processeur ne traite pas les étendues qui correspondent aux propriétés.

Une correspondance exige que le nom de l’étendue soit égal à spanA ou spanB.

Les étendues suivantes correspondent aux propriétés exclude et les actions du processeur ne sont pas appliquées :

Span1 Nom : Attributs « spanA » : {env : dev, test_request : 123, credit_card : 1234}
Span2 Nom : Attributs « spanB » : {env : dev, test_request : false}
Span3 Nom : Attributs « spanA » : {env : 1, test_request : dev, credit_card : 1234}

Cette étendue ne correspond pas aux propriétés exclude et les actions du processeur sont appliquées :

Span4 Name: 'spanC' Attributes: {env: dev, test_request: false}

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "attribute",
        "exclude": {
          "matchType": "strict",
          "spanNames": [
            "spanA",
            "spanB"
          ]
        },
        "actions": [
          {
            "key": "credit_card",
            "action": "delete"
          }
        ]
      }
    ]
  }
}

Exclure des étendues à l’aide de plusieurs critères

Cette section montre comment exclure des étendues pour un processeur d’attributs. Ce processeur ne traite pas les étendues qui correspondent aux propriétés.

Une correspondance requiert que les conditions suivantes soient remplies :

Il faut qu’un attribut (par exemple env avec la valeur dev) existe dans l’étendue.
L’étendue doit avoir un attribut qui a la clé test_request.

Les étendues suivantes correspondent aux propriétés exclude et les actions du processeur ne sont pas appliquées.

Span1 Nom : Attributs « spanB » : {env : dev, test_request : 123, credit_card : 1234}
Span2 Nom : Attributs « spanA » : {env : dev, test_request : false}

Les étendues suivantes ne correspondent pas aux propriétés exclude et les actions du processeur sont appliquées :

Span3 Nom : Attributs « spanB » : {env : 1, test_request : dev, credit_card : 1234}
Span4 Name: 'spanC' Attributes: {env: dev, dev_request: false}

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "attribute",
        "exclude": {
          "matchType": "strict",
          "spanNames": [
            "spanA",
            "spanB"
          ],
          "attributes": [
            {
              "key": "env",
              "value": "dev"
            },
            {
              "key": "test_request"
            }
          ]
        },
        "actions": [
          {
            "key": "credit_card",
            "action": "delete"
          }
        ]
      }
    ]
  }
}

Traitement sélectif

Cette section montre comment spécifier le jeu de propriétés d’étendue qui indiquent les étendues auxquelles ce processeur doit être appliqué. Les propriétés include indiquent les étendues à traiter. Les propriétés exclude filtrent les étendues qui ne doivent pas être traitées.

Dans la configuration suivante, les étendues correspondent aux propriétés et les actions du processeur sont appliquées :

Span1Nom : Attributs « spanB » : {env: production, test_request: 123, credit_card: 1234, redact_trace: "false"}
Span2 Nom : Attributs « spanA » : {env : staging, test_request : false, redact_trace : true}

Ces étendues ne correspondent pas aux propriétés include et les actions du processeur ne sont pas appliquées :

Span3Nom : Attributs « spanB » : {env: production, test_request: true, credit_card: 1234, redact_trace: false}
Span4 Name: 'spanC' Attributes: {env: dev, test_request: false}

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "attribute",
        "include": {
          "matchType": "strict",
          "spanNames": [
            "spanA",
            "spanB"
          ]
        },
        "exclude": {
          "matchType": "strict",
          "attributes": [
            {
              "key": "redact_trace",
              "value": "false"
            }
          ]
        },
        "actions": [
          {
            "key": "credit_card",
            "action": "delete"
          },
          {
            "key": "duplicate_key",
            "action": "delete"
          }
        ]
      }
    ]
  }
}

Exemples de processeurs d’attributs

Insérer

L’exemple suivant insère le nouvel attribut {"attribute1": "attributeValue1"} dans des étendues et des journaux où la clé attribute1 n’existe pas.

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "attribute",
        "actions": [
          {
            "key": "attribute1",
            "value": "attributeValue1",
            "action": "insert"
          }
        ]
      }
    ]
  }
}

Insérer à partir d’une autre clé

L’exemple suivant utilise la valeur de l’attribut anotherkey pour insérer le nouvel attribut {"newKey": "<value from attribute anotherkey>"} dans des étendues et des journaux où la clé newKey n’existe pas. Si l’attribut anotherkey n’existe pas, aucun nouvel attribut n’est inséré dans les étendues et journaux.

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "attribute",
        "actions": [
          {
            "key": "newKey",
            "fromAttribute": "anotherKey",
            "action": "insert"
          }
        ]
      }
    ]
  }
}

Update

L’exemple suivant met à jour l’attribut avec la valeur {"db.secret": "redacted"}. Il met à jour l’attribut boo en utilisant la valeur de l’attribut foo. Les étendues et journaux qui ne possèdent pas l’attribut boo ne changent pas.

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "attribute",
        "actions": [
          {
            "key": "db.secret",
            "value": "redacted",
            "action": "update"
          },
          {
            "key": "boo",
            "fromAttribute": "foo",
            "action": "update" 
          }
        ]
      }
    ]
  }
}

DELETE

L’exemple suivant montre comment supprimer un attribut qui a la clé credit_card.

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "attribute",
        "actions": [
          {
            "key": "credit_card",
            "action": "delete"
          }
        ]
      }
    ]
  }
}

Hachage

L’exemple suivant montre comment hacher des valeurs d’attribut existantes.

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "attribute",
        "actions": [
          {
            "key": "user.email",
            "action": "hash"
          }
        ]
      }
    ]
  }
}

Extract

L’exemple suivant montre comment utiliser une expression régulière (regex) pour créer de nouveaux attributs basés sur la valeur d’un autre attribut. Par exemple, avec url.path = /path?queryParam1=value1,queryParam2=value2, les attributs suivants sont insérés :

httpProtocol : http
httpDomain : example.com
httpPath : path
httpQueryParams : queryParam1=value1,queryParam2=value2
url.path : aucune modification

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "attribute",
        "actions": [
          {
            "key": "url.path",
            "pattern": "^(?<httpProtocol>.*):\\/\\/(?<httpDomain>.*)\\/(?<httpPath>.*)(\\?|\\&)(?<httpQueryParams>.*)",
            "action": "extract"
          }
        ]
      }
    ]
  }
}

Mask

Par exemple, étant donné que url.path = https://example.com/user/12345622 est mis à jour pour url.path = https://example.com/user/**** à l’aide de l’une des configurations ci-dessous.

Premier exemple de configuration :

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "attribute",
        "actions": [
          {
            "key": "url.path",
            "pattern": "user\\/\\d+",
            "replace": "user\\/****",
            "action": "mask"
          }
        ]
      }
    ]
  }
}

Deuxième exemple de configuration avec le nom du groupe d’expressions régulières :

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "attribute",
        "actions": [
          {
            "key": "url.path",
            "pattern": "^(?<userGroupName>[a-zA-Z.:\/]+)\d+",
            "replace": "${userGroupName}**",
            "action": "mask"
          }
        ]
      }
    ]
  }
}

Exemples d’attributs typés sans chaîne

À partir de la version 3.4.19 GA, les processeurs de télémétrie prennent en charge les attributs typés sans chaîne : boolean, double, long, boolean-array, double-array, long-arrayet string-array.

Lorsque attributes.type n’est pas fourni dans le json, il prend par défaut la valeur string.

L’exemple suivant insère le nouvel attribut {"newAttributeKeyStrict": "newAttributeValueStrict"} dans des étendues et des journaux où les attributs correspondent aux exemples suivants : {"longAttributeKey": 1234}{"booleanAttributeKey": true}{"doubleArrayAttributeKey": [1.0, 2.0, 3.0, 4.0]}

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "attribute",
        "include": {
          "matchType": "strict",
          "attributes": [
            {
              "key": "longAttributeKey",
              "value": 1234,
              "type": "long"
            },
            {
              "key": "booleanAttributeKey",
              "value": true,
              "type": "boolean"
            },
            {
              "key": "doubleArrayAttributeKey",
              "value": [1.0, 2.0, 3.0, 4.0],
              "type": "double-array"
            }
          ]
        },
        "actions": [
          {
            "key": "newAttributeKeyStrict",
            "value": "newAttributeValueStrict",
            "action": "insert"
          }
        ],
        "id": "attributes/insertNewAttributeKeyStrict"
      }
    ]
  }
}

De plus, les attributs typés sans chaîne prennent en charge regexp.

L’exemple suivant insère le nouvel attribut {"newAttributeKeyRegexp": "newAttributeValueRegexp"} dans des étendues et des journaux où l’attribut longRegexpAttributeKey correspond à la valeur de 400 à 499.

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "attribute",
        "include": {
          "matchType": "regexp",
          "attributes": [
            {
              "key": "longRegexpAttributeKey",
              "value": "4[0-9][0-9]",
              "type": "long"
            }
          ]
        },
        "actions": [
          {
            "key": "newAttributeKeyRegexp",
            "value": "newAttributeValueRegexp",
            "action": "insert"
          }
        ],
        "id": "attributes/insertNewAttributeKeyRegexp"
      }
    ]
  }
}

Exemples de processeurs d’étendue

Nommer une étendue

L’exemple suivant spécifie les valeurs des attributs db.svc, operation et id. Il forme le nouveau nom de l’étendue en utilisant ces attributs, dans cet ordre, séparés par la valeur ::.

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "span",
        "name": {
          "fromAttributes": [
            "db.svc",
            "operation",
            "id"
          ],
          "separator": "::"
        }
      }
    ]
  }
}

Extraire des attributs d’un nom d’étendue

Supposons que le nom d’étendue en entrée est /api/v1/document/12345678/update. L’exemple suivant donne le nom d’étendue en sortie /api/v1/document/{documentId}/update. Il ajoute le nouvel attribut documentId=12345678 à l’étendue.

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "span",
        "name": {
          "toAttributes": {
            "rules": [
              "^/api/v1/document/(?<documentId>.*)/update$"
            ]
          }
        }
      }
    ]
  }
}

Extraire des attributs d’un nom d’étendue avec les opérations d’inclusion (include) et d’exclusion (exclude)

L’exemple suivant montre comment modifier le nom d’étendue en {operation_website}. Il ajoute un attribut avec la clé operation_website et la valeur {oldSpanName} lorsque l’étendue a les propriétés suivantes :

Le nom d’étendue contient / dans la chaîne.
Le nom d’étendue n’est pas donot/change.

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "span",
        "include": {
          "matchType": "regexp",
          "spanNames": [
            "^(.*?)/(.*?)$"
          ]
        },
        "exclude": {
          "matchType": "strict",
          "spanNames": [
            "donot/change"
          ]
        },
        "name": {
          "toAttributes": {
            "rules": [
              "(?<operation_website>.*?)$"
            ]
          }
        }
      }
    ]
  }
}

Exemples de processeurs de journaux

Extraction des attributs du corps d’un message de journal

Supposons que le corps du message de journal d’entrée soit Starting PetClinicApplication on WorkLaptop with PID 27984 (C:\randompath\target\classes started by userx in C:\randompath). L’exemple suivant donne en sortie le corps du message Starting PetClinicApplication on WorkLaptop with PID {PIDVALUE} (C:\randompath\target\classes started by userx in C:\randompath). Il ajoute le nouvel attribut PIDVALUE=27984 au journal.

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "log",
        "body": {
          "toAttributes": {
            "rules": [
              "^Starting PetClinicApplication on WorkLaptop with PID (?<PIDVALUE>\\d+) .*"
            ]
          }
        }
      }
    ]
  }
}

Masquage de données sensibles dans un message de journal

L’exemple suivant montre comment masquer les données sensibles dans le corps d’un message de journal à l’aide du processeur de journaux et du processeur d’attributs. Supposons que le corps du message de journal d’entrée soit User account with userId 123456xx failed to login. Le processeur de journaux remplace le corps du message de sortie par User account with userId {redactedUserId} failed to login. Le processeur d’attributs, lui, supprime le nouvel attribut redactedUserId, qui a été ajouté à l’étape précédente.

{
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000",
  "preview": {
    "processors": [
      {
        "type": "log",
        "body": {
          "toAttributes": {
            "rules": [
              "userId (?<redactedUserId>[0-9a-zA-Z]+)"
            ]
          }
        }
      },
      {
        "type": "attribute",
        "actions": [
          {
            "key": "redactedUserId",
            "action": "delete"
          }
        ]
      }
    ]
  }
}

Forum aux questions

Pourquoi le processeur de journaux ne traite-t-il pas les fichiers journaux en utilisant TelemetryClient.trackTrace() ?

TelemetryClient.trackTrace() fait partie du pont du SDK classique Application Insights, et les processeurs de journaux fonctionnent uniquement avec la nouvelle instrumentation basée sur OpenTelemetry.

Partager via