Auth0 FGA Logging

import os, time, json, requests

BASE_URL = os.getenv('FGA_API_URL', 'https://api.us1.fga.dev')
STORE_ID = os.getenv('FGA_STORE_ID')
TOKEN = os.getenv('FGA_API_TOKEN')
FILE = f'logs_{STORE_ID}.jsonl'

if not STORE_ID or not TOKEN:
    raise SystemExit('Missing FGA_STORE_ID or FGA_API_TOKEN')

def fetch_page(continuation=None):
    url = f"{BASE_URL}/stores/{STORE_ID}/logs"
    params = {}
    if continuation:
        params['continuation_token'] = continuation
    r = requests.get(url, headers={'Authorization': f'Bearer {TOKEN}', 'Accept': 'application/json'}, params=params)
    if r.status_code != 200:
        print('API error', r.text)
        return None
    return r.json()

def poll_once():
    continuation = None
    total = 0
    while True:
        data = fetch_page(continuation)
        if not data or not data.get('logs'):
            break
        with open(FILE, 'a') as f:
            for log in data['logs']:
                f.write(json.dumps(log) + '\\n')
                total += 1
        continuation = data.get('continuation_token') or None
        if not continuation:
            break
    print(f'Saved {total} logs to {FILE}')

while True:
    poll_once()
    time.sleep(3600)  # 1 hour

// Build & run: dotnet run
// Ensure your .csproj has (if needed):
// <PackageReference Include="System.Net.Http.Json" Version="8.0.0" />
using System; // Environment
using System.IO; // StreamWriter
using System.Linq; // ToArray()
using System.Text.Json;
using System.Net.Http;
using System.Threading.Tasks;

class PollLogs {
    static readonly string BaseUrl = Environment.GetEnvironmentVariable("FGA_API_URL") ?? "https://api.us1.fga.dev";
    static readonly string StoreId = Environment.GetEnvironmentVariable("FGA_STORE_ID") ?? "";
    static readonly string Token = Environment.GetEnvironmentVariable("FGA_API_TOKEN") ?? "";
    static readonly HttpClient Client = new HttpClient();
    static readonly string FilePath = $"logs_{StoreId}.jsonl";

    static async Task<(JsonElement[] logs, string continuation)> FetchAsync(string continuation) {
        var url = $"{BaseUrl}/stores/{StoreId}/logs" + (continuation != null ? $"?continuation_token={Uri.EscapeDataString(continuation)}" : "");
        using var req = new HttpRequestMessage(HttpMethod.Get, url);
        req.Headers.Add("Authorization", $"Bearer {Token}");
        req.Headers.Add("Accept", "application/json");
        var res = await Client.SendAsync(req);
        if (!res.IsSuccessStatusCode) {
            Console.Error.WriteLine("API Error: " + await res.Content.ReadAsStringAsync());
            return (Array.Empty<JsonElement>(), null);
        }
        using var stream = await res.Content.ReadAsStreamAsync();
        using var doc = await JsonDocument.ParseAsync(stream);
        var root = doc.RootElement;
        var logs = root.TryGetProperty("logs", out var logsProp) ? logsProp.EnumerateArray().ToArray() : Array.Empty<JsonElement>();
        var cont = root.TryGetProperty("continuation_token", out var c) ? c.GetString() : null;
        return (logs, cont);
    }

    static async Task PollOnce() {
        string continuation = null; int total = 0;
        while (true) {
            var (logs, cont) = await FetchAsync(continuation);
            if (logs.Length == 0) break;
            await using var fw = new StreamWriter(FilePath, append: true);
            foreach (var log in logs) { fw.WriteLine(log.ToString()); total++; }
            continuation = string.IsNullOrEmpty(cont) ? null : cont;
            if (continuation == null) break;
        }
        Console.WriteLine($"Saved {total} logs to {FilePath}");
    }

    static async Task Main() {
        if (string.IsNullOrEmpty(StoreId) || string.IsNullOrEmpty(Token)) { Console.Error.WriteLine("Missing env vars"); return; }
        while (true) { await PollOnce(); await Task.Delay(TimeSpan.FromHours(1)); }
    }
}

import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.util.*;
import javax.net.ssl.HttpsURLConnection;
import com.fasterxml.jackson.databind.*;

public class PollLogs {
    static class LogResponse {
        public List<Map<String, Object>> logs;
        public String continuation_token;
    }

    private static void pollLogs(String baseURL, String storeID, String token, String filePath) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        int totalLogs = 0;
        String continuationToken = null;

        while (true) {
            String urlStr = baseURL + "/stores/" + storeID + "/logs";
            if (continuationToken != null) {
                urlStr += "?continuation_token=" + URLEncoder.encode(continuationToken, StandardCharsets.UTF_8);
            }
            URL url = new URL(urlStr);
            HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
            conn.setRequestProperty("Authorization", "Bearer " + token);
            conn.setRequestProperty("Accept", "application/json");

            if (conn.getResponseCode() != 200) {
                try (BufferedReader br = new BufferedReader(new InputStreamReader(conn.getErrorStream()))) {
                    System.err.println("API Error: " + br.readLine());
                }
                return;
            }

            LogResponse data;
            try (InputStream is = conn.getInputStream()) {
                data = new ObjectMapper().readValue(is, LogResponse.class);
            }

            if (data.logs == null || data.logs.isEmpty()) {
                break;
            }

            try (FileWriter fw = new FileWriter(filePath, true)) {
                for (Map<String, Object> log : data.logs) {
                    fw.write(mapper.writeValueAsString(log) + "\\n");
                    totalLogs++;
                }
            }

            if (data.continuation_token == null || data.continuation_token.isEmpty()) {
                break;
            }
            continuationToken = data.continuation_token;
        }

        System.out.printf("[%s] Saved %d logs to %s%n", Instant.now(), totalLogs, filePath);
    }

    public static void main(String[] args) throws Exception {
        String baseURL = "https://api.us1.fga.dev"; // or regional endpoint
        String storeID = "YOUR_STORE_ID";
        String token = System.getenv("FGA_API_TOKEN");
        if (token == null || token.isEmpty()) {
            System.err.println("Missing FGA_API_TOKEN");
            System.exit(1);
        }
        String filePath = "logs_" + storeID + ".jsonl";
        System.out.printf("Starting hourly log polling for store %s at %s%n", storeID, baseURL);
        while (true) {
            pollLogs(baseURL, storeID, token, filePath);
            Thread.sleep(3600_000); // 1 hour
        }
    }
}

package main

import (
  "encoding/json"
  "fmt"
  "io"
  "net/http"
  "os"
  "time"
)

var baseURL = getenv("FGA_API_URL", "https://api.us1.fga.dev")
var storeID = os.Getenv("FGA_STORE_ID")
var token = os.Getenv("FGA_API_TOKEN")
var filePath = fmt.Sprintf("logs_%s.jsonl", storeID)

func getenv(k, def string) string { v := os.Getenv(k); if v == "" { return def }; return v }

type logResponse struct {
  Logs []map[string]any \`json:"logs"\`
  ContinuationToken string \`json:"continuation_token"\`
}

func fetchPage(cont string) (*logResponse, error) {
  url := fmt.Sprintf("%s/stores/%s/logs", baseURL, storeID)
  if cont != "" { url += "?continuation_token=" + cont }
  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Authorization", "Bearer "+token)
  req.Header.Set("Accept", "application/json")
  resp, err := http.DefaultClient.Do(req)
  if err != nil { return nil, err }
  defer resp.Body.Close()
  if resp.StatusCode != 200 { b,_ := io.ReadAll(resp.Body); return nil, fmt.Errorf("API error: %s", b) }
  var data logResponse
  if err := json.NewDecoder(resp.Body).Decode(&data); err != nil { return nil, err }
  return &data, nil
}

func pollOnce() error {
  cont := ""; total := 0
  for {
    data, err := fetchPage(cont)
    if err != nil { return err }
    if data.Logs == nil || len(data.Logs) == 0 { break }
    f, _ := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
    for _, l := range data.Logs { line, _ := json.Marshal(l); f.Write(append(line, '\\n')) ; total++ }
    f.Close()
    if data.ContinuationToken == "" { break }
    cont = data.ContinuationToken
  }
  fmt.Printf("Saved %d logs to %s\\n", total, filePath)
  return nil
}

func main() {
  if storeID == "" || token == "" { fmt.Println("Missing env vars"); return }
  for { _ = pollOnce(); time.Sleep(time.Hour) }
}

# Run hourly (e.g., cron). Appends logs to a file.
# Requires: FGA_API_URL, FGA_STORE_ID, FGA_API_TOKEN
FILE="logs_$FGA_STORE_ID.jsonl"
CONTINUATION=""
while true; do
  URL="$FGA_API_URL/stores/$FGA_STORE_ID/logs"
  if [ -n "$CONTINUATION" ]; then
    URL="$URL?continuation_token=$CONTINUATION"
  fi
  RESP=$(curl -s -H "Authorization: Bearer $FGA_API_TOKEN" -H 'Accept: application/json' "$URL")
  LOGS=$(echo "$RESP" | jq -c '.logs[]')
  if [ -z "$LOGS" ]; then
    echo "No logs returned"; break
  fi
  echo "$LOGS" >> "$FILE"
  CONTINUATION=$(echo "$RESP" | jq -r '.continuation_token // ""')
  if [ -z "$CONTINUATION" ]; then
    break
  fi
done
echo "Saved logs to $FILE"
# Sleep for an hour in a looping script: sleep 3600