Address feedback and add mermaid diagram to other SDK basics

go/basics/part0/durableexecution.go

@@ -16,10 +16,17 @@ import (
 // Applications consist of services with handlers that can be called over HTTP or Kafka.
 // Handlers can be called at http://restate:8080/ServiceName/handlerName
 //
-// Restate persists and proxies HTTP requests to handlers and manages their execution.
-// The SDK lets you implement handlers with regular code and control flow, no custom DSLs.
+// Restate persists and proxies HTTP requests to handlers and manages their execution:
+//
+// ┌────────┐   ┌─────────┐   ┌────────────────────────────┐
+// │ HTTP   │ → │ Restate │ → │ Restate Service (with SDK) │
+// │ Client │ ← │         │ ← │   handler1(), handler2()   │
+// └────────┘   └─────────┘   └────────────────────────────┘
+//
+// The SDK lets you implement handlers with regular code and control flow.
+// Handlers have access to a Context that provides durable building blocks that get persisted in Restate.
 // Whenever a handler uses the Restate Context, an event gets persisted in Restate's log.
-// After a failure, this log gets replayed to recover the state of the handler.
+// After a failure, a retry is triggered and this log gets replayed to recover the state of the handler.
 
 type SubscriptionRequest struct {
 	UserID        string   `json:"userId"`

java/basics/src/main/java/durable_execution/SubscriptionService.java

@@ -14,14 +14,20 @@
 //  - Tracking progress of execution and preventing re-execution of completed work on retries
 //  - Providing durable building blocks like timers, promises, and messaging: recoverable and revivable anywhere
 //
-// Applications consist of services (annotated with `@Service`) with handlers (annotated with `@Handler`)
-// that can be called over HTTP or Kafka.
+// Applications consist of services with handlers that can be called over HTTP or Kafka.
 // Handlers can be called at http://restate:8080/ServiceName/handlerName
 //
-// Restate persists and proxies HTTP requests to handlers and manages their execution.
-// The SDK lets you implement handlers with regular code and control flow, no custom DSLs.
+// Restate persists and proxies HTTP requests to handlers and manages their execution:
+//
+// ┌────────┐   ┌─────────┐   ┌────────────────────────────┐
+// │ HTTP   │ → │ Restate │ → │ Restate Service (with SDK) │
+// │ Client │ ← │         │ ← │   handler1(), handler2()   │
+// └────────┘   └─────────┘   └────────────────────────────┘
+//
+// The SDK lets you implement handlers with regular code and control flow.
+// Handlers have access to a Context that provides durable building blocks that get persisted in Restate.
 // Whenever a handler uses the Restate Context, an event gets persisted in Restate's log.
-// After a failure, this log gets replayed to recover the state of the handler.
+// After a failure, a retry is triggered and this log gets replayed to recover the state of the handler.
 
 @Service
 public class SubscriptionService {

kotlin/basics/src/main/kotlin/durable_execution/SubscriptionService.kt

@@ -14,14 +14,20 @@ import utils.createSubscription
 //  - Tracking progress of execution and preventing re-execution of completed work on retries
 //  - Providing durable building blocks like timers, promises, and messaging: recoverable and revivable anywhere
 //
-// Applications consist of services (annotated with `@Service`) with handlers (annotated with `@Handler`)
-// that can be called over HTTP or Kafka.
+// Applications consist of services with handlers that can be called over HTTP or Kafka.
 // Handlers can be called at http://restate:8080/ServiceName/handlerName
 //
-// Restate persists and proxies HTTP requests to handlers and manages their execution.
-// The SDK lets you implement handlers with regular code and control flow, no custom DSLs.
+// Restate persists and proxies HTTP requests to handlers and manages their execution:
+//
+// ┌────────┐   ┌─────────┐   ┌────────────────────────────┐
+// │ HTTP   │ → │ Restate │ → │ Restate Service (with SDK) │
+// │ Client │ ← │         │ ← │   handler1(), handler2()   │
+// └────────┘   └─────────┘   └────────────────────────────┘
+//
+// The SDK lets you implement handlers with regular code and control flow.
+// Handlers have access to a Context that provides durable building blocks that get persisted in Restate.
 // Whenever a handler uses the Restate Context, an event gets persisted in Restate's log.
-// After a failure, this log gets replayed to recover the state of the handler.
+// After a failure, a retry is triggered and this log gets replayed to recover the state of the handler.
 
 @Service
 class SubscriptionService {

python/basics/app/0_durable_execution.py

@@ -21,10 +21,17 @@ class SubscriptionRequest(BaseModel):
  Applications consist of services with handlers that can be called over HTTP or Kafka.
  Handlers can be called at http://restate:8080/ServiceName/handlerName
 
- Restate persists and proxies HTTP requests to handlers and manages their execution.
- The SDK lets you implement handlers with regular code and control flow, no custom DSLs.
+ Restate persists and proxies HTTP requests to handlers and manages their execution:
+
+ ┌────────┐   ┌─────────┐   ┌────────────────────────────┐
+ │ HTTP   │ → │ Restate │ → │ Restate Service (with SDK) │
+ │ Client │ ← │         │ ← │   handler1(), handler2()   │
+ └────────┘   └─────────┘   └────────────────────────────┘
+
+ The SDK lets you implement handlers with regular code and control flow.
+ Handlers have access to a Context that provides durable building blocks that get persisted in Restate.
  Whenever a handler uses the Restate Context, an event gets persisted in Restate's log.
- After a failure, this log gets replayed to recover the state of the handler.
+ After a failure, a retry is triggered and this log gets replayed to recover the state of the handler.
 """
 subscription_service = Service("SubscriptionService")
 

rust/basics/Cargo.toml

@@ -10,7 +10,7 @@ tracing-subscriber = "0.3"
 rand = "0.8.5"
 anyhow = "1.0.86"
 serde = { version = "1.0.208", features = ["derive"] }
-log = "0.4.22"
+tracing = "0.1.41"
 
 [[example]]
 name = "example-0"

rust/basics/src/p0_durable_execution.rs

@@ -6,10 +6,10 @@ use serde::Deserialize;
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub(crate) struct SubscriptionRequest {
-    pub(crate) user_id: String,
-    pub(crate) credit_card: String,
-    pub(crate) subscriptions: Vec<String>,
+pub struct SubscriptionRequest {
+    pub user_id: String,
+    pub credit_card: String,
+    pub subscriptions: Vec<String>,
 }
 
 // Restate helps you implement resilient applications:

rust/basics/src/stubs.rs

@@ -1,6 +1,6 @@
 #![allow(unused)]
 use anyhow::{anyhow, Result};
-use log::{error, info};
+use tracing::{error, info};
 use rand::random;
 use restate_sdk::context::ObjectContext;
 use restate_sdk::errors::HandlerError;

typescript/basics/src/0_durable_execution.ts

@@ -14,10 +14,17 @@ import {
 // Applications consist of services with handlers that can be called over HTTP or Kafka.
 // Handlers can be called at http://restate:8080/ServiceName/handlerName
 //
-// Restate persists and proxies HTTP requests to handlers and manages their execution.
-// The SDK lets you implement handlers with regular code and control flow, no custom DSLs.
+// Restate persists and proxies HTTP requests to handlers and manages their execution:
+//
+// ┌────────┐   ┌─────────┐   ┌────────────────────────────┐
+// │ HTTP   │ → │ Restate │ → │ Restate Service (with SDK) │
+// │ Client │ ← │         │ ← │   handler1(), handler2()   │
+// └────────┘   └─────────┘   └────────────────────────────┘
+//
+// The SDK lets you implement handlers with regular code and control flow.
+// Handlers have access to a Context that provides durable building blocks that get persisted in Restate.
 // Whenever a handler uses the Restate Context, an event gets persisted in Restate's log.
-// After a failure, this log gets replayed to recover the state of the handler.
+// After a failure, a retry is triggered and this log gets replayed to recover the state of the handler.
 
 const subscriptionService = restate.service({
     name: "SubscriptionService",