Przykłady procesora telemetrii — Azure Monitor Application Insights dla języka Java

Artykuł
11/05/2024

Ten artykuł zawiera przykłady procesorów telemetrycznych w usłudze Application Insights dla języka Java, w tym przykłady dotyczące konfiguracji dołączania i wykluczania. Zawiera również przykłady dla procesorów atrybutów i procesorów span.

Dołączanie i wykluczanie przykładów span

W tej sekcji dowiesz się, jak dołączać i wykluczać zakresy. Dowiesz się również, jak wykluczyć wiele zakresów i zastosować przetwarzanie selektywne.

Uwzględnianie zakresów

W tej sekcji pokazano, jak uwzględnić zakresy procesora atrybutów. Procesor nie obejmuje procesów, które nie są zgodne z właściwościami.

Dopasowanie wymaga, aby nazwa zakresu był równa spanA lub spanB.

Te zakresy są zgodne z include właściwościami, a akcje procesora są stosowane:

Span1 Nazwa: atrybuty "spanA": {env: dev, test_request: 123, credit_card: 1234}
Span2 Nazwa: atrybuty "spanB": {env: dev, test_request: false}
Span3 Nazwa: atrybuty "spanA": {env: 1, test_request: dev, credit_card: 1234}

Ten zakres nie jest zgodny z include właściwościami, a akcje procesora nie są stosowane:

Span4 Nazwa: atrybuty "spanC": {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"
          }
        ]
      }
    ]
  }
}

Wykluczanie zakresów

W tej sekcji pokazano, jak wykluczyć zakresy procesora atrybutów. Ten procesor nie obejmuje zakresów, które są zgodne z właściwościami.

Dopasowanie wymaga, aby nazwa zakresu był równa spanA lub spanB.

Następujące zakresy są zgodne z exclude właściwościami, a akcje procesora nie są stosowane:

Span1 Nazwa: atrybuty "spanA": {env: dev, test_request: 123, credit_card: 1234}
Span2 Nazwa: atrybuty "spanB": {env: dev, test_request: false}
Span3 Nazwa: atrybuty "spanA": {env: 1, test_request: dev, credit_card: 1234}

Ten zakres nie jest zgodny z exclude właściwościami, a akcje procesora są stosowane:

Span4 Nazwa: atrybuty "spanC": {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"
          }
        ]
      }
    ]
  }
}

Wykluczanie zakresów przy użyciu wielu kryteriów

W tej sekcji pokazano, jak wykluczyć zakresy procesora atrybutów. Ten procesor nie obejmuje zakresów, które są zgodne z właściwościami.

Dopasowanie wymaga spełnienia następujących warunków:

Atrybut (na przykład env z wartością dev) musi istnieć w zakresie.
Zakres musi mieć atrybut, który ma klucz test_request.

Poniższe zakresy są zgodne z exclude właściwościami, a akcje procesora nie są stosowane.

Span1 Nazwa: atrybuty "spanB": {env: dev, test_request: 123, credit_card: 1234}
Span2 Nazwa: atrybuty "spanA": {env: dev, test_request: false}

Poniższy zakres nie jest zgodny z exclude właściwościami, a akcje procesora są stosowane:

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

Przetwarzanie selektywne

W tej sekcji przedstawiono sposób określania zestawu właściwości zakresu, które wskazują, które zakresy procesora należy zastosować. Właściwości include wskazują, które zakresy powinny być przetwarzane. Właściwości exclude filtrują zakresy, które nie powinny być przetwarzane.

W następującej konfiguracji te zakresy są zgodne z właściwościami, a akcje procesora są stosowane:

Span1 Nazwa: atrybuty "spanB": {env: production, test_request: 123, credit_card: 1234, redact_trace: "false"}
Span2 Nazwa: atrybuty "spanA": {env: staging, test_request: false, redact_trace: true}

Te zakresy nie są zgodne z include właściwościami, a akcje procesora nie są stosowane:

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

Przykłady procesora atrybutów

Insert

Poniższy przykład wstawia nowy atrybut {"attribute1": "attributeValue1"} do zakresów i dzienników, w których klucz attribute1 nie istnieje.

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

Wstaw z innego klucza

W poniższym przykładzie użyto wartości z atrybutu, aby wstawić nowy atrybut anotherkey {"newKey": "<value from attribute anotherkey>"} do zakresów i dzienników, w których klucz newKey nie istnieje. Jeśli atrybut nie istnieje, nowy atrybut anotherkey nie zostanie wstawiony do zakresów i dzienników.

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

Zaktualizuj

Poniższy przykład aktualizuje atrybut na {"db.secret": "redacted"}. Aktualizuje atrybut boo przy użyciu wartości z atrybutu foo. Zakresy i dzienniki, które nie mają atrybutu boo , nie ulegają zmianie.

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

W poniższym przykładzie pokazano, jak usunąć atrybut z kluczem credit_card.

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

Skrót

W poniższym przykładzie pokazano, jak utworzyć skrót istniejących wartości atrybutów.

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

Wyodrębnianie

W poniższym przykładzie pokazano, jak utworzyć nowe atrybuty na podstawie wartości innego atrybutu za pomocą wyrażenia regularnego (regex). Na przykład, biorąc pod uwagę url.path = /path?queryParam1=value1,queryParam2=value2, są wstawione następujące atrybuty:

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

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

Maska

Na przykład podana wartość url.path = https://example.com/user/12345622 jest aktualizowana tak, aby url.path = https://example.com/user/**** korzystała z jednej z poniższych konfiguracji.

Pierwszy przykład konfiguracji:

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

Drugi przykład konfiguracji z nazwą grupy wyrażeń regularnych:

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

Przykłady atrybutów typu nonstring

Począwszy od wersji 3.4.19, procesory telemetryczne obsługują atrybuty nietypowe: boolean, boolean-arraylongdouble-arraydoublelong-arrayi .string-array

Jeśli attributes.type w formacie JSON nie podano wartości domyślnej, wartość domyślna stringto .

Poniższy przykład wstawia nowy atrybut {"newAttributeKeyStrict": "newAttributeValueStrict"} do zakresów i dzienników, w których atrybuty są zgodne z następującymi przykładami: {"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"
      }
    ]
  }
}

Ponadto atrybuty typu nonstring obsługują wartość regexp.

Poniższy przykład wstawia nowy atrybut {"newAttributeKeyRegexp": "newAttributeValueRegexp"} do zakresów i dzienników, w których atrybut longRegexpAttributeKey pasuje do wartości z 400 do 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"
      }
    ]
  }
}

Przykłady procesora span

Nazwij zakres

Poniższy przykład określa wartości atrybutów db.svc, operationi id. Tworzy nową nazwę zakresu przy użyciu tych atrybutów w tej kolejności oddzielonej wartością ::.

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

Wyodrębnianie atrybutów z nazwy zakresu

Załóżmy, że nazwa zakresu wejściowego to /api/v1/document/12345678/update. Poniższe przykładowe wyniki w nazwie /api/v1/document/{documentId}/updatezakresu danych wyjściowych. Dodaje nowy atrybut documentId=12345678 do zakresu.

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

Wyodrębnianie atrybutów z nazwy zakresu przy użyciu funkcji dołączania i wykluczania

W poniższym przykładzie pokazano, jak zmienić nazwę zakresu na {operation_website}. Dodaje atrybut z kluczem operation_website i wartością {oldSpanName} , gdy zakres ma następujące właściwości:

Nazwa zakresu zawiera / dowolne miejsce w ciągu.
Nazwa zakresu nie donot/changejest .

{
  "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>.*?)$"
            ]
          }
        }
      }
    ]
  }
}

Przykłady procesora dziennika

Wyodrębnianie atrybutów z treści komunikatu dziennika

Załóżmy, że treść komunikatu dziennika wejściowego to Starting PetClinicApplication on WorkLaptop with PID 27984 (C:\randompath\target\classes started by userx in C:\randompath). Poniższe przykładowe wyniki w treści Starting PetClinicApplication on WorkLaptop with PID {PIDVALUE} (C:\randompath\target\classes started by userx in C:\randompath)komunikatu wyjściowego . Dodaje nowy atrybut PIDVALUE=27984 do dziennika.

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

Maskowanie poufnych danych w komunikacie dziennika

W poniższym przykładzie pokazano, jak maskować poufne dane w treści komunikatu dziennika przy użyciu procesora dziennika i procesora atrybutów. Załóżmy, że treść komunikatu dziennika wejściowego to User account with userId 123456xx failed to login. Procesor dziennika aktualizuje treść komunikatu wyjściowego do User account with userId {redactedUserId} failed to login , a procesor atrybutów usuwa nowy atrybut redactedUserId, który został dodany w poprzednim kroku.

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

Często zadawane pytania

Dlaczego procesor dziennika nie przetwarza plików dziennika przy użyciu elementu TelemetryClient.trackTrace()?

TelemetryClient.trackTrace() jest częścią klasycznego mostka zestawu SDK usługi Application Insights, a procesory dzienników współpracują tylko z nową instrumentacją opartą na protokole OpenTelemetry.

Udostępnij za pośrednictwem