Changelog

Track all the updates and improvements to Sailhouse

Subscribe to RSS

Papercuts & Mobile language support 📲

February was a month of incremental improvements, and broadening our native language support to Kotlin & Swift, two pillars of the mobile ecosystem.

New

  • Kotlin & Swift SDKs

    Beta
    • Send events from more places thanks to native Kotlin/Swift SDKs

  • Acknowledging events from the dashboard

    • You can now acknowledge individual events from the dashboard, for both pull and push subscriptions.
Improved

  • Click-to-copy slug titles

    • You can now quickly copy app, topic, and subscription slugs throughout the application.

  • Clearer messages for duplicate app names

    • We weren't showing a clear error description when creating an app with a name that already existed.

  • Scheduled events are now more visible in the dashboard

    • We've made it easier to identify events which are due to be sent through a topic or subscription when looking at the events list.
Fixed

  • Topics wouldn't always create when sending the first event

    • In certain circumstances, we failed to create the topic when an event was sent to a non-existant topic. All of these events stayed in our buffer, and were eventually processed!

  • Some cron jobs would still run when paused

    • Fixed an issue where paused cron jobs would still run in a particular edge case.

Python SDK 🐍

Trigger regular scheduled work with ease thanks to our new cron jobs

New

  • Python SDK

    Beta
    • Start sending and receiving events in the snake-named language dominating the AI toolchain.
    await client.publish(
    topic="quick-test",
    data={"message": "Hello, World!", "number": 42}
)
Improved

  • Improved speed of event processing

    • The time from an event being ingested -> it being propogated to subscriptions is now as much as 10x faster.

  • Made it easier to collaborate with your team

    • It's now easier to invite users to your team on Sailhouse, just needing an email address to get them up and running.
Fixed

  • Subscription usage wouldn't show

    • If a subscription had only recieved 1 event in the previous 24 hours, it wouldn't show any activity

Cron jobs in beta 🎉

Trigger regular scheduled work with ease thanks to our new cron jobs

New

  • Cron jobs

    Beta
    • We're rolling this out with a select few partners to get things perfectly right, but you'll be able to trigger events on a schedule with native cron jobs.
Improved

  • More real-time analytics

    • We've reduced the latency

  • Better motion animations on graphs

    • Motion is now smoother on usage graphs across the dashboard
Fixed

  • Empty events could not be processed

    • Events without a body would briefly fail to be processed due to a bug in our internal pipeline. Events could be ingested without issue.

Scheduled events ⏰

New

  • Include a signature for events delivered by push subscription

    • Allows you to verify that the event came from Sailhouse

  • Scheduled events

    Beta
    • We now support scheduling an event for a future date, up to the end of time! Available in the Go & TypeScript SDK. UI coming next week.
    err := client.Publish(
  ctx,
  "user-order-review",
  data,
  // 7 days from now
  sailhouse.WithScheduledTime(time.Now().Add(time.Hour * 24 * 7)),
)
Fixed

  • Some events wouldn't stop being delivered

    • Fixed a bug that meant some (0.0001% of volume last week) events did not have a maximum number of attempted deliveries

Rust SDK 🦀

New

  • Team-wide analytics for events

    • Added team-wide analytics for events.

  • Rust SDK

    Beta
    • Not advised for production, but feedback and PRs appreciated!
    use std::{collections::HashMap, env};
use sailhouse::SailhouseClient;

fn main() {
    let token = match env::var("SAILHOUSE_TOKEN") {
        Ok(value) => value,
        Err(error) => {
            eprintln!("Failed to read SAILHOUSE_TOKEN: {}", error);
            return;
        }
    };

    let client = SailhouseClient::new(token);
    let mut data = HashMap::new();
    data.insert("message", "Hello world!");

    let publish_future = client.publish("example-topic", data);
    let _ = tokio::runtime::Runtime::new().unwrap().block_on(publish_future);
}
Improved

  • Performance improvements at the edge

    • Improved performance at the edge for receiving events
Fixed

  • Fixed edge node distribution issue

    • Fixed an issue where the Sailhouse's edge nodes weren't distributing events properly, resulting in longer processing times