Metadata & tracing

// Logs X-Trace-Id and X-Request-Timestamp on every call — the pattern from
// /v3/metadata-and-tracing#logging-pattern, run against a real endpoint.
// signRequest is the real helper from /v3/authentication — adjust this path
// if you've copied it somewhere else in your own project.
const { signRequest } = require("../../authentication/node/sign-request");
// Pulls the two correlation fields off any v3 response. Kept separate from
// the network call so it's testable without a real request.
function formatLogEntry(res, op) {
  return {
    traceId: res.headers.get("x-trace-id"),
    serverTime: res.headers.get("x-request-timestamp"),
    op,
    status: res.status,
  };
}
async function listPairs() {
  const url = "https://api.openfx.com/v3/fx/pairs";
  const { headers } = signRequest({ method: "GET", url });
  const res = await fetch(url, { headers });
  const data = await res.json();
  console.log(formatLogEntry(res, "list_pairs"));
  return data;
}
module.exports = { formatLogEntry, listPairs };
if (require.main === module) {
  listPairs().catch((err) => {
    console.error("Error:", err.message);
    process.exitCode = 1;
  });
}

"""Logs X-Trace-Id and X-Request-Timestamp on every call — the pattern from
/v3/metadata-and-tracing#logging-pattern, run against a real endpoint."""
import os
import sys
# sign_request is the real helper from /v3/authentication — adjust this path
# if you've copied it somewhere else in your own project.
sys.path.insert(
    0, os.path.join(os.path.dirname(__file__), "..", "..", "authentication", "python")
)
from sign_request import sign_request  # noqa: E402
import requests  # noqa: E402
def format_log_entry(res, op):
    """Pulls the two correlation fields off any v3 response. Kept separate
    from the network call so it's testable without a real request."""
    return {
        "trace_id": res.headers.get("x-trace-id"),
        "server_time": res.headers.get("x-request-timestamp"),
        "op": op,
        "status": res.status_code,
    }
def list_pairs():
    url = "https://api.openfx.com/v3/fx/pairs"
    headers, _ = sign_request("GET", url)
    res = requests.get(url, headers=headers)
    print(format_log_entry(res, "list_pairs"))
    return res.json()
if __name__ == "__main__":
    list_pairs()

// Logs X-Trace-Id and X-Request-Timestamp on every call — the pattern from
// /v3/metadata-and-tracing#logging-pattern, run against a real endpoint.
import java.net.HttpURLConnection;
import java.net.URI;
import java.util.LinkedHashMap;
import java.util.Map;
public class LogTrace {
    // A response reduced to just the fields formatLogEntry needs, so it's
    // testable without a real HttpURLConnection.
    static class ResponseInfo {
        final String traceId;
        final String serverTime;
        final int status;
        ResponseInfo(String traceId, String serverTime, int status) {
            this.traceId = traceId;
            this.serverTime = serverTime;
            this.status = status;
        }
    }
    // Pulls the two correlation fields off any v3 response. Kept separate
    // from the network call so it's testable without a real request.
    static Map<String, Object> formatLogEntry(ResponseInfo res, String op) {
        Map<String, Object> entry = new LinkedHashMap<>();
        entry.put("traceId", res.traceId);
        entry.put("serverTime", res.serverTime);
        entry.put("op", op);
        entry.put("status", res.status);
        return entry;
    }
    public static void main(String[] args) throws Exception {
        String url = "https://api.openfx.com/v3/fx/pairs";
        // SignRequest is the real helper from /v3/authentication, compiled
        // on the classpath alongside this file — see that page's example.
        Map<String, String> headers = SignRequest.signRequest("GET", url, new byte[0]);
        HttpURLConnection conn = (HttpURLConnection) URI.create(url).toURL().openConnection();
        conn.setRequestMethod("GET");
        for (Map.Entry<String, String> h : headers.entrySet()) {
            conn.setRequestProperty(h.getKey(), h.getValue());
        }
        int status = conn.getResponseCode();
        ResponseInfo info = new ResponseInfo(
                conn.getHeaderField("X-Trace-Id"), conn.getHeaderField("X-Request-Timestamp"), status);
        System.out.println(formatLogEntry(info, "list_pairs"));
    }
}

// Logs X-Trace-Id and X-Request-Timestamp on every call — the pattern from
// /v3/metadata-and-tracing#logging-pattern, run against a real endpoint.
// Requires OpenSSL and libcurl.
#include <curl/curl.h>
#include <algorithm>
#include <cctype>
#include <iostream>
#include <map>
#include <string>
// Matches the definition in ../../authentication/cpp/sign_request.cpp,
// compiled together with this file — see that file for the real
// implementation of signRequest.
struct SignedRequest {
    std::string authHeader;
    std::string sigHeader;
};
SignedRequest signRequest(const std::string& method, const std::string& urlPath,
                           const std::string& query, const std::string& body);
struct ResponseInfo {
    std::string traceId;
    std::string serverTime;
    long status;
};
// Pulls the two correlation fields off any v3 response. Kept separate from
// the network call so it's testable without a real request.
std::map<std::string, std::string> formatLogEntry(const ResponseInfo& res, const std::string& op) {
    return {
        {"traceId", res.traceId},
        {"serverTime", res.serverTime},
        {"op", op},
        {"status", std::to_string(res.status)},
    };
}
static std::string toLower(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::tolower(c); });
    return s;
}
static size_t captureHeader(char* buffer, size_t size, size_t nitems, void* userdata) {
    auto* headers = static_cast<std::map<std::string, std::string>*>(userdata);
    std::string line(buffer, size * nitems);
    size_t colon = line.find(':');
    if (colon != std::string::npos) {
        std::string name = toLower(line.substr(0, colon));
        std::string value = line.substr(colon + 1);
        while (!value.empty() && value.front() == ' ') value.erase(0, 1);
        while (!value.empty() && (value.back() == '\r' || value.back() == '\n')) value.pop_back();
        (*headers)[name] = value;
    }
    return size * nitems;
}
#ifndef LOG_TRACE_NO_MAIN
int main() {
    try {
        std::string url = "https://api.openfx.com/v3/fx/pairs";
        SignedRequest req = signRequest("GET", "/v3/fx/pairs", "", "");
        CURL* curl = curl_easy_init();
        std::map<std::string, std::string> respHeaders;
        curl_slist* requestHeaders = nullptr;
        requestHeaders = curl_slist_append(requestHeaders, ("Authorization: " + req.authHeader).c_str());
        requestHeaders = curl_slist_append(requestHeaders, ("X-Request-Signature: " + req.sigHeader).c_str());
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, requestHeaders);
        curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, captureHeader);
        curl_easy_setopt(curl, CURLOPT_HEADERDATA, &respHeaders);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, +[](char*, size_t s, size_t n, void*) { return s * n; });
        CURLcode rc = curl_easy_perform(curl);
        if (rc != CURLE_OK) throw std::runtime_error(curl_easy_strerror(rc));
        long status = 0;
        curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &status);
        ResponseInfo info{respHeaders["x-trace-id"], respHeaders["x-request-timestamp"], status};
        for (const auto& [key, value] : formatLogEntry(info, "list_pairs")) {
            std::cout << key << ": " << value << std::endl;
        }
        curl_slist_free_all(requestHeaders);
        curl_easy_cleanup(curl);
        return 0;
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
}
#endif

// Logs X-Trace-Id and X-Request-Timestamp on every call — the pattern from
// /v3/metadata-and-tracing#logging-pattern, run against a real endpoint.
package main
import (
	"fmt"
	"net/http"
	// auth is the real signRequest helper from /v3/authentication — see
	// go.mod's replace directive if you've copied it somewhere else.
	auth "openfx-v3-authentication-example"
)
// Pulls the two correlation fields off any v3 response. Kept separate from
// the network call so it's testable without a real request.
func formatLogEntry(res *http.Response, op string) map[string]interface{} {
	return map[string]interface{}{
		"traceId":    res.Header.Get("X-Trace-Id"),
		"serverTime": res.Header.Get("X-Request-Timestamp"),
		"op":         op,
		"status":     res.StatusCode,
	}
}
func listPairs() (map[string]interface{}, error) {
	url := "https://api.openfx.com/v3/fx/pairs"
	signed, err := auth.SignRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}
	for k, v := range signed.Headers {
		req.Header.Set(k, v)
	}
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	entry := formatLogEntry(res, "list_pairs")
	fmt.Println(entry)
	return entry, nil
}
func main() {
	if _, err := listPairs(); err != nil {
		fmt.Println("Error:", err)
	}
}