Reporting

curl --fail-with-body --include --max-time 30 --request GET \
  'https://api.useadmesh.com/agent/reporting?time_range=7d' \
  --header 'Authorization: Bearer YOUR_API_KEY'

import json
from urllib.parse import urlencode
from urllib.request import Request, urlopen

api_key = "YOUR_API_KEY"
query = urlencode({"time_range": "7d"})
request = Request(
    f"https://api.useadmesh.com/agent/reporting?{query}",
    headers={"Authorization": f"Bearer {api_key}"},
)

# Non-success HTTP responses raise urllib.error.HTTPError.
with urlopen(request, timeout=30) as response:
    report = json.load(response)
    if response.status == 202:
        retry_after = response.headers.get("Retry-After", "60")
        print(f"Report preparing. Retry after {retry_after} seconds.")
    print(json.dumps(report, indent=2))

// Node.js 18+; save as reporting.mjs to use top-level await.
const apiKey = 'YOUR_API_KEY';
const url = new URL('https://api.useadmesh.com/agent/reporting');
url.searchParams.set('time_range', '7d');

const response = await fetch(url, {
  headers: { Authorization: `Bearer ${apiKey}` },
  signal: AbortSignal.timeout(30_000),
});
if (!response.ok) {
  throw new Error(`Reporting API returned ${response.status}: ${await response.text()}`);
}

const report = await response.json();
if (response.status === 202) {
  console.log(`Report preparing. Retry after ${response.headers.get('Retry-After') || '60'} seconds.`);
}
console.log(report);

// Java 11+; save as ReportingExample.java.
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class ReportingExample {
    public static void main(String[] args) throws Exception {
        String apiKey = "YOUR_API_KEY";
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(10))
            .build();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.useadmesh.com/agent/reporting?time_range=7d"))
            .timeout(Duration.ofSeconds(30))
            .header("Authorization", "Bearer " + apiKey)
            .GET()
            .build();
        HttpResponse<String> response = client.send(
            request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() != 200 && response.statusCode() != 202) {
            throw new IllegalStateException(
                "Reporting API returned " + response.statusCode() + ": " + response.body());
        }
        if (response.statusCode() == 202) {
            String retryAfter = response.headers().firstValue("Retry-After").orElse("60");
            System.out.println("Report preparing. Retry after " + retryAfter + " seconds.");
        }
        System.out.println(response.body());
    }
}

package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
    "time"
)

func main() {
    apiKey := "YOUR_API_KEY"
    client := &http.Client{Timeout: 30 * time.Second}
    request, err := http.NewRequest(http.MethodGet,
        "https://api.useadmesh.com/agent/reporting?time_range=7d", nil)
    if err != nil {
        log.Fatal(err)
    }
    request.Header.Set("Authorization", "Bearer " + apiKey)

    response, err := client.Do(request)
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()
    body, err := io.ReadAll(response.Body)
    if err != nil {
        log.Fatal(err)
    }
    if response.StatusCode != http.StatusOK && response.StatusCode != http.StatusAccepted {
        log.Fatalf("Reporting API returned %d: %s", response.StatusCode, body)
    }
    if response.StatusCode == http.StatusAccepted {
        retryAfter := response.Header.Get("Retry-After")
        if retryAfter == "" {
            retryAfter = "60"
        }
        fmt.Printf("Report preparing. Retry after %s seconds.\n", retryAfter)
    }
    fmt.Println(string(body))
}