wehub-resource-sync
547 lines
19 KiB
TypeScript
547 lines
19 KiB
TypeScript
import { ClickHouse, getPayloadField, getTaskRunField } from "@internal/clickhouse";
|
|
import { replicationContainerTest } from "@internal/testcontainers";
|
|
import { z } from "zod";
|
|
import { RunsReplicationService } from "~/services/runsReplicationService.server";
|
|
import { TestReplicationClickhouseFactory } from "./utils/testReplicationClickhouseFactory";
|
|
|
|
vi.setConfig({ testTimeout: 60_000 });
|
|
|
|
describe("RunsReplicationService (part 6/7)", () => {
|
|
replicationContainerTest(
|
|
"should sort batch inserts according to table schema ordering for optimal performance",
|
|
async ({ clickhouseContainer, redisOptions, postgresContainer, prisma }) => {
|
|
await prisma.$executeRawUnsafe(`ALTER TABLE public."TaskRun" REPLICA IDENTITY FULL;`);
|
|
|
|
const clickhouse = new ClickHouse({
|
|
url: clickhouseContainer.getConnectionUrl(),
|
|
name: "runs-replication-sorting",
|
|
logLevel: "warn",
|
|
});
|
|
|
|
const runsReplicationService = new RunsReplicationService({
|
|
clickhouseFactory: new TestReplicationClickhouseFactory(clickhouse),
|
|
pgConnectionUrl: postgresContainer.getConnectionUri(),
|
|
serviceName: "runs-replication-sorting",
|
|
slotName: "task_runs_to_clickhouse_v1",
|
|
publicationName: "task_runs_to_clickhouse_v1_publication",
|
|
redisOptions,
|
|
maxFlushConcurrency: 1,
|
|
flushIntervalMs: 100,
|
|
flushBatchSize: 10,
|
|
leaderLockTimeoutMs: 5000,
|
|
leaderLockExtendIntervalMs: 1000,
|
|
ackIntervalSeconds: 5,
|
|
logLevel: "warn",
|
|
});
|
|
|
|
// Listen to batchFlushed events to verify sorting
|
|
const batchFlushedEvents: Array<{
|
|
flushId: string;
|
|
taskRunInserts: any[];
|
|
payloadInserts: any[];
|
|
}> = [];
|
|
|
|
runsReplicationService.events.on("batchFlushed", (event) => {
|
|
batchFlushedEvents.push(event);
|
|
});
|
|
|
|
await runsReplicationService.start();
|
|
|
|
// Create two organizations to test sorting by organization_id
|
|
const org1 = await prisma.organization.create({
|
|
data: { title: "org-z", slug: "org-z" },
|
|
});
|
|
|
|
const org2 = await prisma.organization.create({
|
|
data: { title: "org-a", slug: "org-a" },
|
|
});
|
|
|
|
const project1 = await prisma.project.create({
|
|
data: {
|
|
name: "test-sorting-z",
|
|
slug: "test-sorting-z",
|
|
organizationId: org1.id,
|
|
externalRef: "test-sorting-z",
|
|
},
|
|
});
|
|
|
|
const project2 = await prisma.project.create({
|
|
data: {
|
|
name: "test-sorting-a",
|
|
slug: "test-sorting-a",
|
|
organizationId: org2.id,
|
|
externalRef: "test-sorting-a",
|
|
},
|
|
});
|
|
|
|
const env1 = await prisma.runtimeEnvironment.create({
|
|
data: {
|
|
slug: "test-sorting-z",
|
|
type: "DEVELOPMENT",
|
|
projectId: project1.id,
|
|
organizationId: org1.id,
|
|
apiKey: "test-sorting-z",
|
|
pkApiKey: "test-sorting-z",
|
|
shortcode: "test-sorting-z",
|
|
},
|
|
});
|
|
|
|
const env2 = await prisma.runtimeEnvironment.create({
|
|
data: {
|
|
slug: "test-sorting-a",
|
|
type: "DEVELOPMENT",
|
|
projectId: project2.id,
|
|
organizationId: org2.id,
|
|
apiKey: "test-sorting-a",
|
|
pkApiKey: "test-sorting-a",
|
|
shortcode: "test-sorting-a",
|
|
},
|
|
});
|
|
|
|
const now = Date.now();
|
|
|
|
const run1 = await prisma.taskRun.create({
|
|
data: {
|
|
friendlyId: `run_sort_org_z_${now}`,
|
|
taskIdentifier: "my-task-sort",
|
|
payload: JSON.stringify({ org: "z" }),
|
|
payloadType: "application/json",
|
|
traceId: `sort-z-${now}`,
|
|
spanId: `sort-z-${now}`,
|
|
queue: "test-sorting",
|
|
runtimeEnvironmentId: env1.id,
|
|
projectId: project1.id,
|
|
organizationId: org1.id,
|
|
environmentType: "DEVELOPMENT",
|
|
engine: "V2",
|
|
status: "PENDING",
|
|
createdAt: new Date(now + 2000),
|
|
},
|
|
});
|
|
await prisma.taskRun.update({
|
|
where: { id: run1.id },
|
|
data: { status: "DEQUEUED" },
|
|
});
|
|
|
|
await prisma.taskRun.create({
|
|
data: {
|
|
friendlyId: `run_sort_org_a_${now}`,
|
|
taskIdentifier: "my-task-sort",
|
|
payload: JSON.stringify({ org: "a" }),
|
|
payloadType: "application/json",
|
|
traceId: `sort-a-${now}`,
|
|
spanId: `sort-a-${now}`,
|
|
queue: "test-sorting",
|
|
runtimeEnvironmentId: env2.id,
|
|
projectId: project2.id,
|
|
organizationId: org2.id,
|
|
environmentType: "DEVELOPMENT",
|
|
engine: "V2",
|
|
status: "PENDING",
|
|
createdAt: new Date(now + 1000),
|
|
},
|
|
});
|
|
|
|
await prisma.taskRun.create({
|
|
data: {
|
|
friendlyId: `run_sort_org_a_${now}_2`,
|
|
taskIdentifier: "my-task-sort",
|
|
payload: JSON.stringify({ org: "a" }),
|
|
payloadType: "application/json",
|
|
traceId: `sort-a-${now}`,
|
|
spanId: `sort-a-${now}`,
|
|
queue: "test-sorting",
|
|
runtimeEnvironmentId: env2.id,
|
|
projectId: project2.id,
|
|
organizationId: org2.id,
|
|
environmentType: "DEVELOPMENT",
|
|
engine: "V2",
|
|
status: "PENDING",
|
|
createdAt: new Date(now),
|
|
},
|
|
});
|
|
|
|
await vi.waitFor(
|
|
() => {
|
|
expect(batchFlushedEvents[0]?.taskRunInserts.length).toBeGreaterThan(1);
|
|
expect(batchFlushedEvents[0]?.payloadInserts.length).toBeGreaterThan(1);
|
|
},
|
|
{ timeout: 30_000, interval: 250 }
|
|
);
|
|
|
|
// Verify sorting order: organization_id, project_id, environment_id, created_at, run_id
|
|
for (let i = 1; i < batchFlushedEvents[0]?.taskRunInserts.length; i++) {
|
|
const prev = batchFlushedEvents[0]!.taskRunInserts[i - 1];
|
|
const curr = batchFlushedEvents[0]!.taskRunInserts[i];
|
|
|
|
const prevKey = [
|
|
getTaskRunField(prev, "organization_id"),
|
|
getTaskRunField(prev, "project_id"),
|
|
getTaskRunField(prev, "environment_id"),
|
|
getTaskRunField(prev, "created_at"),
|
|
getTaskRunField(prev, "run_id"),
|
|
];
|
|
const currKey = [
|
|
getTaskRunField(curr, "organization_id"),
|
|
getTaskRunField(curr, "project_id"),
|
|
getTaskRunField(curr, "environment_id"),
|
|
getTaskRunField(curr, "created_at"),
|
|
getTaskRunField(curr, "run_id"),
|
|
];
|
|
|
|
const keysAreEqual = prevKey.every((val, idx) => val === currKey[idx]);
|
|
if (keysAreEqual) {
|
|
// Also valid order
|
|
continue;
|
|
}
|
|
|
|
// Compare tuples lexicographically
|
|
let isCorrectOrder = false;
|
|
for (let j = 0; j < prevKey.length; j++) {
|
|
if (prevKey[j] < currKey[j]) {
|
|
isCorrectOrder = true;
|
|
break;
|
|
}
|
|
if (prevKey[j] > currKey[j]) {
|
|
isCorrectOrder = false;
|
|
break;
|
|
}
|
|
// If equal, continue to next field
|
|
}
|
|
|
|
expect(isCorrectOrder).toBeTruthy();
|
|
}
|
|
|
|
// Verify payloadInserts are also sorted by run_id
|
|
for (let i = 1; i < batchFlushedEvents[0]?.payloadInserts.length; i++) {
|
|
const prev = batchFlushedEvents[0]!.payloadInserts[i - 1];
|
|
const curr = batchFlushedEvents[0]!.payloadInserts[i];
|
|
expect(getPayloadField(prev, "run_id") <= getPayloadField(curr, "run_id")).toBeTruthy();
|
|
}
|
|
|
|
await runsReplicationService.stop();
|
|
}
|
|
);
|
|
|
|
replicationContainerTest(
|
|
"should exhaustively replicate all TaskRun columns to ClickHouse",
|
|
async ({ clickhouseContainer, redisOptions, postgresContainer, prisma }) => {
|
|
await prisma.$executeRawUnsafe(`ALTER TABLE public."TaskRun" REPLICA IDENTITY FULL;`);
|
|
|
|
const clickhouse = new ClickHouse({
|
|
url: clickhouseContainer.getConnectionUrl(),
|
|
name: "runs-replication-exhaustive",
|
|
logLevel: "warn",
|
|
});
|
|
|
|
const runsReplicationService = new RunsReplicationService({
|
|
clickhouseFactory: new TestReplicationClickhouseFactory(clickhouse),
|
|
pgConnectionUrl: postgresContainer.getConnectionUri(),
|
|
serviceName: "runs-replication-exhaustive",
|
|
slotName: "task_runs_to_clickhouse_v1",
|
|
publicationName: "task_runs_to_clickhouse_v1_publication",
|
|
redisOptions,
|
|
maxFlushConcurrency: 1,
|
|
flushIntervalMs: 100,
|
|
flushBatchSize: 1,
|
|
leaderLockTimeoutMs: 5000,
|
|
leaderLockExtendIntervalMs: 1000,
|
|
ackIntervalSeconds: 5,
|
|
logLevel: "warn",
|
|
});
|
|
|
|
await runsReplicationService.start();
|
|
|
|
const organization = await prisma.organization.create({
|
|
data: {
|
|
title: "test-exhaustive",
|
|
slug: "test-exhaustive",
|
|
},
|
|
});
|
|
|
|
const project = await prisma.project.create({
|
|
data: {
|
|
name: "test-exhaustive",
|
|
slug: "test-exhaustive",
|
|
organizationId: organization.id,
|
|
externalRef: "test-exhaustive",
|
|
},
|
|
});
|
|
|
|
const runtimeEnvironment = await prisma.runtimeEnvironment.create({
|
|
data: {
|
|
slug: "test-exhaustive",
|
|
type: "PRODUCTION",
|
|
projectId: project.id,
|
|
organizationId: organization.id,
|
|
apiKey: "test-exhaustive",
|
|
pkApiKey: "test-exhaustive",
|
|
shortcode: "test-exhaustive",
|
|
},
|
|
});
|
|
|
|
// Create a batch for the batchId field
|
|
const batch = await prisma.batchTaskRun.create({
|
|
data: {
|
|
friendlyId: "batch_exhaustive",
|
|
runtimeEnvironmentId: runtimeEnvironment.id,
|
|
status: "PENDING",
|
|
},
|
|
});
|
|
|
|
// Create a root run for the rootTaskRunId field
|
|
const rootRun = await prisma.taskRun.create({
|
|
data: {
|
|
friendlyId: "run_root_exhaustive",
|
|
taskIdentifier: "root-task",
|
|
payload: JSON.stringify({ root: true }),
|
|
traceId: "root-trace-id",
|
|
spanId: "root-span-id",
|
|
queue: "root-queue",
|
|
runtimeEnvironmentId: runtimeEnvironment.id,
|
|
projectId: project.id,
|
|
organizationId: organization.id,
|
|
environmentType: "PRODUCTION",
|
|
engine: "V2",
|
|
},
|
|
});
|
|
|
|
// Create a parent run for the parentTaskRunId field
|
|
const parentRun = await prisma.taskRun.create({
|
|
data: {
|
|
friendlyId: "run_parent_exhaustive",
|
|
taskIdentifier: "parent-task",
|
|
payload: JSON.stringify({ parent: true }),
|
|
traceId: "parent-trace-id",
|
|
spanId: "parent-span-id",
|
|
queue: "parent-queue",
|
|
runtimeEnvironmentId: runtimeEnvironment.id,
|
|
projectId: project.id,
|
|
organizationId: organization.id,
|
|
environmentType: "PRODUCTION",
|
|
engine: "V2",
|
|
rootTaskRunId: rootRun.id,
|
|
depth: 1,
|
|
},
|
|
});
|
|
|
|
// Set up all the dates we'll use
|
|
const now = new Date();
|
|
const createdAt = new Date(now.getTime() - 10000);
|
|
const updatedAt = new Date(now.getTime() - 5000);
|
|
const startedAt = new Date(now.getTime() - 8000);
|
|
const executedAt = new Date(now.getTime() - 7500);
|
|
const completedAt = new Date(now.getTime() - 6000);
|
|
const delayUntil = new Date(now.getTime() - 9000);
|
|
const queuedAt = new Date(now.getTime() - 9500);
|
|
const expiredAt = null; // Not expired
|
|
|
|
// Create the main task run with ALL fields populated
|
|
const taskRun = await prisma.taskRun.create({
|
|
data: {
|
|
// Core identifiers
|
|
friendlyId: "run_exhaustive_test",
|
|
taskIdentifier: "exhaustive-task",
|
|
|
|
// Environment/project/org
|
|
runtimeEnvironmentId: runtimeEnvironment.id,
|
|
projectId: project.id,
|
|
organizationId: organization.id,
|
|
environmentType: "PRODUCTION",
|
|
|
|
// Engine and execution
|
|
engine: "V2",
|
|
status: "COMPLETED_SUCCESSFULLY",
|
|
attemptNumber: 3,
|
|
queue: "exhaustive-queue",
|
|
workerQueue: "exhaustive-worker-queue",
|
|
|
|
// Relationships
|
|
// Note: scheduleId is not set to test empty string handling
|
|
batchId: batch.id,
|
|
rootTaskRunId: rootRun.id,
|
|
parentTaskRunId: parentRun.id,
|
|
depth: 2,
|
|
|
|
// Timestamps
|
|
createdAt,
|
|
updatedAt,
|
|
startedAt,
|
|
executedAt,
|
|
completedAt,
|
|
delayUntil,
|
|
queuedAt,
|
|
expiredAt,
|
|
|
|
// Payload and output
|
|
payload: JSON.stringify({ input: "test-payload" }),
|
|
payloadType: "application/json",
|
|
output: JSON.stringify({ result: "test-output" }),
|
|
outputType: "application/json",
|
|
error: { message: "test error", name: "TestError" },
|
|
|
|
// Tracing
|
|
traceId: "exhaustive-trace-id-12345",
|
|
spanId: "exhaustive-span-id-67890",
|
|
|
|
// Versioning
|
|
taskVersion: "1.2.3",
|
|
sdkVersion: "3.0.0",
|
|
cliVersion: "2.5.1",
|
|
|
|
// Execution settings
|
|
machinePreset: "large-1x",
|
|
idempotencyKey: "exhaustive-idempotency-key-hashed",
|
|
idempotencyKeyOptions: {
|
|
key: "exhaustive-idempotency-key",
|
|
scope: "run",
|
|
},
|
|
ttl: "1h",
|
|
isTest: true,
|
|
concurrencyKey: "exhaustive-concurrency-key",
|
|
maxDurationInSeconds: 3600,
|
|
|
|
// Tags and bulk actions
|
|
runTags: ["tag1", "tag2", "exhaustive-tag"],
|
|
bulkActionGroupIds: ["bulk-group-1", "bulk-group-2"],
|
|
|
|
// Usage metrics
|
|
usageDurationMs: 12345,
|
|
costInCents: 50,
|
|
baseCostInCents: 25,
|
|
},
|
|
});
|
|
|
|
// Query ClickHouse directly to get all columns
|
|
const queryRuns = clickhouse.reader.query({
|
|
name: "exhaustive-replication-test",
|
|
query: "SELECT * FROM trigger_dev.task_runs_v2 FINAL WHERE run_id = {run_id:String}",
|
|
schema: z.any(),
|
|
params: z.object({ run_id: z.string() }),
|
|
});
|
|
|
|
const result = await vi.waitFor(
|
|
async () => {
|
|
const [queryError, rows] = await queryRuns({ run_id: taskRun.id });
|
|
|
|
expect(queryError).toBeNull();
|
|
expect(rows).toHaveLength(1);
|
|
|
|
return rows;
|
|
},
|
|
{ timeout: 30_000, interval: 250 }
|
|
);
|
|
|
|
const clickhouseRun = result![0];
|
|
|
|
// Exhaustively verify each column
|
|
// Core identifiers
|
|
expect(clickhouseRun.run_id).toBe(taskRun.id);
|
|
expect(clickhouseRun.friendly_id).toBe("run_exhaustive_test");
|
|
expect(clickhouseRun.task_identifier).toBe("exhaustive-task");
|
|
|
|
// Environment/project/org
|
|
expect(clickhouseRun.environment_id).toBe(runtimeEnvironment.id);
|
|
expect(clickhouseRun.project_id).toBe(project.id);
|
|
expect(clickhouseRun.organization_id).toBe(organization.id);
|
|
expect(clickhouseRun.environment_type).toBe("PRODUCTION");
|
|
|
|
// Engine and execution
|
|
expect(clickhouseRun.engine).toBe("V2");
|
|
expect(clickhouseRun.status).toBe("COMPLETED_SUCCESSFULLY");
|
|
expect(clickhouseRun.attempt).toBe(3);
|
|
expect(clickhouseRun.queue).toBe("exhaustive-queue");
|
|
expect(clickhouseRun.worker_queue).toBe("exhaustive-worker-queue");
|
|
|
|
// Relationships
|
|
expect(clickhouseRun.schedule_id).toBe(""); // Empty when not set
|
|
expect(clickhouseRun.batch_id).toBe(batch.id);
|
|
expect(clickhouseRun.root_run_id).toBe(rootRun.id);
|
|
expect(clickhouseRun.parent_run_id).toBe(parentRun.id);
|
|
expect(clickhouseRun.depth).toBe(2);
|
|
|
|
// Timestamps (ClickHouse returns DateTime64 as strings in UTC without 'Z' suffix)
|
|
// Helper to parse ClickHouse timestamp strings to milliseconds
|
|
function parseClickhouseTimestamp(ts: string | null): number | null {
|
|
if (ts === null || ts === "1970-01-01 00:00:00.000") return null;
|
|
return new Date(ts + "Z").getTime();
|
|
}
|
|
|
|
expect(parseClickhouseTimestamp(clickhouseRun.created_at)).toBe(createdAt.getTime());
|
|
expect(parseClickhouseTimestamp(clickhouseRun.updated_at)).toBe(updatedAt.getTime());
|
|
expect(parseClickhouseTimestamp(clickhouseRun.started_at)).toBe(startedAt.getTime());
|
|
expect(parseClickhouseTimestamp(clickhouseRun.executed_at)).toBe(executedAt.getTime());
|
|
expect(parseClickhouseTimestamp(clickhouseRun.completed_at)).toBe(completedAt.getTime());
|
|
expect(parseClickhouseTimestamp(clickhouseRun.delay_until)).toBe(delayUntil.getTime());
|
|
expect(parseClickhouseTimestamp(clickhouseRun.queued_at)).toBe(queuedAt.getTime());
|
|
expect(parseClickhouseTimestamp(clickhouseRun.expired_at)).toBeNull();
|
|
|
|
// Output (parsed JSON)
|
|
expect(clickhouseRun.output).toEqual({ data: { result: "test-output" } });
|
|
|
|
// Error
|
|
expect(clickhouseRun.error).toEqual({
|
|
data: { message: "test error", name: "TestError" },
|
|
});
|
|
|
|
// Tracing
|
|
expect(clickhouseRun.trace_id).toBe("exhaustive-trace-id-12345");
|
|
expect(clickhouseRun.span_id).toBe("exhaustive-span-id-67890");
|
|
|
|
// Versioning
|
|
expect(clickhouseRun.task_version).toBe("1.2.3");
|
|
expect(clickhouseRun.sdk_version).toBe("3.0.0");
|
|
expect(clickhouseRun.cli_version).toBe("2.5.1");
|
|
|
|
// Execution settings
|
|
expect(clickhouseRun.machine_preset).toBe("large-1x");
|
|
expect(clickhouseRun.idempotency_key).toBe("exhaustive-idempotency-key-hashed");
|
|
expect(clickhouseRun.idempotency_key_user).toBe("exhaustive-idempotency-key");
|
|
expect(clickhouseRun.idempotency_key_scope).toBe("run");
|
|
expect(clickhouseRun.expiration_ttl).toBe("1h");
|
|
expect(clickhouseRun.is_test).toBe(1); // ClickHouse returns booleans as integers
|
|
expect(clickhouseRun.concurrency_key).toBe("exhaustive-concurrency-key");
|
|
expect(clickhouseRun.max_duration_in_seconds).toBe(3600);
|
|
|
|
// Tags and bulk actions
|
|
expect(clickhouseRun.tags).toEqual(["tag1", "tag2", "exhaustive-tag"]);
|
|
expect(clickhouseRun.bulk_action_group_ids).toEqual(["bulk-group-1", "bulk-group-2"]);
|
|
|
|
// Usage metrics
|
|
expect(clickhouseRun.usage_duration_ms).toBe(12345);
|
|
expect(clickhouseRun.cost_in_cents).toBe(50);
|
|
expect(clickhouseRun.base_cost_in_cents).toBe(25);
|
|
|
|
// Internal ClickHouse columns
|
|
expect(clickhouseRun._is_deleted).toBe(0);
|
|
expect(clickhouseRun._version).toBeDefined();
|
|
expect(typeof clickhouseRun._version).toBe("number"); // ClickHouse returns UInt64 as number
|
|
|
|
// Also verify the payload was inserted into the payloads table
|
|
const queryPayloads = clickhouse.reader.query({
|
|
name: "exhaustive-payload-test",
|
|
query: "SELECT * FROM trigger_dev.raw_task_runs_payload_v1 WHERE run_id = {run_id:String}",
|
|
schema: z.any(),
|
|
params: z.object({ run_id: z.string() }),
|
|
});
|
|
|
|
const payloadResult = await vi.waitFor(
|
|
async () => {
|
|
const [payloadError, payloadRows] = await queryPayloads({ run_id: taskRun.id });
|
|
|
|
expect(payloadError).toBeNull();
|
|
expect(payloadRows).toHaveLength(1);
|
|
|
|
return payloadRows;
|
|
},
|
|
{ timeout: 30_000, interval: 250 }
|
|
);
|
|
expect(payloadResult![0].run_id).toBe(taskRun.id);
|
|
expect(parseClickhouseTimestamp(payloadResult![0].created_at)).toBe(createdAt.getTime());
|
|
expect(payloadResult![0].payload).toEqual({ data: { input: "test-payload" } });
|
|
|
|
await runsReplicationService.stop();
|
|
}
|
|
);
|
|
});
|