Embed analytics in your apps, easily.

import crypto from 'crypto';

function generateTractorUrl(dashboard, filters) {

	const data = encodeURIComponent(JSON.stringify({ dashboard, filters }));

    const signature = crypto
        .createHmac('sha256', TRACTORSCOPE_API_SECRET)
        .update(data)
        .digest('hex');

    return `https://app.tractorscope.com/embed/dashboard/${dashboard}?data=${data}&signature=${signature}`;

}

// implement example
const analytics_url = generateTractorUrl('dsh_abc123', { 'userId': 'user_123' });
const metrics_url = generateTractorUrl('dsh_bcd234', {'spaceId': '55'})

import hmac
import hashlib
import json
import urllib.parse

TRACTORSCOPE_API_SECRET = 'your_tractorscope_api_secret'  # Use bytes

def generate_tractor_url(dashboard, filters):
    data_dict = {"dashboard": dashboard, "filters": filters}
    data_json = json.dumps(data_dict)
    data_encoded = urllib.parse.quote(data_json)

    signature = hmac.new(
        TRACTORSCOPE_API_SECRET,
        msg=data_encoded.encode('utf-8'),
        digestmod=hashlib.sha256
    ).hexdigest()

    return "https://app.tractorscope.com/embed/dashboard/{dashboard}?data={data_encoded}&signature={signature}"

# Example usage
analytics_url = generate_tractor_url('dsh_abc123', {'userId': 'user_123'})
metrics_url = generate_tractor_url('dsh_bcd234', {'spaceId': '55'})

defmodule TractorScope do
  @tractorscope_secret System.get_env("TRACTORSCOPE_API_SECRET")

  def generate_tractor_url(dashboard, filters) do
    payload = %{
      "dashboard" => dashboard,
      "filters" => filters
    }

    data =
      payload
      |> Jason.encode!()
      |> URI.encode()

    signature =
      :crypto.mac(:hmac, :sha256, @tractorscope_secret, data)
      |> Base.encode16(case: :lower)

    "https://app.tractorscope.com/embed/dashboard/#{dashboard}?data=#{data}&signature=#{signature}"
  end
end

# Example usage
analytics_url = TractorScope.generate_tractor_url("dsh_abc123", %{"userId" => "user_123"})
metrics_url = TractorScope.generate_tractor_url("dsh_bcd234", %{"spaceId" => "55"})

<?php

function generateTractorUrl($dashboard, $filters) {
    $TRACTORSCOPE_API_SECRET = getenv('TRACTORSCOPE_API_SECRET');

    $payload = [
        'dashboard' => $dashboard,
        'filters' => $filters
    ];

    $data = urlencode(json_encode($payload));
    $signature = hash_hmac('sha256', $data, $TRACTORSCOPE_API_SECRET);

    return "https://app.tractorscope.com/embed/dashboard/{$dashboard}?data={$data}&signature={$signature}";
}

// Example usage
$analytics_url = generateTractorUrl('dsh_abc123', ['userId' => 'user_123']);
$metrics_url = generateTractorUrl('dsh_bcd234', ['spaceId' => '55']);

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"net/url"
	"os"
)

func generateTractorUrl(dashboard string, filters map[string]string) string {
	payload := map[string]interface{}{
		"dashboard": dashboard,
		"filters":   filters,
	}

	jsonData, err := json.Marshal(payload)
	if err != nil {
		panic(err)
	}

	data := url.QueryEscape(string(jsonData))
	secret := os.Getenv("TRACTORSCOPE_API_SECRET")

	h := hmac.New(sha256.New, []byte(secret))
	h.Write([]byte(data))
	signature := hex.EncodeToString(h.Sum(nil))

	return fmt.Sprintf("https://app.tractorscope.com/embed/dashboard/%s?data=%s&signature=%s", dashboard, data, signature)
}

func main() {
	analyticsURL := generateTractorUrl("dsh_abc123", map[string]string{"userId": "user_123"})
	metricsURL := generateTractorUrl("dsh_bcd234", map[string]string{"spaceId": "55"})

	fmt.Println("Analytics URL:", analyticsURL)
	fmt.Println("Metrics URL:", metricsURL)
}

#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <cstdlib>
#include <openssl/hmac.h>
#include <nlohmann/json.hpp>
#include <curl/curl.h>

using json = nlohmann::json;

std::string url_encode(const std::string& value) {
    char* output = curl_easy_escape(nullptr, value.c_str(), value.length());
    std::string encoded(output);
    curl_free(output);
    return encoded;
}

std::string hmac_sha256(const std::string& key, const std::string& data) {
    unsigned char* digest;
    digest = HMAC(EVP_sha256(),
                  key.c_str(), key.length(),
                  reinterpret_cast<const unsigned char*>(data.c_str()), data.length(),
                  nullptr, nullptr);

    std::ostringstream result;
    for (int i = 0; i < 32; ++i) {
        result << std::hex << std::setw(2) << std::setfill('0') << (int)digest[i];
    }
    return result.str();
}

std::string generateTractorUrl(const std::string& dashboard, const json& filters) {
    json payload = {
        {"dashboard", dashboard},
        {"filters", filters}
    };

    std::string data = url_encode(payload.dump());
    std::string secret = std::getenv("TRACTORSCOPE_API_SECRET");

    std::string signature = hmac_sha256(secret, data);

    std::ostringstream url;
    url << "https://app.tractorscope.com/embed/dashboard/"
        << dashboard
        << "?data=" << data
        << "&signature=" << signature;

    return url.str();
}

int main() {
    std::string analyticsUrl = generateTractorUrl("dsh_abc123", {{"userId", "user_123"}});
    std::string metricsUrl = generateTractorUrl("dsh_bcd234", {{"spaceId", "55"}});

    std::cout << "Analytics URL: " << analyticsUrl << std::endl;
    std::cout << "Metrics URL: " << metricsUrl << std::endl;

    return 0;
}

use hmac::{Hmac, Mac};
use sha2::Sha256;
use serde_json::json;
use std::env;
use urlencoding::encode;

type HmacSha256 = Hmac<Sha256>;

fn generate_tractor_url(dashboard: &str, filters: serde_json::Value) -> String {
    let payload = json!({
        "dashboard": dashboard,
        "filters": filters
    });

    let data = encode(&payload.to_string());

    let secret = env::var("TRACTORSCOPE_API_SECRET")
        .expect("TRACTORSCOPE_API_SECRET not set");

    let mut mac = HmacSha256::new_from_slice(secret.as_bytes())
        .expect("HMAC can take key of any size");
    mac.update(data.as_bytes());
    let signature = hex::encode(mac.finalize().into_bytes());

    format!(
        "https://app.tractorscope.com/embed/dashboard/{}?data={}&signature={}",
        dashboard, data, signature
    )
}

fn main() {
    let analytics_url = generate_tractor_url(
        "dsh_abc123",
        json!({ "userId": "user_123" }),
    );

    let metrics_url = generate_tractor_url(
        "dsh_bcd234",
        json!({ "spaceId": "55" }),
    );

    println!("Analytics URL: {}", analytics_url);
    println!("Metrics URL: {}", metrics_url);
}