Exemples de processeurs de télémétrie - Azure Monitor Application Insights pour Java
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 :
Span1Nom : Attributs « spanA » : {env : dev, test_request : 123, credit_card : 1234}Span2Nom : Attributs « spanB » : {env : dev, test_request : false}Span3Nom : 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 :
Span4Name: '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 :
Span1Nom : Attributs « spanA » : {env : dev, test_request : 123, credit_card : 1234}Span2Nom : Attributs « spanB » : {env : dev, test_request : false}Span3Nom : 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 :
Span4Name: '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
envavec la valeurdev) 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.
Span1Nom : Attributs « spanB » : {env : dev, test_request : 123, credit_card : 1234}Span2Nom : 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 :
Span3Nom : Attributs « spanB » : {env : 1, test_request : dev, credit_card : 1234}Span4Name: '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"}Span2Nom : 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}Span4Name: '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.
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour