Exempel på telemetriprocessor – Azure Monitor Application Insights för Java

Artikel
01/31/2025

Den här artikeln innehåller exempel på telemetriprocessorer i Application Insights för Java, inklusive exempel för att inkludera och exkludera konfigurationer. Den innehåller även exempel för attributprocessorer och spänner över processorer.

Ta med och exkludera Span-exempel

I det här avsnittet lär du dig att inkludera och exkludera intervall. Du får också lära dig hur du undantar flera intervall och tillämpar selektiv bearbetning.

Inkludera intervall

Det här avsnittet visar hur du inkluderar intervall för en attributprocessor. Processorn bearbetar inte intervall som inte matchar egenskaperna.

En matchning kräver att spannamnet är lika med spanA eller spanB.

Dessa intervall matchar include egenskaperna och processoråtgärderna tillämpas:

Span1 Namn: SpanA-attribut: {env: dev, test_request: 123, credit_card: 1234}
Span2 Namn: "spanB"-attribut: {env: dev, test_request: false}
Span3 Namn: SpanA-attribut: {env: 1, test_request: dev, credit_card: 1234}

Det här intervallet matchar include inte egenskaperna och processoråtgärderna tillämpas inte:

Span4 Namn: "spanC"-attribut: {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"
          }
        ]
      }
    ]
  }
}

Exkludera intervall

Det här avsnittet visar hur du exkluderar intervall för en attributprocessor. Den här processorn bearbetar inte intervall som matchar egenskaperna.

En matchning kräver att spannamnet är lika med spanA eller spanB.

Följande intervall matchar exclude egenskaperna och processoråtgärderna tillämpas inte:

Span1 Namn: SpanA-attribut: {env: dev, test_request: 123, credit_card: 1234}
Span2 Namn: "spanB"-attribut: {env: dev, test_request: false}
Span3 Namn: SpanA-attribut: {env: 1, test_request: dev, credit_card: 1234}

Det här intervallet matchar exclude inte egenskaperna och processoråtgärderna tillämpas:

Span4 Namn: "spanC"-attribut: {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"
          }
        ]
      }
    ]
  }
}

Exkludera intervall med hjälp av flera villkor

Det här avsnittet visar hur du exkluderar intervall för en attributprocessor. Den här processorn bearbetar inte intervall som matchar egenskaperna.

En matchning kräver att följande villkor uppfylls:

Ett attribut (till exempel env med värde dev) måste finnas i intervallet.
Intervallet måste ha ett attribut som har nyckeln test_request.

Följande intervall matchar exclude egenskaperna och processoråtgärderna tillämpas inte.

Span1 Namn: SpanB-attribut: {env: dev, test_request: 123, credit_card: 1234}
Span2 Namn: SpanA-attribut: {env: dev, test_request: false}

Följande intervall matchar exclude inte egenskaperna och processoråtgärderna tillämpas:

Span3 Namn: SpanB-attribut: {env: 1, test_request: dev, credit_card: 1234}
Span4 Namn: "spanC"-attribut: {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"
          }
        ]
      }
    ]
  }
}

Selektiv bearbetning

Det här avsnittet visar hur du anger den uppsättning span-egenskaper som anger vilka intervall som processorn ska tillämpas på. Egenskaperna include anger vilka intervall som ska bearbetas. Egenskaperna exclude filtrerar bort intervall som inte ska bearbetas.

I följande konfiguration matchar dessa intervall egenskaperna och processoråtgärder tillämpas:

Span1 Namn: SpanB-attribut: {env: production, test_request: 123, credit_card: 1234, redact_trace: "false"}
Span2 Namn: SpanA-attribut: {env: mellanlagring, test_request: false, redact_trace: true}

Dessa intervall matchar include inte egenskaperna och processoråtgärder tillämpas inte:

Span3 Namn: SpanB-attribut: {env: production, test_request: true, credit_card: 1234, redact_trace: false}
Span4 Namn: "spanC"-attribut: {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"
          }
        ]
      }
    ]
  }
}

Exempel på attributprocessor

Infoga

Följande exempel infogar det nya attributet {"attribute1": "attributeValue1"} i intervall och loggar där nyckeln attribute1 inte finns.

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

Infoga från en annan nyckel

I följande exempel används värdet från attributet anotherkey för att infoga det nya attributet {"newKey": "<value from attribute anotherkey>"} i intervall och loggar där nyckeln newKey inte finns. Om attributet anotherkey inte finns infogas inget nytt attribut i intervall och loggar.

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

Uppdatera

Följande exempel uppdaterar attributet till {"db.secret": "redacted"}. Det uppdaterar attributet boo med hjälp av värdet från attributet foo. Intervall och loggar som inte har attributet boo ändras inte.

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

Följande exempel visar hur du tar bort ett attribut som har nyckeln credit_card.

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

Hash

Följande exempel visar hur du hash befintliga attributvärden.

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

Extrahera

Följande exempel visar hur du använder ett reguljärt uttryck (regex) för att skapa nya attribut baserat på värdet för ett annat attribut. Till exempel url.path = /path?queryParam1=value1,queryParam2=value2infogas följande attribut:

httpProtocol: http
httpDomain: example.com
httpPath: path
httpQueryParams: queryParam1=value1,queryParam2=value2
url.path: ingen ändring

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

Mask

Angiven url.path = https://example.com/user/12345622 uppdateras till exempel till att url.path = https://example.com/user/**** använda någon av konfigurationerna nedan.

Första konfigurationsexemplet:

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

Andra konfigurationsexemplet med gruppnamn för reguljärt uttryck:

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

Exempel på inskrivna attribut som inte har angetts

Från och med 3.4.19 GA har telemetriprocessorer stöd för icke-teckentypade attribut: boolean, double, long, boolean-array, double-array, long-arrayoch string-array.

När attributes.type anges inte i json är det standardvärdet string.

Följande exempel infogar det nya attributet {"newAttributeKeyStrict": "newAttributeValueStrict"} i intervall och loggar där attributen matchar följande exempel: {"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"
      }
    ]
  }
}

Dessutom stöder regexpicke-instrukna typattribut .

Följande exempel infogar det nya attributet {"newAttributeKeyRegexp": "newAttributeValueRegexp"} i intervall och loggar där attributet longRegexpAttributeKey matchar värdet från 400 till 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"
      }
    ]
  }
}

Spänn över processorexempel

Namnge ett intervall

Följande exempel anger värdena för attributen db.svc, operationoch id. Det bildar det nya namnet på intervallet med hjälp av dessa attribut, i den ordningen, avgränsade med värdet ::.

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

Extrahera attribut från ett spannnamn

Anta att namnet på indataintervallet är /api/v1/document/12345678/update. Följande exempel resulterar i namnet /api/v1/document/{documentId}/updatepå utdataintervallet . Det lägger till det nya attributet documentId=12345678 i intervallet.

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

Extrahera attribut från ett spannnamn med hjälp av inkludera och exkludera

Följande exempel visar hur du ändrar span-namnet till {operation_website}. Det lägger till ett attribut med nyckel operation_website och värde {oldSpanName} när intervallet har följande egenskaper:

Span-namnet innehåller / var som helst i strängen.
Spannamnet är inte 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>.*?)$"
            ]
          }
        }
      }
    ]
  }
}

Exempel på loggprocessor

Extrahera attribut från en loggmeddelandetext

Vi antar att brödtexten för indataloggmeddelandet är Starting PetClinicApplication on WorkLaptop with PID 27984 (C:\randompath\target\classes started by userx in C:\randompath). Följande exempel resulterar i utdatameddelandetexten Starting PetClinicApplication on WorkLaptop with PID {PIDVALUE} (C:\randompath\target\classes started by userx in C:\randompath). Det lägger till det nya attributet PIDVALUE=27984 i loggen.

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

Maskera känsliga data i loggmeddelande

Följande exempel visar hur du maskerar känsliga data i en loggmeddelandetext med både loggprocessor och attributprocessor. Vi antar att brödtexten för indataloggmeddelandet är User account with userId 123456xx failed to login. Loggprocessorn uppdaterar utdatameddelandetexten till User account with userId {redactedUserId} failed to login och attributprocessorn tar bort det nya attributet redactedUserId, som lades till i föregående steg.

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

Vanliga frågor och svar

Varför bearbetar inte loggfilerna för loggprocessorn med TelemetryClient.trackTrace()?

TelemetryClient.trackTrace() är en del av Application Insights klassiska SDK-brygga och loggprocessorerna fungerar bara med den nya OpenTelemetry-baserade instrumentationen.

Dela via