Voorbeelden van telemetrieprocessor - Azure Monitor Application Insights voor Java

Artikel
09/13/2024

Dit artikel bevat voorbeelden van telemetrieprocessors in Application Insights voor Java, waaronder voorbeelden voor het opnemen en uitsluiten van configuraties. Het bevat ook voorbeelden voor kenmerkprocessors en spanprocessors.

Span-voorbeelden opnemen en uitsluiten

In deze sectie leert u hoe u spanten kunt opnemen en uitsluiten. U leert ook hoe u meerdere spanten uitsluit en selectieve verwerking toepast.

Inclusief spanten

In deze sectie ziet u hoe u spans voor een kenmerkprocessor kunt opnemen. De processor verwerkt geen spanten die niet overeenkomen met de eigenschappen.

Voor een overeenkomst moet de spannaam gelijk zijn aan spanA of spanB.

Deze reeksen komen overeen met de include eigenschappen en de processoracties worden toegepast:

Span1 Naam: 'spanA' Kenmerken: {env: dev, test_request: 123, credit_card: 1234}
Span2 Naam: 'spanB'-kenmerken: {env: dev, test_request: false}
Span3 Naam: 'spanA' Kenmerken: {env: 1, test_request: dev, credit_card: 1234}

Deze periode komt niet overeen met de include eigenschappen en de processoracties worden niet toegepast:

Span4 Naam: spanC-kenmerken: {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"
          }
        ]
      }
    ]
  }
}

Uitsluitbereiken

In deze sectie ziet u hoe u spans voor een kenmerkprocessor kunt uitsluiten. Deze processor verwerkt geen spanten die overeenkomen met de eigenschappen.

Voor een overeenkomst moet de spannaam gelijk zijn aan spanA of spanB.

De volgende reeksen komen overeen met de exclude eigenschappen en de processoracties worden niet toegepast:

Span1 Naam: 'spanA' Kenmerken: {env: dev, test_request: 123, credit_card: 1234}
Span2 Naam: 'spanB'-kenmerken: {env: dev, test_request: false}
Span3 Naam: 'spanA' Kenmerken: {env: 1, test_request: dev, credit_card: 1234}

Deze periode komt niet overeen met de exclude eigenschappen en de processoracties worden toegepast:

Span4 Naam: spanC-kenmerken: {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"
          }
        ]
      }
    ]
  }
}

Spanen uitsluiten met behulp van meerdere criteria

In deze sectie ziet u hoe u spans voor een kenmerkprocessor kunt uitsluiten. Deze processor verwerkt geen spanten die overeenkomen met de eigenschappen.

Voor een overeenkomst moeten de volgende voorwaarden worden voldaan:

Er moet een kenmerk (bijvoorbeeld env met waarde dev) aanwezig zijn in het bereik.
Het bereik moet een kenmerk hebben dat sleutel test_requestheeft.

De volgende reeksen komen overeen met de exclude eigenschappen en de processoracties worden niet toegepast.

Span1 Naam: 'spanB' Kenmerken: {env: dev, test_request: 123, credit_card: 1234}
Span2 Naam: 'spanA'-kenmerken: {env: dev, test_request: false}

De volgende periode komt niet overeen met de exclude eigenschappen en de processoracties worden toegepast:

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

Selectieve verwerking

In deze sectie ziet u hoe u de set spaneigenschappen opgeeft waarop wordt aangegeven waarop deze processor moet worden toegepast. De include eigenschappen geven aan welke periodes moeten worden verwerkt. De exclude eigenschappen worden uitgefilterd en moeten niet worden verwerkt.

In de volgende configuratie komen deze overeen met de eigenschappen en worden processoracties toegepast:

Span1 Naam: 'spanB' Kenmerken: {env: production, test_request: 123, credit_card: 1234, redact_trace: "false"}
Span2 Naam: 'spanA'-kenmerken: {env: fasering, test_request: false, redact_trace: true}

Deze reeksen komen niet overeen met de include eigenschappen en processoracties worden niet toegepast:

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

Voorbeelden van kenmerkprocessor

Invoegen

In het volgende voorbeeld wordt het nieuwe kenmerk {"attribute1": "attributeValue1"} ingevoegd in spans en logboeken waarin de sleutel attribute1 niet bestaat.

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

Invoegen vanuit een andere sleutel

In het volgende voorbeeld wordt de waarde van het kenmerk anotherkey gebruikt om het nieuwe kenmerk {"newKey": "<value from attribute anotherkey>"} in spans en logboeken in te voegen waarin de sleutel newKey niet bestaat. Als het kenmerk anotherkey niet bestaat, wordt er geen nieuw kenmerk ingevoegd in spans en logboeken.

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

Bijwerken

In het volgende voorbeeld wordt het kenmerk bijgewerkt naar {"db.secret": "redacted"}. Het kenmerk boo wordt bijgewerkt met behulp van de waarde van het kenmerk foo. Spans en logboeken die niet over het kenmerk boo beschikken, worden niet gewijzigd.

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

In het volgende voorbeeld ziet u hoe u een kenmerk verwijdert dat de sleutel credit_cardbevat.

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

Hash

In het volgende voorbeeld ziet u hoe u bestaande kenmerkwaarden kunt hashen.

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

Extraheren

In het volgende voorbeeld ziet u hoe u een reguliere expressie (regex) gebruikt om nieuwe kenmerken te maken op basis van de waarde van een ander kenmerk. De volgende kenmerken worden bijvoorbeeld url.path = /path?queryParam1=value1,queryParam2=value2ingevoegd:

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

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

Masker

Gegeven wordt bijvoorbeeld url.path = https://example.com/user/12345622 bijgewerkt naar url.path = https://example.com/user/**** het gebruik van een van de onderstaande configuraties.

Eerste configuratievoorbeeld:

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

Tweede configuratievoorbeeld met de naam van de reguliere expressiegroep:

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

Voorbeelden van niet-getypeerde kenmerken

Vanaf 3.4.19 GA ondersteunen telemetrieprocessors niet-getypte kenmerken: boolean, , doublelong, boolean-array, , double-arrayen long-arraystring-array.

Wanneer attributes.type wordt niet opgegeven in de json, is deze standaard ingesteld op string.

In het volgende voorbeeld wordt het nieuwe kenmerk {"newAttributeKeyStrict": "newAttributeValueStrict"} ingevoegd in spans en logboeken waarin de kenmerken overeenkomen met de volgende voorbeelden: {"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"
      }
    ]
  }
}

Daarnaast ondersteunen regexpniet-getypte kenmerken .

In het volgende voorbeeld wordt het nieuwe kenmerk {"newAttributeKeyRegexp": "newAttributeValueRegexp"} ingevoegd in spans en logboeken waarin het kenmerk longRegexpAttributeKey overeenkomt met de waarde van waaruit 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"
      }
    ]
  }
}

Spanprocessorvoorbeelden

Een spannaam opgeven

In het volgende voorbeeld worden de waarden van kenmerken db.svc, operationen id. Het vormt de nieuwe naam van het bereik met behulp van deze kenmerken, in die volgorde, gescheiden door de waarde ::.

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

Kenmerken extraheren uit een spannaam

Stel dat de naam van de invoerspanne is /api/v1/document/12345678/update. Het volgende voorbeeld resulteert in de naam /api/v1/document/{documentId}/updatevan het uitvoerbereik. Hiermee wordt het nieuwe kenmerk documentId=12345678 toegevoegd aan het bereik.

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

Kenmerken uit een spannaam extraheren met behulp van opnemen en uitsluiten

In het volgende voorbeeld ziet u hoe u de spannaam wijzigt in {operation_website}. Er wordt een kenmerk met sleutel operation_website en waarde {oldSpanName} toegevoegd wanneer het bereik de volgende eigenschappen heeft:

De spannaam bevat / een willekeurige plaats in de tekenreeks.
De spannaam is niet 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>.*?)$"
            ]
          }
        }
      }
    ]
  }
}

Voorbeelden van logboekprocessor

Kenmerken extraheren uit de hoofdtekst van een logboekbericht

Stel dat de hoofdtekst van het invoerlogboekbericht is Starting PetClinicApplication on WorkLaptop with PID 27984 (C:\randompath\target\classes started by userx in C:\randompath). Het volgende voorbeeld resulteert in de hoofdtekst Starting PetClinicApplication on WorkLaptop with PID {PIDVALUE} (C:\randompath\target\classes started by userx in C:\randompath)van het uitvoerbericht. Het nieuwe kenmerk PIDVALUE=27984 wordt toegevoegd aan het logboek.

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

Gevoelige gegevens in logboekbericht maskeren

In het volgende voorbeeld ziet u hoe u gevoelige gegevens in een hoofdtekst van een logboekbericht kunt maskeren met behulp van zowel logboekprocessor als kenmerkprocessor. Stel dat de hoofdtekst van het invoerlogboekbericht is User account with userId 123456xx failed to login. De hoofdtekst van het uitvoerbericht User account with userId {redactedUserId} failed to login wordt bijgewerkt met de logboekprocessor en de kenmerkprocessor verwijdert het nieuwe kenmerk redactedUserId, dat in de vorige stap werd toegevoegd.

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

Veelgestelde vragen

Waarom verwerkt de logboekprocessor logboekbestanden niet met behulp van TelemetryClient.trackTrace()?

TelemetryClient.trackTrace() maakt deel uit van de klassieke Application Insights SDK-brug en de logboekprocessors werken alleen met de nieuwe op OpenTelemetry gebaseerde instrumentatie.

Delen via