Esempi di processore di telemetria - Application Insights di Azure Monitor per Java

Questo articolo fornisce esempi di processori di telemetria in Application Insights per Java, inclusi gli esempi per includere ed escludere configurazioni. Include anche esempi per processori di attributi e processori di span.

Includere ed escludere esempi Span

In questa sezione viene illustrato come includere ed escludere gli span. Si apprenderà anche come escludere più span e applicare l'elaborazione selettiva.

Includi span

Questa sezione illustra come includere gli span per un processore di attributi. Il processore non elabora segmenti che non corrispondono alle proprietà.

Una corrispondenza richiede che il nome span sia uguale a spanA o spanB.

Questi intervalli corrispondono alle proprietà di include e vengono applicate le azioni del processore:

Span1 Nome: 'spanA' Attributi: {env: dev, test_request: 123, credit_card: 1234}
Nome: Span2 'spanB' Attributi: {env: dev, test_request: false}
Span3 Nome: 'spanA' Attributi: {env: 1, test_request: dev, credit_card: 1234}

Questo span non corrisponde alle proprietà include e le azioni del processore non vengono applicate:

Span4 Nome: 'spanC' Attributi: {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"
          }
        ]
      }
    ]
  }
}

Escludi span

Questa sezione illustra come escludere gli span per un processore di attributi. Questo processore non elabora span che corrispondono alle proprietà.

Una corrispondenza richiede che il nome span sia uguale a spanA o spanB.

Gli span seguenti corrispondono alle proprietà exclude e le azioni del processore non vengono applicate:

Span1 Nome: 'spanA' Attributi: {env: dev, test_request: 123, credit_card: 1234}
Nome: Span2 'spanB' Attributi: {env: dev, test_request: false}
Span3 Nome: 'spanA' Attributi: {env: 1, test_request: dev, credit_card: 1234}

Questo span non corrisponde alle proprietà exclude e vengono applicate le azioni del processore:

Span4 Nome: 'spanC' Attributi: {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"
          }
        ]
      }
    ]
  }
}

Escludere gli intervalli usando più criteri

Questa sezione illustra come escludere gli span per un processore di attributi. Questo processore non elabora span che corrispondono alle proprietà.

Una partita richiede che vengano soddisfatte le condizioni seguenti:

Nello span deve esistere un attributo (ad esempio env con valore dev).
Lo span deve avere un attributo con chiave test_request.

Gli span seguenti corrispondono alle proprietà exclude e le azioni del processore non vengono applicate.

Span1 Nome: 'spanB' Attributi: {env: dev, test_request: 123, credit_card: 1234}
Span2 Nome: 'spanA' Attributi: {env: dev, test_request: false}

Lo span seguente non corrisponde alle proprietà exclude e vengono applicate le azioni del processore:

Span3 Nome: 'spanB' Attributi: {env: 1, test_request: dev, credit_card: 1234}
Span4 Nome: 'spanC' Attributi: {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"
          }
        ]
      }
    ]
  }
}

Elaborazione selettiva

Questa sezione illustra come specificare l'insieme di proprietà degli intervalli che indicano a quali intervalli deve essere applicato questo processore. Le proprietà include indicano quali intervalli devono essere elaborati. Le proprietà exclude filtrano gli intervalli che non devono essere elaborati.

Nella configurazione seguente, questi span corrispondono alle proprietà e vengono applicate le azioni del processore:

Nome Span1: attributi 'spanB': {env: production, test_request: 123, credit_card: 1234, redact_trace: "false"}
Nome Span2: attributi 'spanA': {env: staging, test_request: false, redact_trace: true}

Questi intervalli non corrispondono alle proprietà include e le azioni del processore non vengono applicate:

Nome Span3: attributi 'spanB': {env: production, test_request: true, credit_card: 1234, redact_trace: false}
Span4 Nome: 'spanC' Attributi: {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"
          }
        ]
      }
    ]
  }
}

Esempi di processore di attributi

Inserire

L'esempio seguente inserisce il nuovo attributo {"attribute1": "attributeValue1"} in span e log in cui la chiave attribute1 non esiste.

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

Inserisci da un'altra chiave

Nell'esempio seguente viene usato il valore dell'attributo anotherkey per inserire il nuovo attributo {"newKey": "<value from attribute anotherkey>"} in span e log in cui la chiave newKey non esiste. Se l'attributo anotherkey non esiste, in span e log non viene inserito alcun nuovo attributo.

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

Aggiornamento

L'esempio seguente aggiorna l'attributo a {"db.secret": "redacted"}. Aggiorna l'attributo boo usando il valore dell'attributo foo. Gli span e i log che non hanno l'attributo boo non cambiano.

{
  "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" 
          }
        ]
      }
    ]
  }
}

Elimina

Nell'esempio seguente viene illustrato come eliminare un attributo che ha la chiave credit_card.

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

Hash

Nell'esempio seguente viene illustrato come eseguire l'hash dei valori di attributo esistenti.

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

Estratto

Nell'esempio seguente viene illustrato come usare un'espressione regolare (regex) per creare nuovi attributi in base al valore di un altro attributo. Ad esempio, se url.path = /path?queryParam1=value1,queryParam2=value2, vengono inseriti gli attributi seguenti:

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

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

Maschera

Ad esempio, se url.path = https://example.com/user/12345622 viene aggiornato a url.path = https://example.com/user/**** usando una delle configurazioni seguenti.

Primo esempio di configurazione:

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

Secondo esempio di configurazione con il nome del gruppo di espressioni regolari:

{
  "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"
          }
        ]
      }
    ]
  }
}

Esempi di attributi tipizzati non stringa

A partire dalla versione 3.4.19 GA, i processori di telemetria supportano attributi non tipizzati stringa: boolean, double, long, boolean-array, double-array, long-array e string-array.

Quando attributes.type non viene fornito nel file JSON, per impostazione predefinita è string.

L'esempio seguente inserisce il nuovo attributo {"newAttributeKeyStrict": "newAttributeValueStrict"} negli span e log in cui gli attributi corrispondono agli esempi seguenti: {"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"
      }
    ]
  }
}

Inoltre, gli attributi tipizzati non stringa supportano regexp.

Nell'esempio seguente il nuovo attributo {"newAttributeKeyRegexp": "newAttributeValueRegexp"} viene inserito negli span e log in cui l'attributo longRegexpAttributeKey corrisponde al valore da 400 a 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"
      }
    ]
  }
}

Esempi di processori di span

Assegna un nome a un intervallo

Nell'esempio seguente vengono specificati i valori degli attributi db.svc, operation e id. Forma il nuovo nome dello span usando tali attributi, in tale ordine, separati dal valore ::.

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

Estrarre attributi da un nome span

Si supponga che il nome dello span di input sia /api/v1/document/12345678/update. Nell'esempio seguente viene restituito il nome dello span di output /api/v1/document/{documentId}/update. Aggiunge allo span il nuovo attributo documentId=12345678.

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

Estrarre gli attributi da un nome di span usando includi ed escludi

Nell'esempio seguente viene illustrato come modificare il nome dello span in {operation_website}. Aggiunge un attributo con chiave operation_website e valore {oldSpanName} quando lo span ha le proprietà seguenti:

Il nome dello span contiene / in un punto qualsiasi della stringa.
Il nome dello span non è 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>.*?)$"
            ]
          }
        }
      }
    ]
  }
}

Esempi di processore di log

Estrarre attributi dal corpo del messaggio di log

Si supponga che il corpo del messaggio del log di input sia Starting PetClinicApplication on WorkLaptop with PID 27984 (C:\randompath\target\classes started by userx in C:\randompath). Nell'esempio seguente viene restituito il corpo del messaggio di output Starting PetClinicApplication on WorkLaptop with PID {PIDVALUE} (C:\randompath\target\classes started by userx in C:\randompath). Aggiunge al log il nuovo attributo PIDVALUE=27984.

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

Mascherare i dati sensibili nel messaggio di log

L'esempio seguente illustra come mascherare i dati sensibili in un corpo del messaggio di log usando sia il processore di log che il processore di attributi. Si supponga che il corpo del messaggio del log di input sia User account with userId 123456xx failed to login. Il processore di log aggiorna il corpo del messaggio di output in User account with userId {redactedUserId} failed to login e il processore di attributi elimina il nuovo attributo redactedUserId, che è stato aggiunto nel passaggio precedente.

{
  "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"
          }
        ]
      }
    ]
  }
}

Passaggi successivi

Per esaminare le domande frequenti, vedere Domande frequenti sul processore di telemetria

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-05-24