Contoh prosesor telemetri - Azure Monitor Application Insights for Java

Artikel
03/19/2024

Artikel ini menyediakan contoh prosesor telemetri di Application Insights untuk Java, termasuk sampel untuk menyertakan dan mengecualikan konfigurasi. Ini juga mencakup sampel untuk prosesor atribut dan prosesor rentang.

Menyertakan dan mengecualikan sampel Rentang

Di bagian ini, pelajari cara menyertakan dan mengecualikan rentang. Anda juga mempelajari cara mengecualikan beberapa rentang dan menerapkan pemrosesan selektif.

Sertakan rentang

Bagian ini menampilkan cara menyertakan rentang untuk prosesor atribut. Prosesor tidak memproses rentang yang tidak cocok dengan properti.

Kecocokan mewajibkan nama rentang yang setara dengan spanA atau spanB.

Rentang ini cocok dengan include properti, dan tindakan prosesor diterapkan:

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

Rentang ini tidak cocok dengan include properti, dan tindakan prosesor tidak diterapkan:

Span4 Nama: Atribut '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"
          }
        ]
      }
    ]
  }
}

Jangan sertakan rentang

Bagian ini menampilkan cara pengecualian rentang untuk prosesor atribut. Prosesor ini tidak memproses rentang yang cocok dengan properti.

Kecocokan mewajibkan nama rentang yang setara dengan spanA atau spanB.

Rentang berikut cocok dengan exclude properti, dan tindakan prosesor tidak diterapkan:

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

Rentang ini tidak cocok dengan exclude properti, dan tindakan prosesor diterapkan:

Span4 Nama: Atribut '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"
          }
        ]
      }
    ]
  }
}

Mengecualikan rentang menggunakan beberapa kriteria

Bagian ini menampilkan cara pengecualian rentang untuk prosesor atribut. Prosesor ini tidak memproses rentang yang cocok dengan properti.

Kecocokan mewajibkan kondisi berikut untuk terpenuhi:

Atribut (misalnya, env dengan nilai dev) harus ada dalam rentang.
Rentang harus memiliki atribut yang memiliki kunci test_request.

Rentang berikut cocok dengan exclude properti, dan tindakan prosesor tidak diterapkan.

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

Rentang berikut tidak cocok dengan exclude properti, dan tindakan prosesor diterapkan:

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

Pemrosesan secara selektif

Bagian ini menampilkan cara menentukan kumpulan properti rentang yang menunjukkan rentang mana yang harus diterapkan prosesor ini. Properti include menunjukkan rentang mana yang harus diproses. Properti exclude memfilter rentang yang seharusnya tidak diproses.

Dalam konfigurasi berikut ini, rentang ini cocok dengan properti, dan tindakan prosesor akan diterapkan:

Span1 Nama: Atribut 'spanB': {env: production, test_request: 123, credit_card: 1234, redact_trace: "false"}
Span2 Nama: Atribut 'spanA': {env: penahapan, test_request: false, redact_trace: true}

Rentang ini tidak cocok dengan include properti, dan tindakan prosesor tidak diterapkan:

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

Sampel prosesor atribut

Sisipkan

Sampel berikut menyisipkan atribut baru {"attribute1": "attributeValue1"} ke dalam rentang dan log di mana kunci attribute1 tidak ada.

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

Menyisipkan dari kunci lain

Sampel berikut menggunakan nilai dari atribut anotherkey untuk menyisipkan atribut baru {"newKey": "<value from attribute anotherkey>"} ke dalam rentang dan log di mana kunci newKey tidak ada. Jika atribut anotherkey tidak ada, tidak ada atribut baru yang dimasukkan ke dalam rentang dan log.

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

Pembaruan

Contoh berikut akan memperbarui atribut ke {"db.secret": "redacted"}. Hal ini memperbarui atribut boo dengan menggunakan nilai dari atribut foo. Rentang dan log yang tidak memiliki atribut boo tidak berubah.

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

Hapus

Contoh berikut menampilkan cara menghapus atribut yang memiliki kunci credit_card.

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

Hash

Contoh berikut akan menunjukkan cara hash nilai atribut yang ada.

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

Ekstrak

Sampel berikut menunjukkan cara menggunakan ekspresi reguler (regex) untuk membuat atribut baru berdasarkan nilai atribut yang lain. Misalnya, mengingat url.path = /path?queryParam1=value1,queryParam2=value2, atribut berikut akan disisipkan:

httpProtocol: http
httpDomain: example.com
httpPath: path
httpQueryParams: queryParam1=value1,queryParam2=value2
url.path: tidak ada perubahan

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

Mask

Misalnya, yang diberikan url.path = https://example.com/user/12345622 diperbarui untuk url.path = https://example.com/user/**** menggunakan salah satu konfigurasi di bawah ini.

Contoh konfigurasi pertama:

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

Contoh konfigurasi kedua dengan nama grup ekspresi reguler:

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

Sampel atribut yang dititik nonstring

Mulai 3.4.19 GA, prosesor telemetri mendukung atribut yang diketik nonstring: boolean, , double, longboolean-array, double-array, long-array, dan string-array.

Ketika attributes.type tidak disediakan di json, defaultnya adalah string.

Sampel berikut menyisipkan atribut {"newAttributeKeyStrict": "newAttributeValueStrict"} baru ke dalam rentang dan log di mana atribut cocok dengan contoh berikut: {"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"
      }
    ]
  }
}

Selain itu, atribut jenis nonstring mendukung regexp.

Sampel berikut menyisipkan atribut {"newAttributeKeyRegexp": "newAttributeValueRegexp"} baru ke dalam rentang dan log di mana atribut longRegexpAttributeKey cocok dengan nilai dari 400 ke 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"
      }
    ]
  }
}

Rentang sampel prosesor

Berikan nama pada rentang

Contoh berikut akan menentukan nilai atribut db.svc, operation, dan id. Hal ini membentuk nama baru rentang dengan menggunakan atribut tersebut, dengan urutan tersebut, yang dipisahkan oleh nilai ::.

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

Mengekstrak atribut dari nama rentang

Mari berasumsi nama rentang input adalah /api/v1/document/12345678/update. Contoh berikut akan menghasilkan nama rentang output /api/v1/document/{documentId}/update. Hal ini akan menambahkan atribut baru documentId=12345678 ke rentang.

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

Mengekstrak atribut dari nama rentang dengan menggunakan sertakan dan kecualikan

Sampel berikut akan menunjukkan cara mengubah nama rentang menjadi {operation_website}. Hal ini menambahkan atribut dengan kunci operation_website dan nilai ketika rentang memiliki properti {oldSpanName} berikut:

Nama rentang berisi / di mana saja dalam string.
Nama rentang bukan 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>.*?)$"
            ]
          }
        }
      }
    ]
  }
}

Sampel prosesor log

Mengekstrak atribut dari isi pesan log

Mari kita anggap isi pesan log input adalah Starting PetClinicApplication on WorkLaptop with PID 27984 (C:\randompath\target\classes started by userx in C:\randompath). Sampel berikut menghasilkan isi pesan output Starting PetClinicApplication on WorkLaptop with PID {PIDVALUE} (C:\randompath\target\classes started by userx in C:\randompath). Sampel menambahkan atribut baru PIDVALUE=27984 ke log.

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

Menyembunyikan data sensitif dalam pesan log

Sampel berikut menunjukkan cara menyembunyikan data sensitif dalam isi pesan log menggunakan pemroses log dan pemroses atribut. Mari kita anggap isi pesan log input adalah User account with userId 123456xx failed to login. Prosesor log memperbarui isi pesan output ke User account with userId {redactedUserId} failed to login dan prosesor atribut menghapus atribut redactedUserIdbaru , yang ditambahkan pada langkah sebelumnya.

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

Tanya jawab umum

Mengapa prosesor log tidak memproses file log menggunakan TelemetryClient.trackTrace()?

TelemetryClient.trackTrace() adalah bagian dari jembatan Application Insights Classic SDK, dan prosesor log hanya berfungsi dengan instrumentasi berbasis OpenTelemetry baru.

Bagikan melalui