Sequential Builder

The sequential builder is the easiest way to write Griffin monitors. You add steps in order and edges are created automatically: START → step 1 → step 2 → ... → END. For monitors that need branching or parallel paths, see the Graph Builder. For browser-based monitoring, see Browser Monitors.

Basic example

import { createMonitorBuilder, GET, Json, Assert, Frequency } from "@griffin-app/griffin";

const monitor = createMonitorBuilder({
  name: "health-check",
  frequency: Frequency.every(1).minute(),
})
  .request("check", {
    method: GET,
    base: "https://api.example.com",
    response_format: Json,
    path: "/health",
  })
  .assert((state) => [
    Assert(state["check"].status).equals(200),
  ])
  .build();

export default monitor;

Configuration

createMonitorBuilder({
  name: "my-test",                          // Required: unique monitor name
  frequency: Frequency.every(5).minutes(),  // Required: how often to run
  locations: ["us-east-1"],                 // Optional: where to execute
  notifications: [                          // Optional: alert rules
    notify.onFailure().toSlack("#alerts"),
  ],
})

Adding requests

Use .request(name, config) to add an HTTP request step:

builder
  .request("get-users", {
    method: GET,
    base: "https://api.example.com",
    response_format: Json,
    path: "/users",
  })
  .request("create-user", {
    method: POST,
    base: "https://api.example.com",
    response_format: Json,
    path: "/users",
    headers: { "Content-Type": "application/json" },
    body: { name: "Test User" },
  })

Response format: Use Json or Xml for JSON/XML bodies. Use NoContent (import from @griffin-app/griffin) for endpoints that return 204 with no body (e.g. successful DELETE); assert only on state["node"].status (e.g. .equals(204)), not on body. See the Graph Builder page for the full config reference.

Adding waits

Use .wait(name, duration) to pause between steps:

builder
  .request("create", { ... })
  .wait("pause", { seconds: 2 })
  .request("verify", { ... })

Duration formats:

1000 — milliseconds
{ seconds: 2 } — seconds
{ minutes: 1 } — minutes

Adding assertions

Use .assert(callback) to validate results from previous steps. The callback receives a type-safe state proxy with autocomplete for all node names defined above it:

builder
  .request("get-users", {
    method: GET,
    base: "https://api.example.com",
    response_format: Json,
    path: "/users",
  })
  .assert((state) => [
    // Check status code
    Assert(state["get-users"].status).equals(200),

    // Check response body
    Assert(state["get-users"].body["data"]).not.isEmpty(),
    Assert(state["get-users"].body["data"].at(0)["name"]).isDefined(),

    // Check headers
    Assert(state["get-users"].headers["content-type"]).contains("application/json"),

    // Check latency
    Assert(state["get-users"].latency).lessThan(2000),
  ])

See Assertions for the full assertion API.

Adding browser steps

Use .browser(name, browserAction) to add a Playwright browser step:

import {
  BrowserAction, navigate, waitForSelector,
  extractText, screenshot,
} from "@griffin-app/griffin";

builder
  .browser("check_page", BrowserAction({
    browser: "chromium",
    steps: [
      navigate("https://example.com"),
      waitForSelector("h1"),
      extractText("heading", "h1"),
      screenshot(),
    ],
  }))
  .assert((state) => [
    Assert(state["check_page"].page.url).contains("example.com"),
    Assert(state["check_page"].extracts["heading"]).equals("Welcome"),
    Assert(state["check_page"].console.errors).isEmpty(),
  ])

Browser steps can be mixed freely with .request() and .wait() in any order. See Browser Monitors for the full browser API, step reference, and examples.

Complete example

A multi-step API monitor that creates a resource, verifies it, and cleans up:

import {
  createMonitorBuilder, GET, POST, DELETE, Json,
  Assert, Frequency, secret
} from "@griffin-app/griffin";

const monitor = createMonitorBuilder({
  name: "user-lifecycle",
  frequency: Frequency.every(15).minutes(),
})
  .request("create", {
    method: POST,
    base: "https://api.example.com",
    response_format: Json,
    path: "/users",
    headers: { "Authorization": secret("API_KEY") },
    body: { name: "Test User", email: "test@example.com" },
  })
  .assert((state) => [
    Assert(state["create"].status).equals(201),
    Assert(state["create"].body["id"]).isDefined(),
  ])
  .wait("pause", { seconds: 1 })
  .request("verify", {
    method: GET,
    base: "https://api.example.com",
    response_format: Json,
    path: "/users/1",
    headers: { "Authorization": secret("API_KEY") },
  })
  .assert((state) => [
    Assert(state["verify"].status).equals(200),
    Assert(state["verify"].body["name"]).equals("Test User"),
  ])
  .request("cleanup", {
    method: DELETE,
    base: "https://api.example.com",
    response_format: Json,
    path: "/users/1",
    headers: { "Authorization": secret("API_KEY") },
  })
  .assert((state) => [
    Assert(state["cleanup"].status).equals(204),
  ])
  .build();

export default monitor;

Getting Started

Concepts

Writing Monitors

Platform

Griffin Hub

Griffin Cloud

Command Line

Sequential Builder

Basic example

Configuration

Adding requests

Adding waits

Adding assertions

Adding browser steps

Complete example

​Basic example

​Configuration

​Adding requests

​Adding waits

​Adding assertions

​Adding browser steps

​Complete example

Basic example

Configuration

Adding requests

Adding waits

Adding assertions

Adding browser steps

Complete example