[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"article-deep-evm-24-bidongi-rust-kontekseuteu-jeonpa-dedeurain-chwiso":3},{"article":4,"author":51},{"id":5,"category_id":6,"title":7,"slug":8,"excerpt":9,"content_md":10,"content_html":11,"locale":12,"author_id":13,"published":14,"published_at":15,"meta_title":16,"meta_description":17,"focus_keyword":18,"og_image":19,"canonical_url":19,"robots_meta":20,"created_at":15,"updated_at":15,"tags":21,"category_name":31,"related_articles":32},"d5000000-0000-0000-0000-000000000124","a0000000-0000-0000-0000-000000000056","Deep EVM #24: 비동기 Rust에서의 컨텍스트 전파 — 데드라인, 취소, 트레이싱","deep-evm-24-bidongi-rust-kontekseuteu-jeonpa-dedeurain-chwiso","Go 스타일 컨텍스트 전파를 비동기 Rust에서 구현합니다. 데드라인, CancellationToken, tokio::select! 취소, 트레이싱 스팬 전파를 다룹니다.","## Go의 context.Context가 해결하는 문제\n\nGo의 `context.Context`는 비동기 작업의 세 가지 핵심 문제를 해결합니다: 데드라인(이 작업은 언제까지 완료되어야 하는가?), 취소(이 작업을 중단해야 하는가?), 값 전파(이 요청과 관련된 메타데이터는 무엇인가?). Rust에는 `context.Context`에 대한 직접적인 대응물이 없지만, tokio의 원시 자료형으로 동일한 패턴을 구축할 수 있습니다.\n\n## 데드라인: tokio::time::timeout\n\n가장 간단한 형태의 컨텍스트는 데드라인입니다 — 작업이 지정된 시간 내에 완료되지 않으면 취소합니다:\n\n```rust\nuse tokio::time::{timeout, Duration};\n\nasync fn fetch_with_deadline(url: &str) -> Result\u003CResponse> {\n    timeout(Duration::from_secs(5), reqwest::get(url))\n        .await\n        .map_err(|_| anyhow::anyhow!(\"Request timed out after 5s\"))?\n        .map_err(Into::into)\n}\n```\n\n중첩된 데드라인도 올바르게 작동합니다 — 내부 타임아웃이 외부 타임아웃보다 짧으면 내부가 먼저 트리거됩니다:\n\n```rust\nasync fn process_request() -> Result\u003C()> {\n    \u002F\u002F 전체 요청: 10초\n    timeout(Duration::from_secs(10), async {\n        \u002F\u002F DB 조회: 2초\n        let user = timeout(Duration::from_secs(2),\n            db.get_user(id)\n        ).await??;\n\n        \u002F\u002F 외부 API: 5초\n        let data = timeout(Duration::from_secs(5),\n            api.fetch_data(&user)\n        ).await??;\n\n        Ok(data)\n    }).await?\n}\n```\n\n## 취소: CancellationToken\n\n`tokio_util::sync::CancellationToken`은 Go의 `context.WithCancel()`에 가장 가까운 대응물입니다:\n\n```rust\nuse tokio_util::sync::CancellationToken;\nuse tokio::select;\n\nasync fn long_running_task(token: CancellationToken) -> Result\u003C()> {\n    loop {\n        select! {\n            _ = token.cancelled() => {\n                tracing::info!(\"Task cancelled, cleaning up\");\n                return Ok(());\n            }\n            result = do_work() => {\n                result?;\n            }\n        }\n    }\n}\n\n\u002F\u002F 사용\nlet token = CancellationToken::new();\nlet child_token = token.child_token();\n\ntokio::spawn(long_running_task(child_token));\n\n\u002F\u002F 나중에 — 모든 자식 작업을 취소\ntoken.cancel();\n```\n\n`child_token()`은 Go의 `context.WithCancel(parent)`와 동일합니다. 부모 토큰이 취소되면 모든 자식 토큰도 자동으로 취소됩니다.\n\n## 토큰 트리와 계층적 취소\n\n복잡한 시스템에서는 취소 토큰의 트리를 구성합니다:\n\n```rust\nstruct RequestContext {\n    token: CancellationToken,\n    deadline: Instant,\n    request_id: String,\n    trace_id: String,\n}\n\nimpl RequestContext {\n    fn new(timeout: Duration) -> Self {\n        Self {\n            token: CancellationToken::new(),\n            deadline: Instant::now() + timeout,\n            request_id: Uuid::new_v4().to_string(),\n            trace_id: Uuid::new_v4().to_string(),\n        }\n    }\n\n    fn child(&self) -> Self {\n        Self {\n            token: self.token.child_token(),\n            deadline: self.deadline,\n            request_id: self.request_id.clone(),\n            trace_id: self.trace_id.clone(),\n        }\n    }\n\n    fn remaining(&self) -> Duration {\n        self.deadline.saturating_duration_since(Instant::now())\n    }\n\n    async fn with_deadline\u003CF, T>(&self, fut: F) -> Result\u003CT>\n    where\n        F: Future\u003COutput = Result\u003CT>>,\n    {\n        select! {\n            _ = self.token.cancelled() => {\n                Err(anyhow::anyhow!(\"Cancelled\"))\n            }\n            _ = tokio::time::sleep_until(self.deadline.into()) => {\n                Err(anyhow::anyhow!(\"Deadline exceeded\"))\n            }\n            result = fut => result\n        }\n    }\n}\n```\n\n## tokio::select!를 사용한 취소 패턴\n\n`tokio::select!`는 여러 비동기 작업 중 먼저 완료되는 것을 선택하는 Rust의 핵심 취소 메커니즘입니다:\n\n```rust\nasync fn resilient_fetch(\n    ctx: &RequestContext,\n    primary_url: &str,\n    fallback_url: &str,\n) -> Result\u003CResponse> {\n    select! {\n        _ = ctx.token.cancelled() => {\n            Err(anyhow::anyhow!(\"Request cancelled\"))\n        }\n        result = async {\n            \u002F\u002F 기본에 먼저 시도, 실패 시 폴백\n            match timeout(Duration::from_secs(2), reqwest::get(primary_url)).await {\n                Ok(Ok(resp)) => Ok(resp),\n                _ => {\n                    tracing::warn!(\"Primary failed, trying fallback\");\n                    reqwest::get(fallback_url).await.map_err(Into::into)\n                }\n            }\n        } => result\n    }\n}\n```\n\n`select!`의 중요한 특성: 선택되지 않은 분기의 Future는 드롭됩니다. 이것이 Rust의 구조적 취소입니다 — Go와 달리 고루틴이 암묵적으로 누수되는 문제가 없습니다.\n\n## 트레이싱 스팬 전파\n\n`tracing` 크레이트의 스팬은 컨텍스트의 또 다른 측면을 전파합니다 — 구조화된 로깅 컨텍스트:\n\n```rust\nuse tracing::{instrument, info_span, Instrument};\n\n#[instrument(skip(ctx, db))]\nasync fn handle_request(\n    ctx: RequestContext,\n    db: Arc\u003CDatabase>,\n    request: Request,\n) -> Result\u003CResponse> {\n    let user = get_user(&ctx, &db, request.user_id)\n        .instrument(info_span!(\"get_user\", user_id = request.user_id))\n        .await?;\n\n    let orders = get_orders(&ctx, &db, &user)\n        .instrument(info_span!(\"get_orders\", user_name = %user.name))\n        .await?;\n\n    Ok(Response::new(user, orders))\n}\n```\n\n`.instrument(span)` 메서드는 비동기 작업을 스팬과 연결하여, 해당 작업의 모든 로그가 올바른 컨텍스트를 포함하도록 합니다.\n\n## task_local!을 사용한 암시적 전파\n\n명시적으로 컨텍스트를 모든 함수에 전달하는 것이 지루하다면, `tokio::task_local!`을 사용할 수 있습니다:\n\n```rust\ntokio::task_local! {\n    static REQUEST_CONTEXT: RequestContext;\n}\n\nasync fn handle_request(ctx: RequestContext) -> Result\u003CResponse> {\n    REQUEST_CONTEXT.scope(ctx, async {\n        \u002F\u002F 이 스코프 내의 모든 코드가 컨텍스트에 접근 가능\n        let user = get_user().await?;\n        let orders = get_orders(&user).await?;\n        Ok(Response::new(user, orders))\n    }).await\n}\n\nasync fn get_user() -> Result\u003CUser> {\n    REQUEST_CONTEXT.with(|ctx| {\n        tracing::info!(request_id = %ctx.request_id, \"Fetching user\");\n    });\n    \u002F\u002F ...\n}\n```\n\n이 패턴은 Go의 `context.Value()`와 유사하지만, 타입 안전합니다.\n\n## 우아한 종료\n\n컨텍스트 전파의 가장 중요한 응용 중 하나는 우아한 종료입니다:\n\n```rust\n#[tokio::main]\nasync fn main() -> Result\u003C()> {\n    let shutdown = CancellationToken::new();\n\n    \u002F\u002F Ctrl+C 핸들러\n    let shutdown_clone = shutdown.clone();\n    tokio::spawn(async move {\n        tokio::signal::ctrl_c().await.unwrap();\n        tracing::info!(\"Shutdown signal received\");\n        shutdown_clone.cancel();\n    });\n\n    \u002F\u002F 모든 서비스에 취소 토큰 전달\n    let server = tokio::spawn(\n        run_server(shutdown.child_token())\n    );\n    let worker = tokio::spawn(\n        run_background_worker(shutdown.child_token())\n    );\n\n    \u002F\u002F 모든 서비스가 우아하게 종료될 때까지 대기\n    let _ = tokio::join!(server, worker);\n    tracing::info!(\"Clean shutdown complete\");\n    Ok(())\n}\n```\n\n## 결론\n\nRust에서의 컨텍스트 전파는 Go의 `context.Context`와 동일한 문제를 해결하지만, 다른 원시 자료형으로 구성됩니다: `tokio::time::timeout`은 데드라인, `CancellationToken`은 취소, `tracing` 스팬은 구조화된 로깅 컨텍스트, `task_local!`은 암시적 값 전파. `select!` 매크로는 이 모든 것을 연결하는 접착제입니다. Rust의 소유권 시스템과 드롭 의미론은 Go에서 흔한 고루틴 누수 문제를 구조적으로 방지합니다.","\u003Ch2 id=\"go-context-context\">Go의 context.Context가 해결하는 문제\u003C\u002Fh2>\n\u003Cp>Go의 \u003Ccode>context.Context\u003C\u002Fcode>는 비동기 작업의 세 가지 핵심 문제를 해결합니다: 데드라인(이 작업은 언제까지 완료되어야 하는가?), 취소(이 작업을 중단해야 하는가?), 값 전파(이 요청과 관련된 메타데이터는 무엇인가?). Rust에는 \u003Ccode>context.Context\u003C\u002Fcode>에 대한 직접적인 대응물이 없지만, tokio의 원시 자료형으로 동일한 패턴을 구축할 수 있습니다.\u003C\u002Fp>\n\u003Ch2 id=\"tokio-time-timeout\">데드라인: tokio::time::timeout\u003C\u002Fh2>\n\u003Cp>가장 간단한 형태의 컨텍스트는 데드라인입니다 — 작업이 지정된 시간 내에 완료되지 않으면 취소합니다:\u003C\u002Fp>\n\u003Cpre>\u003Ccode class=\"language-rust\">use tokio::time::{timeout, Duration};\n\nasync fn fetch_with_deadline(url: &str) -> Result<Response> {\n    timeout(Duration::from_secs(5), reqwest::get(url))\n        .await\n        .map_err(|_| anyhow::anyhow!(\"Request timed out after 5s\"))?\n        .map_err(Into::into)\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Cp>중첩된 데드라인도 올바르게 작동합니다 — 내부 타임아웃이 외부 타임아웃보다 짧으면 내부가 먼저 트리거됩니다:\u003C\u002Fp>\n\u003Cpre>\u003Ccode class=\"language-rust\">async fn process_request() -> Result<()> {\n    \u002F\u002F 전체 요청: 10초\n    timeout(Duration::from_secs(10), async {\n        \u002F\u002F DB 조회: 2초\n        let user = timeout(Duration::from_secs(2),\n            db.get_user(id)\n        ).await??;\n\n        \u002F\u002F 외부 API: 5초\n        let data = timeout(Duration::from_secs(5),\n            api.fetch_data(&user)\n        ).await??;\n\n        Ok(data)\n    }).await?\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Ch2 id=\"cancellationtoken\">취소: CancellationToken\u003C\u002Fh2>\n\u003Cp>\u003Ccode>tokio_util::sync::CancellationToken\u003C\u002Fcode>은 Go의 \u003Ccode>context.WithCancel()\u003C\u002Fcode>에 가장 가까운 대응물입니다:\u003C\u002Fp>\n\u003Cpre>\u003Ccode class=\"language-rust\">use tokio_util::sync::CancellationToken;\nuse tokio::select;\n\nasync fn long_running_task(token: CancellationToken) -> Result<()> {\n    loop {\n        select! {\n            _ = token.cancelled() => {\n                tracing::info!(\"Task cancelled, cleaning up\");\n                return Ok(());\n            }\n            result = do_work() => {\n                result?;\n            }\n        }\n    }\n}\n\n\u002F\u002F 사용\nlet token = CancellationToken::new();\nlet child_token = token.child_token();\n\ntokio::spawn(long_running_task(child_token));\n\n\u002F\u002F 나중에 — 모든 자식 작업을 취소\ntoken.cancel();\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Cp>\u003Ccode>child_token()\u003C\u002Fcode>은 Go의 \u003Ccode>context.WithCancel(parent)\u003C\u002Fcode>와 동일합니다. 부모 토큰이 취소되면 모든 자식 토큰도 자동으로 취소됩니다.\u003C\u002Fp>\n\u003Ch2 id=\"\">토큰 트리와 계층적 취소\u003C\u002Fh2>\n\u003Cp>복잡한 시스템에서는 취소 토큰의 트리를 구성합니다:\u003C\u002Fp>\n\u003Cpre>\u003Ccode class=\"language-rust\">struct RequestContext {\n    token: CancellationToken,\n    deadline: Instant,\n    request_id: String,\n    trace_id: String,\n}\n\nimpl RequestContext {\n    fn new(timeout: Duration) -> Self {\n        Self {\n            token: CancellationToken::new(),\n            deadline: Instant::now() + timeout,\n            request_id: Uuid::new_v4().to_string(),\n            trace_id: Uuid::new_v4().to_string(),\n        }\n    }\n\n    fn child(&self) -> Self {\n        Self {\n            token: self.token.child_token(),\n            deadline: self.deadline,\n            request_id: self.request_id.clone(),\n            trace_id: self.trace_id.clone(),\n        }\n    }\n\n    fn remaining(&self) -> Duration {\n        self.deadline.saturating_duration_since(Instant::now())\n    }\n\n    async fn with_deadline<F, T>(&self, fut: F) -> Result<T>\n    where\n        F: Future<Output = Result<T>>,\n    {\n        select! {\n            _ = self.token.cancelled() => {\n                Err(anyhow::anyhow!(\"Cancelled\"))\n            }\n            _ = tokio::time::sleep_until(self.deadline.into()) => {\n                Err(anyhow::anyhow!(\"Deadline exceeded\"))\n            }\n            result = fut => result\n        }\n    }\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Ch2 id=\"tokio-select\">tokio::select!를 사용한 취소 패턴\u003C\u002Fh2>\n\u003Cp>\u003Ccode>tokio::select!\u003C\u002Fcode>는 여러 비동기 작업 중 먼저 완료되는 것을 선택하는 Rust의 핵심 취소 메커니즘입니다:\u003C\u002Fp>\n\u003Cpre>\u003Ccode class=\"language-rust\">async fn resilient_fetch(\n    ctx: &RequestContext,\n    primary_url: &str,\n    fallback_url: &str,\n) -> Result<Response> {\n    select! {\n        _ = ctx.token.cancelled() => {\n            Err(anyhow::anyhow!(\"Request cancelled\"))\n        }\n        result = async {\n            \u002F\u002F 기본에 먼저 시도, 실패 시 폴백\n            match timeout(Duration::from_secs(2), reqwest::get(primary_url)).await {\n                Ok(Ok(resp)) => Ok(resp),\n                _ => {\n                    tracing::warn!(\"Primary failed, trying fallback\");\n                    reqwest::get(fallback_url).await.map_err(Into::into)\n                }\n            }\n        } => result\n    }\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Cp>\u003Ccode>select!\u003C\u002Fcode>의 중요한 특성: 선택되지 않은 분기의 Future는 드롭됩니다. 이것이 Rust의 구조적 취소입니다 — Go와 달리 고루틴이 암묵적으로 누수되는 문제가 없습니다.\u003C\u002Fp>\n\u003Ch2 id=\"\">트레이싱 스팬 전파\u003C\u002Fh2>\n\u003Cp>\u003Ccode>tracing\u003C\u002Fcode> 크레이트의 스팬은 컨텍스트의 또 다른 측면을 전파합니다 — 구조화된 로깅 컨텍스트:\u003C\u002Fp>\n\u003Cpre>\u003Ccode class=\"language-rust\">use tracing::{instrument, info_span, Instrument};\n\n#[instrument(skip(ctx, db))]\nasync fn handle_request(\n    ctx: RequestContext,\n    db: Arc<Database>,\n    request: Request,\n) -> Result<Response> {\n    let user = get_user(&ctx, &db, request.user_id)\n        .instrument(info_span!(\"get_user\", user_id = request.user_id))\n        .await?;\n\n    let orders = get_orders(&ctx, &db, &user)\n        .instrument(info_span!(\"get_orders\", user_name = %user.name))\n        .await?;\n\n    Ok(Response::new(user, orders))\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Cp>\u003Ccode>.instrument(span)\u003C\u002Fcode> 메서드는 비동기 작업을 스팬과 연결하여, 해당 작업의 모든 로그가 올바른 컨텍스트를 포함하도록 합니다.\u003C\u002Fp>\n\u003Ch2 id=\"task-local\">task_local!을 사용한 암시적 전파\u003C\u002Fh2>\n\u003Cp>명시적으로 컨텍스트를 모든 함수에 전달하는 것이 지루하다면, \u003Ccode>tokio::task_local!\u003C\u002Fcode>을 사용할 수 있습니다:\u003C\u002Fp>\n\u003Cpre>\u003Ccode class=\"language-rust\">tokio::task_local! {\n    static REQUEST_CONTEXT: RequestContext;\n}\n\nasync fn handle_request(ctx: RequestContext) -> Result<Response> {\n    REQUEST_CONTEXT.scope(ctx, async {\n        \u002F\u002F 이 스코프 내의 모든 코드가 컨텍스트에 접근 가능\n        let user = get_user().await?;\n        let orders = get_orders(&user).await?;\n        Ok(Response::new(user, orders))\n    }).await\n}\n\nasync fn get_user() -> Result<User> {\n    REQUEST_CONTEXT.with(|ctx| {\n        tracing::info!(request_id = %ctx.request_id, \"Fetching user\");\n    });\n    \u002F\u002F ...\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Cp>이 패턴은 Go의 \u003Ccode>context.Value()\u003C\u002Fcode>와 유사하지만, 타입 안전합니다.\u003C\u002Fp>\n\u003Ch2 id=\"\">우아한 종료\u003C\u002Fh2>\n\u003Cp>컨텍스트 전파의 가장 중요한 응용 중 하나는 우아한 종료입니다:\u003C\u002Fp>\n\u003Cpre>\u003Ccode class=\"language-rust\">#[tokio::main]\nasync fn main() -> Result<()> {\n    let shutdown = CancellationToken::new();\n\n    \u002F\u002F Ctrl+C 핸들러\n    let shutdown_clone = shutdown.clone();\n    tokio::spawn(async move {\n        tokio::signal::ctrl_c().await.unwrap();\n        tracing::info!(\"Shutdown signal received\");\n        shutdown_clone.cancel();\n    });\n\n    \u002F\u002F 모든 서비스에 취소 토큰 전달\n    let server = tokio::spawn(\n        run_server(shutdown.child_token())\n    );\n    let worker = tokio::spawn(\n        run_background_worker(shutdown.child_token())\n    );\n\n    \u002F\u002F 모든 서비스가 우아하게 종료될 때까지 대기\n    let _ = tokio::join!(server, worker);\n    tracing::info!(\"Clean shutdown complete\");\n    Ok(())\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Ch2 id=\"\">결론\u003C\u002Fh2>\n\u003Cp>Rust에서의 컨텍스트 전파는 Go의 \u003Ccode>context.Context\u003C\u002Fcode>와 동일한 문제를 해결하지만, 다른 원시 자료형으로 구성됩니다: \u003Ccode>tokio::time::timeout\u003C\u002Fcode>은 데드라인, \u003Ccode>CancellationToken\u003C\u002Fcode>은 취소, \u003Ccode>tracing\u003C\u002Fcode> 스팬은 구조화된 로깅 컨텍스트, \u003Ccode>task_local!\u003C\u002Fcode>은 암시적 값 전파. \u003Ccode>select!\u003C\u002Fcode> 매크로는 이 모든 것을 연결하는 접착제입니다. Rust의 소유권 시스템과 드롭 의미론은 Go에서 흔한 고루틴 누수 문제를 구조적으로 방지합니다.\u003C\u002Fp>\n","ko","b0000000-0000-0000-0000-000000000001",true,"2026-03-28T10:44:28.293858Z","비동기 Rust에서의 컨텍스트 전파 — 데드라인, 취소, 트레이싱","Go 스타일 컨텍스트 전파를 비동기 Rust에서 데드라인, CancellationToken, tokio::select! 취소, 트레이싱 스팬 전파로 구현.","비동기 Rust 컨텍스트 전파",null,"index, follow",[22,27],{"id":23,"name":24,"slug":25,"created_at":26},"c0000000-0000-0000-0000-000000000022","Performance","performance","2026-03-28T10:44:21.513630Z",{"id":28,"name":29,"slug":30,"created_at":26},"c0000000-0000-0000-0000-000000000001","Rust","rust","엔지니어링",[33,39,45],{"id":34,"title":35,"slug":36,"excerpt":37,"locale":12,"category_name":31,"published_at":38},"d0000000-0000-0000-0000-000000000674","2026년, Bali가 동남아시아의 임팩트 테크 허브가 되고 있는 이유","bali-2026-dongnamasia-impaekteu-tekeu-heobeu-iyu","Bali는 동남아시아 스타트업 생태계에서 16위를 차지하고 있습니다. Web3 빌더, AI 지속가능성 스타트업, 에코 여행 테크 기업이 집중되면서, 이 섬은 지역 임팩트 테크의 수도로 자리매김하고 있습니다.","2026-03-28T10:44:49.294484Z",{"id":40,"title":41,"slug":42,"excerpt":43,"locale":12,"category_name":31,"published_at":44},"d0000000-0000-0000-0000-000000000673","ASEAN 데이터 보호 패치워크: 개발자를 위한 컴플라이언스 체크리스트","asean-deiteo-boho-paechiwokeu-gaebaljaleul-wihan-keompeullaieonseuchekeuriseuteu","7개 ASEAN 국가가 포괄적인 데이터 보호법을 시행하고 있으며, 각각 다른 동의 모델, 현지화 요건, 벌칙 구조를 가지고 있습니다. 다중 국가 애플리케이션을 구축하는 개발자를 위한 실용적인 컴플라이언스 체크리스트입니다.","2026-03-28T10:44:49.286400Z",{"id":46,"title":47,"slug":48,"excerpt":49,"locale":12,"category_name":31,"published_at":50},"d0000000-0000-0000-0000-000000000672","Indonesia 290억 달러 디지털 전환: 소프트웨어 기업을 위한 기회","indonesia-290eok-dallleo-dijiteol-jeonhwan-sopeuteuweo-gieopui-gihoe","Indonesia IT 서비스 시장은 2026년 290.3억 달러에 달할 것으로 예상되며, 이는 2025년 243.7억 달러에서 증가한 수치입니다. 클라우드 인프라, AI, 전자상거래, 데이터센터가 동남아시아에서 가장 빠른 성장을 주도하고 있습니다.","2026-03-28T10:44:49.265609Z",{"id":13,"name":52,"slug":53,"bio":54,"photo_url":19,"linkedin":19,"role":55,"created_at":56,"updated_at":56},"Open Soft Team","open-soft-team","The engineering team at Open Soft, building premium software solutions from Bali, Indonesia.","Engineering Team","2026-03-28T08:31:22.226811Z"]