Halaman ini diterjemahkan oleh Cloud Translation API.

Menggunakan API metrik

Halaman ini berlaku untuk Apigee dan Apigee hybrid.

Apigee merekam berbagai data operasional dan bisnis yang mengalir di seluruh API. Metrik yang berasal dari data ini berguna untuk pemantauan operasional dan pemantauan bisnis. Dengan Apigee Analytics, Anda dapat, untuk menentukan API mana yang berperforma baik atau buruk, developer mana yang memberikan traffic bernilai tertinggi, dan aplikasi mana yang menyebabkan masalah terbanyak untuk layanan backend.

Untuk membantu mengakses data metrik ini dengan mudah, gunakan Metrics API saat Anda perlu mengotomatiskan fungsi analitik, seperti mengambil metrik secara berkala menggunakan klien atau skrip otomatisasi. Anda juga dapat menggunakan API ini untuk membuat visualisasi dalam bentuk widget khusus yang dapat Anda sematkan di portal atau aplikasi khusus.

Untuk mempelajari cara menggunakan Analytics di UI Apigee, lihat Ringkasan Analisis Apigee.

Tentang Metrics API

Ada dua cara untuk menggunakan Metrics API:

Mendapatkan metrik untuk organisasi dan lingkungan selama jangka waktu tertentu, misalnya satu jam, hari, atau minggu. Metode ini menampilkan metrik mentah untuk seluruh organisasi dan lingkungan.
Misalnya, untuk minggu sebelumnya, Anda ingin mendapatkan:
- Jumlah error kebijakan
- Waktu respons rata-rata
- Total traffic
Dapatkan metrik yang diatur menurut dimensi selama jangka waktu tertentu untuk organisasi dan lingkungan.

Misalnya, untuk minggu sebelumnya, Anda dapat menggunakan dimensi untuk mengelompokkan metrik menurut produk API, proxy API, dan email developer (yang juga dapat berupa ID AppGroup) untuk mendapatkan:
- Jumlah error kebijakan per produk API
- Waktu respons rata-rata per proxy API
- Total traffic per email developer
Untuk mengelola hasil yang ditampilkan, Metrics API mendukung fitur berikut:
Untuk informasi selengkapnya, lihat referensi API metrik.

Mulai menggunakan Metrics API

URL permintaan untuk Metrics API adalah:
```
https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats[dimension]
```
Misalnya, untuk mendapatkan metrik yang dikelompokkan menurut proxy API, gunakan URL berikut untuk memanggil Apigee API:
```
https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/apiproxy?timeRange=07/21/2018+00:00:00~08/23/2018+00:00:00
```
Hapus dimensi untuk menampilkan metrik mentah untuk seluruh organisasi dan lingkungan selama jangka waktu yang ditentukan:
```
https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats?timeRange=07/21/2019+00:00:00~08/23/2018+00:00:00
```
Menentukan metrik yang akan ditampilkan

Gunakan parameter kueri select untuk menentukan metrik untuk diambil, dan fungsi agregasi opsional, dalam bentuk:
```
?select=metric
```
atau:
```
?select=aggFunction(metric)
```
Dengan keterangan:
- metric menentukan data yang ingin Anda tampilkan. Misalnya, jumlah permintaan API, cache ditemukan, atau error kebijakan. Lihat metrik untuk tabel yang menentukan nama metrik yang akan digunakan dengan parameter kueri select.
- aggFunction menentukan fungsi agregasi opsional yang dijalankan terhadap metrik. Misalnya, Anda dapat menggunakan fungsi agregasi berikut dengan metrik latensi pemrosesan:
  - avg: Menampilkan latensi pemrosesan rata-rata.
  - min: Menampilkan latensi pemrosesan minimum.
  - max: Menampilkan latensi pemrosesan maksimum.
  - sum: Menampilkan jumlah semua latensi pemrosesan.
  - p50: Menampilkan persentil ke-50 untuk latensi pemrosesan.
  - p95: Menampilkan persentil ke-95 untuk memproses latensi.
  - p99: Menampilkan persentil ke-99 untuk latensi pemrosesan.
  Tidak semua metrik mendukung semua fungsi agregasi. Dokumentasi tentang metrics berisi tabel yang menentukan nama metrik dan fungsi (sum, avg, min, max) yang didukung oleh metrik.
Misalnya, untuk menampilkan jumlah rata-rata transaksi, artinya permintaan proxy API, per detik:
```
?select=tps
```
Perhatikan bahwa contoh ini tidak memerlukan fungsi agregasi. Contoh berikutnya menggunakan fungsi agregasi untuk menampilkan jumlah hit cache:
```
?select=sum(cache_hit)
```
Anda dapat menampilkan beberapa metrik untuk satu panggilan API. Untuk mendapatkan metrik jumlah error kebijakan dan ukuran permintaan rata-rata, setel parameter kueri select menggunakan parameter daftar metrik:
```
?select=sum(policy_error),avg(request_size)
```
Menentukan jangka waktu

Metrik API menampilkan data selama jangka waktu tertentu. Menggunakan timeRange (maksimal 6 bulan) untuk menentukan jangka waktu, dalam bentuk:
```
?timeRange=MM/DD/YYYY%20HH:MM~MM/DD/YYYY%20HH:MM
```
Perhatikan %20 sebelum HH:MM. Parameter timeRange memerlukan karakter spasi yang dienkode URL sebelum HH:MM, atau karakter +, seperti dalam: MM/DD/YYYY+HH:MM~MM/DD/YYYY+HH:MM.

Contoh:
```
?timeRange=03/01/2018%2000:00~03/30/2018%2023:59
```
Jangan gunakan pukul 24.00 sebagai waktu karena akan membungkus pukul 00.00. Sebagai gantinya, gunakan 23:59.

Catatan: Untuk informasi tentang durasi retensi data, lihat Halaman paket Apigee.

Contoh pemanggilan Metrics API

Bagian ini memberikan contoh penggunaan API metrik. Lihat Contoh Metrics API untuk contoh tambahan.
Mengembalikan total jumlah panggilan yang dilakukan ke API Anda selama satu bulan

Untuk menampilkan jumlah total panggilan yang dilakukan ke semua API di organisasi dan lingkungan Anda selama satu bulan, gunakan panggilan yang mirip dengan panggilan berikut:
```
curl -v "https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/?select=sum(message_count)&timeRange=03/01/2018%2000:00~03/31/2018%2023:59" \
  -H "Authorization: Bearer $TOKEN"
```
Jika $TOKEN ditetapkan ke token akses OAuth 2.0 Anda, seperti yang dijelaskan di Mendapatkan token akses OAuth 2.0. Untuk mengetahui informasi tentang opsi curl yang digunakan dalam contoh ini, lihat Menggunakan curl. Untuk deskripsi tentang variabel lingkungan yang digunakan, lihat Menetapkan variabel lingkungan untuk permintaan API Apigee.

Berikut ini contoh responsnya:
```
{
  "environments": [
    {
      "metrics": [
        {
          "name": "sum(message_count)",
          "values": [
            "7.44944088E8"
          ]
        }
      ],
      "name": "prod"
    }
  ],
...
}
```
Menampilkan total jumlah pesan per proxy API selama dua hari

Dalam contoh ini, Anda menampilkan metrik untuk jumlah permintaan yang diterima oleh semua proxy API selama periode dua hari. Parameter kueri select menentukan fungsi agregat sum untuk metrik message_count pada dimensi apiproxy. Laporan ini menampilkan throughput pesan permintaan untuk semua API untuk traffic yang diterima antara awal 20/6/2018 dan akhir 21/6/2018, di Waktu UTC:
```
curl  https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/apiproxy?"select=sum(message_count)&timeRange=06/20/2018%2000:00~06/21/2018%2023:59" \
  -H "Authorization: Bearer $TOKEN"
```
Jika $TOKEN ditetapkan ke token akses OAuth 2.0 Anda, seperti yang dijelaskan di Mendapatkan token akses OAuth 2.0. Untuk mengetahui informasi tentang opsi curl yang digunakan dalam contoh ini, lihat Menggunakan curl. Untuk deskripsi tentang variabel lingkungan yang digunakan, lihat Menetapkan variabel lingkungan untuk permintaan API Apigee.

Berikut ini contoh responsnya:
```
{
  "environments" : [ {
    "dimensions" : [ {
      "metrics" : [ {
        "name" : "sum(message_count)",
        "values" : [ {
          "timestamp" : 1498003200000,
          "value" : "1100.0"
        } ]
      } ],
      "name" : "target-reroute"
    } ],
    "name" : "test"
  } ]...
}
```
Respons ini menunjukkan bahwa 1100 pesan diterima oleh satu proxy API yang disebut 'target-ubah rute' berjalan di lingkungan pengujian antara awal 6/20/2018 dan akhir 21/6/2018.

Tips: Perhatikan bahwa stempel waktu, 1498003200000, adalah dalam Format stempel waktu Unix. Ada banyak alat konversi stempel waktu Unix yang tersedia di Internet yang dapat Anda gunakan untuk mendekode stempel waktu ini.

Agar mendapatkan metrik untuk dimensi lain, tentukan dimensi yang berbeda sebagai parameter URI. Sebagai misalnya, Anda dapat menentukan dimensi developer_app untuk mengambil metrik untuk aplikasi developer lainnya. Panggilan API berikut menampilkan total throughput (pesan yang diterima) dari setiap aplikasi untuk interval waktu yang ditentukan:
```
curl  https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/developer_app?"select=sum(message_count)&timeRange=06/20/2018%2000:00~06/21/2018%2023:59&timeUnit=day" \
  -H "Authorization: Bearer $TOKEN"
```
Berikut ini contoh responsnya:
```
{
  "environments": [
    {
      "dimensions": [
        {
          "metrics": [
            {
              "name": "sum(message_count)",
              "values": [
                {
                  "timestamp": 1498003200000,
                  "value": "886.0"
                }
              ]
            }
          ],
          "name": "Test-App"
        },
        {
          "metrics": [
            {
              "name": "sum(message_count)",
              "values": [
                {
                  "timestamp": 1498003200000,
                  "value": "6645.0"
                }
              ]
            }
          ],
          "name": "johndoe_app"
        },
        {
          "metrics": [
            {
              "name": "sum(message_count)",
              "values": [
                {
                  "timestamp": 1498003200000,
                  "value": "1109.0"
                }
              ]
            }
          ],
          "name": "marys_app"
        }
  ]...
}
```
Mengurutkan hasil menurut peringkat relatif

Sering kali saat mendapatkan metrik, Anda hanya ingin mendapatkan hasil untuk sebagian dari kumpulan total layanan otomatis dan data skalabel. Biasanya, Anda perlu mendapatkan hasil untuk "10 teratas", misalnya, "10 teratas paling lambat API", "10 aplikasi paling aktif". Anda dapat melakukannya menggunakan parameter kueri topk sebagai bagian dari permintaan.

Misalnya, Anda mungkin tertarik untuk mengetahui siapa developer teratas Anda, yang diukur berdasarkan throughput, atau performa terburuk Anda (yaitu, API target 'paling lambat') didasarkan pada latensi.

topk (artinya entitas 'top k') memungkinkan pelaporan entitas yang terkait dengan nilai tertinggi untuk metrik tertentu. Hal ini memungkinkan Anda memfilter metrik untuk daftar entity yang menunjukkan kondisi tertentu.

Misalnya, untuk menemukan URL target yang sebagian besar rentan error selama seminggu terakhir, parameter topk ditambahkan ke permintaan, dengan nilai 1:
```
curl https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/target_url?"select=sum(is_error)&timeRange=05/08/2018%2000:00~05/15/2018%2000:00&timeUnit=week&sortby=sum(is_error)&topk=1" \
  -H "Authorization: Bearer $TOKEN"
```
Jika $TOKEN ditetapkan ke token akses OAuth 2.0 Anda, seperti yang dijelaskan di Mendapatkan token akses OAuth 2.0. Untuk mengetahui informasi tentang opsi curl yang digunakan dalam contoh ini, lihat Menggunakan curl. Untuk deskripsi tentang variabel lingkungan yang digunakan, lihat Menetapkan variabel lingkungan untuk permintaan API Apigee.

Berikut ini contoh responsnya:
```
{
  "environments": [
    {
      "dimensions": [
        {
          "metrics": [
            {
              "name": "sum(is_error)",
              "values": [
                {
                  "timestamp": 1494201600000,
                  "value": "12077.0"
                }
              ]
            }
          ],
          "name": "http://api.company.com"
        }
      ]...
}
```
Hasil permintaan ini adalah kumpulan metrik yang menunjukkan bahwa URL target yang paling bermasalah http://api.company.com.

Anda juga dapat menggunakan parameter topk untuk mengurutkan API yang mengalami yang konsisten. Contoh berikut mengambil metrik di API peringkat teratas, yang ditentukan oleh API throughput di minggu lalu:
```
curl https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV}/stats/apiproxy?"select=sum(message_count)&timeRange=05/08/2018%2000:00~05/15/2018%2000:00&timeUnit=day&sortby=sum(message_count)&sort=DESC&topk=1" \
  -H "Authorization: Bearer $TOKEN"
```
Berikut ini contoh responsnya:
```
{
  "environments": [
    {
      "dimensions": [
        {
          "metrics": [
            {
              "name": "sum(message_count)",
              "values": [
                {
                  "timestamp": 1494720000000,
                  "value": "5750.0"
                },
                {
                  "timestamp": 1494633600000,
                  "value": "5752.0"
                },
                {
                  "timestamp": 1494547200000,
                  "value": "5747.0"
                },
                {
                  "timestamp": 1494460800000,
                  "value": "5751.0"
                },
                {
                  "timestamp": 1494374400000,
                  "value": "5753.0"
                },
                {
                  "timestamp": 1494288000000,
                  "value": "5751.0"
                },
                {
                  "timestamp": 1494201600000,
                  "value": "5752.0"
                }
              ]
            }
          ],
          "name": "testCache"
        }
      ],
      "name": "test"
    }
  ]...
}
```
Memfilter hasil

Untuk tingkat perincian yang lebih besar, Anda dapat memfilter hasil untuk membatasi data yang ditampilkan. Saat menggunakan filter, Anda harus menggunakan dimensi sebagai properti filter.

Misalnya, anggaplah Anda perlu mengambil sejumlah error dari layanan backend. difilter oleh kata kerja HTTP permintaan. Sasaran Anda adalah mencari tahu berapa banyak permintaan POST dan PUT menghasilkan error per layanan backend. Untuk melakukannya, gunakan dimensi target_url bersama dengan filter request_verb:
```
curl https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/target_url?"select=sum(is_error)&timeRange=05/08/2018%2000:00~05/15/2018%2000:00&timeUnit=week&filter=(request_verb%20in%20'POST','PUT')" \
  -H "Authorization: Bearer $TOKEN"
```
Jika $TOKEN ditetapkan ke token akses OAuth 2.0 Anda, seperti yang dijelaskan di Mendapatkan token akses OAuth 2.0. Untuk mengetahui informasi tentang opsi curl yang digunakan dalam contoh ini, lihat Menggunakan curl. Untuk deskripsi tentang variabel lingkungan yang digunakan, lihat Menetapkan variabel lingkungan untuk permintaan API Apigee.

Catatan: Anda harus menempatkan teks filter di antara tanda kutip tunggal, misalnya, 'POST'. Jangan gunakan tanda kutip ganda.

Berikut ini contoh responsnya:
```
{
  "environments" : [
    {
      "dimensions" : [
        {
          "metrics" : [
            {
              "name" : "sum(is_error)",
              "values" : [
                {
                  "timestamp" : 1519516800000,
                  "value" : "1.0"
                }
              ]
          }
        ],
        "name" : "testCache"
        }
      ],
      "name" : "test"
    }
  ]...
}
```
Memberi nomor halaman pada hasil

Dalam lingkungan produksi, beberapa permintaan ke API analisis Apigee menampilkan data yang sangat besar yang sudah ditetapkan. Untuk memudahkan tampilan {i>dataset<i} besar dalam konteks aplikasi berbasis UI, API secara native mendukung penomoran halaman.

Untuk memberi nomor halaman pada hasil, gunakan parameter kueri offset dan limit, bersama dengan parameter pengurutan sortby untuk memastikan pengurutan yang konsisten item.

Catatan: Saat melakukan penomoran halaman pada hasil, penting untuk mengurutkan hasil dalam cara yang dapat diprediksi menggunakan parameter kueri sortby. Tanpa penyortiran, hasil akan dikembalikan dalam urutan yang tidak dapat diprediksi, yang mengalahkan tujuan penomoran halaman.
Nilai sortby harus sama dengan nilai yang digunakan dalam kueri select . Misalnya, jika select=sum(message_count), maka sortby=sum(message_count).

Misalnya, permintaan berikut cenderung mengembalikan set data yang besar, karena mengambil metrik untuk semua error pada semua API di lingkungan produk selama seminggu terakhir.
```
curl https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/apiproxy?"select=sum(is_error)&timeRange=05/08/2018%2000:00~05/15/2018%2000:00&timeUnit=week&sortby=sum(is_error)" \
  -H "Authorization: Bearer $TOKEN"
```
Jika $TOKEN ditetapkan ke token akses OAuth 2.0 Anda, seperti yang dijelaskan di Mendapatkan token akses OAuth 2.0. Untuk mengetahui informasi tentang opsi curl yang digunakan dalam contoh ini, lihat Menggunakan curl. Untuk deskripsi tentang variabel lingkungan yang digunakan, lihat Menetapkan variabel lingkungan untuk permintaan API Apigee.

Jika aplikasi berbasis UI dapat menampilkan 50 hasil per halaman secara wajar, Anda dapat menetapkan batas menjadi 50. Karena 0 dihitung sebagai item pertama, panggilan berikut mengembalikan item 0-49 dalam urutan menurun (sort=DESC adalah default).
```
curl https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/apiproxy?"select=sum(is_error)&timeRange=05/08/2018%2000:00~05/15/2018%2000:00&timeUnit=week&sortby=sum(is_error)&limit=50&offset=0" \
  -H "Authorization: Bearer $TOKEN"
```
Untuk 'halaman' kedua hasil, gunakan parameter kueri offset, sebagai berikut. Perhatikan bahwa {i> limit <i}dan {i>offset <i}adalah identik. Itu karena 0 dihitung sebagai item pertama. Dengan batas maksimal 50 karakter, offset 0, item 0-49 dikembalikan. Dengan offset 50, item 50-99 akan dikembalikan.
```
curl https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/apiproxy?"select=sum(is_error)&timeRange=05/08/2018%2000:00~05/15/2018%2000:00&timeUnit=week&sortby=sum(is_error)&limit=50&offset=50" \
  -H "Authorization: Bearer $TOKEN"
```

Menggunakan API metrik

Tentang Metrics API

Mulai menggunakan Metrics API

Menentukan metrik yang akan ditampilkan

Menentukan jangka waktu

Contoh pemanggilan Metrics API

Mengurutkan hasil menurut peringkat relatif

Memfilter hasil

Memberi nomor halaman pada hasil