Heartbeat ping

BODY='{"status":"up","metadata":{"batch":1247,"durationMs":832}}'
SIG=$(printf '%s' "$BODY" | openssl dgst -sha256 -hmac "$OPSHIFT_SECRET" -hex | awk '{print $2}')
 
curl -X POST https://www.opshift.io/api/ping/payments-worker \
  -H "Content-Type: application/json" \
  -H "X-Webhook-Signature: $SIG" \
  -d "$BODY"

import { createHmac } from "node:crypto";
 
const secret = process.env.OPSHIFT_SECRET;
 
const body = JSON.stringify({
  status: "up",
  metadata: { batch: 1247, durationMs: 832 },
});
 
const signature = createHmac("sha256", secret).update(body).digest("hex");
 
const res = await fetch(
  "https://www.opshift.io/api/ping/payments-worker",
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Webhook-Signature": signature,
    },
    body,
  },
);
 
console.log(await res.json());

import hashlib
import hmac
import json
import os
import urllib.request
 
secret = os.environ["OPSHIFT_SECRET"]
 
body = json.dumps({
    "status": "up",
    "metadata": {"batch": 1247, "durationMs": 832},
}).encode()
 
signature = hmac.new(secret.encode(), body, hashlib.sha256).hexdigest()
 
request = urllib.request.Request(
    "https://www.opshift.io/api/ping/payments-worker",
    data=body,
    method="POST",
    headers={
        "Content-Type": "application/json",
        "X-Webhook-Signature": signature,
    },
)
 
with urllib.request.urlopen(request) as response:
    print(response.read().decode())

package main
 
import (
	"bytes"
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"io"
	"net/http"
	"os"
)
 
func main() {
	secret := os.Getenv("OPSHIFT_SECRET")
	body := []byte(`{"status":"up","metadata":{"batch":1247,"durationMs":832}}`)
 
	mac := hmac.New(sha256.New, []byte(secret))
	mac.Write(body)
	signature := hex.EncodeToString(mac.Sum(nil))
 
	req, _ := http.NewRequest(
		http.MethodPost,
		"https://www.opshift.io/api/ping/payments-worker",
		bytes.NewReader(body),
	)
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Webhook-Signature", signature)
 
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
 
	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}

use hmac::{Hmac, Mac};
use sha2::Sha256;
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let secret = std::env::var("OPSHIFT_SECRET")?;
    let body = r#"{"status":"up","metadata":{"batch":1247,"durationMs":832}}"#;
 
    let mut mac = Hmac::<Sha256>::new_from_slice(secret.as_bytes())?;
    mac.update(body.as_bytes());
    let signature = hex::encode(mac.finalize().into_bytes());
 
    let response = reqwest::Client::new()
        .post("https://www.opshift.io/api/ping/payments-worker")
        .header("Content-Type", "application/json")
        .header("X-Webhook-Signature", signature)
        .body(body)
        .send()
        .await?;
 
    println!("{}", response.text().await?);
    Ok(())
}