#Step 12 — 운영

} catch (CanceledFailure e) {
    // ↓ 이 액티비티들은 시작하자마자 취소됩니다
    if (reservationId != null) inventory.release(reservationId);
    if (paymentId != null)     payment.refund(paymentId);
    throw e;
}

} catch (CanceledFailure e) {
    // 부모 스코프의 취소에 영향받지 않는 별도 스코프
    CancellationScope compensation = Workflow.newDetachedCancellationScope(() -> {
        if (reservationId[0] != null) inventory.release(reservationId[0]);
        if (paymentId[0] != null)     payment.refund(paymentId[0]);
        notification.notifyCustomer(req.orderId(), "주문이 취소되었습니다");
    });
    compensation.run();     // ★ 이 줄이 없으면 보상이 통째로 사라집니다
    throw e;                // 워크플로우는 CANCELED 로 마무리
}

SearchAttributes sa = SearchAttributes.newBuilder()
    .set(SearchAttributeKey.forKeyword("CustomerId"), req.customerId())
    .set(SearchAttributeKey.forLong("OrderAmount"), req.amount())
    .build();

OrderWorkflow wf = client.newWorkflowStub(OrderWorkflow.class,
    WorkflowOptions.newBuilder()
        .setTaskQueue(ORDER_TASK_QUEUE)
        .setWorkflowId("order-" + req.orderId())
        .setTypedSearchAttributes(sa)          // ← 1.20+ 의 타입 안전 API
        .build());

static final SearchAttributeKey<String> STAGE = SearchAttributeKey.forKeyword("OrderStage");

Workflow.upsertTypedSearchAttributes(STAGE.valueSet("PAYMENT"));
String paymentId = payment.charge(req.orderId(), req.amount());

Workflow.upsertTypedSearchAttributes(STAGE.valueSet("INVENTORY"));
String reservationId = inventory.reserve(req.orderId(), req.sku(), req.qty());

Workflow.upsertTypedSearchAttributes(STAGE.valueSet("SHIPPING"));
shipping.requestShipment(req.orderId(), req.address());

Scope scope = new RootScopeBuilder()
    .reporter(new MicrometerClientStatsReporter(
        new PrometheusMeterRegistry(PrometheusConfig.DEFAULT)))
    .reportEvery(Duration.ofSeconds(10));

WorkflowServiceStubs service = WorkflowServiceStubs.newServiceStubs(
    WorkflowServiceStubsOptions.newBuilder()
        .setTarget("127.0.0.1:7233")
        .setMetricsScope(scope)
        .build());

WorkerFactoryOptions factoryOptions = WorkerFactoryOptions.newBuilder()
    .setWorkflowCacheSize(1200)
    .setMaxWorkflowThreadCount(2400)      // cacheSize 의 2배 이상
    .build();
WorkerFactory factory = WorkerFactory.newInstance(client, factoryOptions);

WorkerOptions workerOptions = WorkerOptions.newBuilder()
    .setMaxConcurrentWorkflowTaskExecutionSize(400)
    .setMaxConcurrentActivityExecutionSize(100)     // 결제 API 부하를 고려해 낮춤
    .setMaxConcurrentWorkflowTaskPollers(10)
    .setMaxConcurrentActivityTaskPollers(10)
    .setMaxTaskQueueActivitiesPerSecond(50.0)       // 결제 게이트웨이 보호
    .build();

Worker worker = factory.newWorker(ORDER_TASK_QUEUE, workerOptions);

package com.example.order;

/*
 * Step 12 — 운영 : Practice
 *
 * 실행 방법
 *   ./gradlew run -PmainClass=com.example.order.Practice
 *
 * 이 파일은 두 종류의 내용을 담습니다.
 *   (1) CLI 명령 — static final String 상수. main() 이 "명령 + 기대 출력"을 인쇄합니다.
 *       터미널에 복사해 실행하고 실제 출력과 비교하세요.
 *       ★ 의도적으로 명령을 자동 실행하지 않습니다. prod 에 terminate 를 잘못 쏘는 사고를 막기 위함입니다.
 *   (2) Java 코드 — detached scope 보상, Search Attribute, WorkerOptions. 그대로 컴파일됩니다.
 *
 * 사전 준비
 *   docker compose up -d
 *   export TEMPORAL_ADDRESS=127.0.0.1:7233
 *   export TEMPORAL_NAMESPACE=orders
 */

import io.temporal.activity.ActivityOptions;
import io.temporal.client.WorkflowClient;
import io.temporal.client.WorkflowOptions;
import io.temporal.common.SearchAttributeKey;
import io.temporal.common.SearchAttributes;
import io.temporal.failure.CanceledFailure;
import io.temporal.worker.Worker;
import io.temporal.worker.WorkerFactory;
import io.temporal.worker.WorkerFactoryOptions;
import io.temporal.worker.WorkerOptions;
import io.temporal.workflow.CancellationScope;
import io.temporal.workflow.Workflow;

import java.time.Duration;

public class Practice {

    static final String TASK_QUEUE = "ORDER_TASK_QUEUE";
    static final String NAMESPACE = "orders";

    public static void main(String[] args) {
        CLI.printAll();
        Playbook.printAll();
    }

    // =====================================================================
    // [12-1][12-2][12-3][12-4][12-5] CLI 명령 모음
    // =====================================================================
    static class CLI {

        // [12-1] Namespace
        static final String NS_CREATE =
                "temporal operator namespace create --namespace orders --retention 72h";
        static final String NS_CREATE_OUT = """
                Namespace orders successfully registered.""";

        static final String NS_DESCRIBE =
                "temporal operator namespace describe --namespace orders";
        static final String NS_DESCRIBE_OUT = """
                NamespaceInfo.Name                                orders
                NamespaceInfo.State                               Registered
                Config.WorkflowExecutionRetentionTtl              72h0m0s
                Config.HistoryArchivalState                       Disabled
                Config.VisibilityArchivalState                    Disabled""";

        // [12-2] Retention
        static final String NS_RETENTION_30D =
                "temporal operator namespace update --namespace orders --retention 720h";
        static final String NS_RETENTION_30D_OUT = """
                Namespace orders successfully updated.""";

        static final String SHOW_EXPIRED =
                "temporal workflow show -w order-0042 --namespace orders";
        static final String SHOW_EXPIRED_OUT = """
                Error: unable to get workflow execution history:
                  workflow execution not found for workflow id: order-0042
                Error Details: NotFound""";

        static final String ARCHIVAL_ENABLE = """
                temporal operator namespace update --namespace orders \\
                  --history-archival-state enabled \\
                  --history-uri "s3://temporal-archival-prod/orders\"""";
        static final String ARCHIVAL_ENABLE_OUT = """
                Namespace orders successfully updated.""";

        // [12-3] 조회
        static final String LIST_RUNNING =
                "temporal workflow list --query \"WorkflowType='OrderWorkflow' "
                        + "AND ExecutionStatus='Running'\"";
        static final String LIST_RUNNING_OUT = """
                  Status   WorkflowId    Name           StartTime             CloseTime
                  Running  order-1001    OrderWorkflow  2026-07-20T09:12:04Z
                  Running  order-1004    OrderWorkflow  2026-07-20T09:18:33Z
                  Running  order-1007    OrderWorkflow  2026-07-20T09:21:57Z""";

        static final String COUNT_RUNNING =
                "temporal workflow count --query \"WorkflowType='OrderWorkflow' "
                        + "AND ExecutionStatus='Running'\"";
        static final String COUNT_RUNNING_OUT = "Total: 1247";

        static final String DESCRIBE_STUCK = "temporal workflow describe -w order-1004";
        static final String DESCRIBE_STUCK_OUT = """
                Execution Info:
                  Workflow Id       order-1004
                  Type              OrderWorkflow
                  Task Queue        ORDER_TASK_QUEUE
                  Status            RUNNING
                  History Length    11

                Pending Activities:
                  ActivityId              2
                  ActivityType            ShippingActivity_requestShipment
                  State                   Started
                  Attempt                 7
                  MaximumAttempts         10
                  LastFailure             {"message":"connect timed out", ...}""";

        static final String SHOW_JSON =
                "temporal workflow show -w order-1001 --output json > order-1001.json";
        static final String SHOW_JSON_OUT = """
                (18432 bytes written — Step 11 의 리플레이 테스트 입력 파일이 됩니다)""";

        static final String RESET_LAST =
                "temporal workflow reset -w order-1004 --type LastWorkflowTask "
                        + "--reason \"코드 수정 후 재개\"";
        static final String RESET_LAST_OUT = """
                Reset workflow succeeded.
                  WorkflowId  order-1004
                  RunId       0b4a9c71-5d38-4e02-8f61-9a2d7c1e3b55   ← 새 RunId""";

        static final String RESET_BATCH = """
                temporal workflow reset-batch \\
                  --query "WorkflowType='OrderWorkflow' AND ExecutionStatus='Running'" \\
                  --type LastWorkflowTask --reason "INC-2291 롤백 후 재개\"""";
        static final String RESET_BATCH_OUT = """
                Batch job started.
                  JobId  9f1c4e70-3a82-4b56-8d09-27e5f3a1c604""";

        static final String TQ_DESCRIBE =
                "temporal task-queue describe --task-queue ORDER_TASK_QUEUE";
        static final String TQ_DESCRIBE_OUT = """
                Workflow Poller Info:
                  Identity                   LastAccessTime          RatePerSecond
                  41@worker-7f9c8d-xk2mq@    2026-07-20T09:34:02Z    100000
                  41@worker-7f9c8d-p8vn4@    2026-07-20T09:34:02Z    100000

                Activity Poller Info:
                  Identity                   LastAccessTime          RatePerSecond
                  41@worker-7f9c8d-xk2mq@    2026-07-20T09:34:02Z    100000
                  41@worker-7f9c8d-p8vn4@    2026-07-20T09:34:02Z    100000""";

        // [12-4] cancel vs terminate
        static final String CANCEL =
                "temporal workflow cancel -w order-1004 --reason \"고객 요청 취소\"";
        static final String CANCEL_OUT = """
                Cancel workflow succeeded.
                  WorkflowId  order-1004
                (히스토리: WorkflowExecutionCancelRequested → 보상 액티비티들 → WorkflowExecutionCanceled)""";

        static final String TERMINATE =
                "temporal workflow terminate -w order-1007 --reason \"결정성 깨져 진행 불가 (INC-2291)\"";
        static final String TERMINATE_OUT = """
                Terminate workflow succeeded.
                  WorkflowId  order-1007
                (히스토리: WorkflowExecutionTerminated 하나뿐 — 보상 없음!)""";

        // [12-5] Search Attributes
        static final String SA_CREATE = """
                temporal operator search-attribute create --name CustomerId  --type Keyword --namespace orders
                temporal operator search-attribute create --name OrderAmount --type Int     --namespace orders
                temporal operator search-attribute create --name OrderStage  --type Keyword --namespace orders""";
        static final String SA_CREATE_OUT = """
                Search attribute CustomerId successfully registered.
                Search attribute OrderAmount successfully registered.
                Search attribute OrderStage successfully registered.""";

        static final String SA_QUERY =
                "temporal workflow list --query \"CustomerId='C-77'\" --namespace orders";
        static final String SA_QUERY_OUT = """
                  Status     WorkflowId    Name           StartTime             CloseTime
                  Completed  order-1001    OrderWorkflow  2026-07-20T09:12:04Z  2026-07-20T09:12:09Z
                  Running    order-1004    OrderWorkflow  2026-07-20T09:18:33Z""";

        static final String SA_STAGE_COUNT =
                "temporal workflow count --query \"OrderStage='SHIPPING' "
                        + "AND ExecutionStatus='Running'\" --namespace orders";
        static final String SA_STAGE_COUNT_OUT = "Total: 38";

        static void printAll() {
            section("12-1 Namespace");
            pair(NS_CREATE, NS_CREATE_OUT);
            pair(NS_DESCRIBE, NS_DESCRIBE_OUT);

            section("12-2 Retention / Archival");
            pair(NS_RETENTION_30D, NS_RETENTION_30D_OUT);
            pair(SHOW_EXPIRED, SHOW_EXPIRED_OUT);
            pair(ARCHIVAL_ENABLE, ARCHIVAL_ENABLE_OUT);

            section("12-3 CLI 레퍼런스");
            pair(LIST_RUNNING, LIST_RUNNING_OUT);
            pair(COUNT_RUNNING, COUNT_RUNNING_OUT);
            pair(DESCRIBE_STUCK, DESCRIBE_STUCK_OUT);
            pair(SHOW_JSON, SHOW_JSON_OUT);
            pair(RESET_LAST, RESET_LAST_OUT);
            pair(RESET_BATCH, RESET_BATCH_OUT);
            pair(TQ_DESCRIBE, TQ_DESCRIBE_OUT);

            section("12-4 cancel vs terminate");
            pair(CANCEL, CANCEL_OUT);
            pair(TERMINATE, TERMINATE_OUT);

            section("12-5 Search Attributes");
            pair(SA_CREATE, SA_CREATE_OUT);
            pair(SA_QUERY, SA_QUERY_OUT);
            pair(SA_STAGE_COUNT, SA_STAGE_COUNT_OUT);
        }

        static void section(String title) {
            System.out.println("\n══════════ " + title + " ══════════");
        }

        static void pair(String cmd, String out) {
            System.out.println("\n$ " + cmd);
            System.out.println(out);
        }
    }

    // =====================================================================
    // [12-4] cancel 을 받았을 때의 보상 — 잘못된 버전과 올바른 버전
    // =====================================================================
    static class CancelCompensation {

        static final ActivityOptions ACT_OPTS = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10))
                .build();

        /*
         * 잘못된 버전.
         * 워크플로우 코드 전체가 하나의 CancellationScope 안에서 돕니다.
         * cancel 이 오면 그 스코프가 "취소됨" 상태가 되고,
         * catch 블록도 같은 스코프이므로 여기서 띄우는 액티비티는 태어나자마자 취소됩니다.
         *
         * 히스토리:
         *   11 WorkflowExecutionCancelRequested
         *   13 ActivityTaskScheduled   InventoryActivity_release
         *   14 ActivityTaskCancelRequested   ← 즉시 취소
         *   15 ActivityTaskCanceled
         *   16 WorkflowExecutionCanceled
         *   Status: CANCELED      ← ★ 정상처럼 보입니다. 이게 함정입니다.
         */
        public static class WrongOrderWorkflowImpl implements OrderWorkflow {

            private final PaymentActivity payment =
                    Workflow.newActivityStub(PaymentActivity.class, ACT_OPTS);
            private final InventoryActivity inventory =
                    Workflow.newActivityStub(InventoryActivity.class, ACT_OPTS);
            private final ShippingActivity shipping =
                    Workflow.newActivityStub(ShippingActivity.class, ACT_OPTS);

            private String status = "STARTED";

            @Override
            public String processOrder(OrderRequest req) {
                String paymentId = null;
                String reservationId = null;
                try {
                    status = "PAYMENT";
                    paymentId = payment.charge(req.orderId(), req.amount());
                    status = "INVENTORY";
                    reservationId = inventory.reserve(req.orderId(), req.sku(), req.qty());
                    status = "WAITING_SHIPMENT";
                    shipping.requestShipment(req.orderId(), req.address());
                    status = "DONE";
                    return req.orderId() + " COMPLETED";
                } catch (CanceledFailure e) {
                    status = "CANCELED";
                    // ↓ 즉시 취소됩니다
                    if (reservationId != null) inventory.release(reservationId);
                    if (paymentId != null) payment.refund(paymentId);
                    throw e;
                }
            }

            @Override
            public void cancelRequested(String reason) {
                status = "CANCELED";
            }

            @Override
            public String getStatus() {
                return status;
            }
        }

        /*
         * 올바른 버전.
         * Workflow.newDetachedCancellationScope 는 부모 스코프의 취소로부터
         * 분리된 새 스코프를 만듭니다. 그 안에서 띄운 액티비티는 끝까지 실행됩니다.
         *
         * 히스토리:
         *   11 WorkflowExecutionCancelRequested
         *   13 ActivityTaskScheduled   InventoryActivity_release
         *   14 ActivityTaskCompleted                                ← 완료!
         *   15 ActivityTaskScheduled   PaymentActivity_refund
         *   16 ActivityTaskCompleted                                ← 완료!
         *   19 WorkflowExecutionCanceled
         *   Status: CANCELED
         *
         * ★ 두 버전 모두 Status 가 CANCELED 입니다. 히스토리를 봐야 구분됩니다.
         */
        public static class CorrectOrderWorkflowImpl implements OrderWorkflow {

            private final PaymentActivity payment =
                    Workflow.newActivityStub(PaymentActivity.class, ACT_OPTS);
            private final InventoryActivity inventory =
                    Workflow.newActivityStub(InventoryActivity.class, ACT_OPTS);
            private final ShippingActivity shipping =
                    Workflow.newActivityStub(ShippingActivity.class, ACT_OPTS);
            private final NotificationActivity notification =
                    Workflow.newActivityStub(NotificationActivity.class, ACT_OPTS);

            private String status = "STARTED";

            @Override
            public String processOrder(OrderRequest req) {
                // 람다에서 참조하려면 effectively final 이어야 하므로 배열로 감쌉니다.
                final String[] paymentId = {null};
                final String[] reservationId = {null};
                try {
                    status = "PAYMENT";
                    paymentId[0] = payment.charge(req.orderId(), req.amount());
                    status = "INVENTORY";
                    reservationId[0] = inventory.reserve(req.orderId(), req.sku(), req.qty());
                    status = "WAITING_SHIPMENT";
                    shipping.requestShipment(req.orderId(), req.address());
                    status = "DONE";
                    return req.orderId() + " COMPLETED";

                } catch (CanceledFailure e) {
                    status = "CANCELED";
                    CancellationScope compensation =
                            Workflow.newDetachedCancellationScope(() -> {
                                if (reservationId[0] != null) inventory.release(reservationId[0]);
                                if (paymentId[0] != null) payment.refund(paymentId[0]);
                                notification.notifyCustomer(req.orderId(), "주문이 취소되었습니다");
                            });
                    compensation.run();
                    throw e;
                }
            }

            @Override
            public void cancelRequested(String reason) {
                status = "CANCELED";
            }

            @Override
            public String getStatus() {
                return status;
            }
        }
    }

    // =====================================================================
    // [12-5] Search Attributes
    // =====================================================================
    static class SearchAttrs {

        // 키를 상수로 뽑습니다. 문자열 오타를 컴파일 타임에 막기 위해서입니다.
        static final SearchAttributeKey<String> CUSTOMER_ID =
                SearchAttributeKey.forKeyword("CustomerId");
        static final SearchAttributeKey<Long> ORDER_AMOUNT =
                SearchAttributeKey.forLong("OrderAmount");
        static final SearchAttributeKey<String> ORDER_STAGE =
                SearchAttributeKey.forKeyword("OrderStage");

        // 시작 시점에 설정
        static WorkflowOptions optionsWithSearchAttributes(OrderRequest req) {
            SearchAttributes sa = SearchAttributes.newBuilder()
                    .set(CUSTOMER_ID, req.customerId())
                    .set(ORDER_AMOUNT, req.amount())
                    .build();

            return WorkflowOptions.newBuilder()
                    .setTaskQueue(TASK_QUEUE)
                    .setWorkflowId("order-" + req.orderId())
                    // 1.20 이전의 setSearchAttributes(Map) 은 deprecated 입니다.
                    .setTypedSearchAttributes(sa)
                    .build();
        }

        // 실행 중 갱신 — 히스토리에 UpsertWorkflowSearchAttributes 이벤트가 남습니다(결정적).
        static void markStage(String stage) {
            Workflow.upsertTypedSearchAttributes(ORDER_STAGE.valueSet(stage));
        }
    }

    // =====================================================================
    // [12-7] Worker 튜닝
    // =====================================================================
    static class WorkerTuning {

        /*
         * 안전한 구성.
         * 규칙: maxWorkflowThreadCount >= workflowCacheSize x (워크플로우당 평균 스레드 + 1)
         *   - 단순 워크플로우(자식 없음, Async 없음): 배수 2
         *   - 자식 워크플로우 / Async.function 여러 개: 배수 3~4
         */
        static WorkerFactory buildFactory(WorkflowClient client) {
            WorkerFactoryOptions factoryOptions = WorkerFactoryOptions.newBuilder()
                    .setWorkflowCacheSize(1200)
                    .setMaxWorkflowThreadCount(2400)      // cacheSize x 2
                    .build();
            return WorkerFactory.newInstance(client, factoryOptions);
        }

        static Worker buildWorker(WorkerFactory factory) {
            WorkerOptions options = WorkerOptions.newBuilder()
                    .setMaxConcurrentWorkflowTaskExecutionSize(400)   // 기본 200
                    .setMaxConcurrentActivityExecutionSize(100)       // 결제 API 부하 고려해 낮춤
                    .setMaxConcurrentWorkflowTaskPollers(10)          // 기본 5
                    .setMaxConcurrentActivityTaskPollers(10)          // 기본 5
                    .setMaxTaskQueueActivitiesPerSecond(50.0)         // 게이트웨이 보호 (전역)
                    .build();
            return factory.newWorker(TASK_QUEUE, options);
        }

        /*
         * 위험한 구성 — 재현용.
         * cacheSize 와 threadCount 가 같습니다. 캐시가 가득 차면 스레드가 정확히 소진됩니다.
         *
         * 재현 방법: 이 팩토리로 Worker 를 띄우고, 자식 워크플로우를 동시에 600개 이상 시작하세요.
         *
         * 결과 (Worker 로그):
         *   ERROR i.t.i.w.WorkflowExecutionHandler -
         *     io.temporal.internal.sync.PotentialDeadlockException:
         *     Potential deadlock detected: workflow thread "workflow-method-order-2288-1"
         *     didn't yield control for over a second.
         *     Current thread pool: 600/600 in use, 0 available.
         */
        static WorkerFactory buildDangerousFactory(WorkflowClient client) {
            WorkerFactoryOptions bad = WorkerFactoryOptions.newBuilder()
                    .setWorkflowCacheSize(600)
                    .setMaxWorkflowThreadCount(600)       // ★ 같은 값 — 데드락 위험
                    .build();
            return WorkerFactory.newInstance(client, bad);
        }
    }

    // =====================================================================
    // [12-8] 운영 플레이북
    // =====================================================================
    static class Playbook {

        /*
         * 1단계 분기 조건
         *   Pending Activities 있음 + Attempt 증가  → 외부 시스템 장애 (4단계로)
         *   Pending Activities 있음 + State Scheduled + Attempt 1 → Worker 가 안 가져감 (2단계로)
         *   Pending Workflow Task 만 있고 Attempt 가 큼 → 결정성 문제 (3단계로)
         */
        static final String[] STEP_1 = {
                "temporal workflow describe -w order-1004 --namespace orders"
        };

        /*
         * 2단계 — Poller 가 비어 있으면 원인은 셋 중 하나
         *   (a) Worker 프로세스 죽음
         *   (b) Worker 가 다른 Task Queue 이름으로 붙음 (오타 — 매우 흔함)
         *   (c) Worker 가 다른 Namespace 에 붙음
         */
        static final String[] STEP_2 = {
                "temporal task-queue describe --task-queue ORDER_TASK_QUEUE --namespace orders"
        };

        static final String[] STEP_3 = {
                "kubectl logs deploy/order-worker --since=10m | grep -E \"NonDeterministic|Deadlock|ERROR\""
        };

        static final String[] STEP_4 = {
                "temporal workflow count --query \"ExecutionStatus='Running'\" --namespace orders",
                "curl -s localhost:8080/actuator/prometheus | grep workflow_task_execution_failed"
        };

        /*
         * 5단계 조치
         *   NonDeterministic + 다수  → 즉시 롤백. 그다음 getVersion 넣고 재배포
         *   NonDeterministic + 소수  → 롤백 후 reset --type LastWorkflowTask
         *   외부 시스템 장애         → ★ 아무것도 하지 마세요. 재시도가 알아서 성공합니다
         *   장시간 복구 불가         → cancel (보상 실행) → 나중에 재주문
         *   cancel 도 안 먹음        → describe 로 기록한 뒤 terminate, 보상은 수동
         *   Worker 없음              → Worker 배포 수정. 붙는 즉시 재개됨
         */
        static final String[] STEP_5 = {
                "kubectl rollout undo deploy/order-worker",
                "temporal workflow reset-batch "
                        + "--query \"WorkflowType='OrderWorkflow' AND ExecutionStatus='Running'\" "
                        + "--type LastWorkflowTask --reason \"INC-2291 롤백 후 재개\" --namespace orders",
                "temporal batch describe --job-id 9f1c4e70-3a82-4b56-8d09-27e5f3a1c604"
        };

        static void printAll() {
            CLI.section("12-8 운영 플레이북");
            printStep("1단계 — describe 로 무엇을 기다리는지 본다", STEP_1);
            printStep("2단계 — task-queue describe 로 Worker 확인", STEP_2);
            printStep("3단계 — Worker 로그", STEP_3);
            printStep("4단계 — 메트릭으로 범위 파악", STEP_4);
            printStep("5단계 — 조치", STEP_5);
        }

        static void printStep(String title, String[] commands) {
            System.out.println("\n[" + title + "]");
            for (String c : commands) {
                System.out.println("  $ " + c);
            }
        }
    }
}

package com.example.order;

/*
 * Step 12 — 운영 : Exercise (문제지)
 *
 * 실행 방법
 *   ./gradlew run -PmainClass=com.example.order.Exercise
 *
 * 7문제입니다. // TODO 자리를 채우고 main() 을 실행하면 자동 채점 결과가 인쇄됩니다.
 * CLI 문제는 정답 문자열을 정확히 외울 필요가 없습니다 — 핵심 옵션 토큰만 맞으면 통과합니다.
 */

import io.temporal.activity.ActivityOptions;
import io.temporal.client.WorkflowClient;
import io.temporal.client.WorkflowOptions;
import io.temporal.common.SearchAttributeKey;
import io.temporal.failure.CanceledFailure;
import io.temporal.worker.WorkerFactory;
import io.temporal.worker.WorkerFactoryOptions;
import io.temporal.workflow.Workflow;

import java.time.Duration;

public class Exercise {

    static final String TASK_QUEUE = "ORDER_TASK_QUEUE";

    // =====================================================================
    // 문제 1 — Namespace 생성 + Retention 30일
    //
    // orders 라는 Namespace 를 만들고, Retention 을 30일로 바꾸는 명령 두 개를
    // 개행으로 이어 붙여 반환하세요.
    // 힌트: Retention 은 시간 단위로 지정합니다. 30일 = ?h
    // =====================================================================
    static String 문제1_namespace_명령() {
        // TODO: 여기에 작성
        return "";
    }

    // =====================================================================
    // 문제 2 — Search Attribute 쿼리
    //
    // "고객 C-77 의, 금액 10만원 초과, 실패한 주문"을 찾는 --query 문자열만
    // (temporal workflow list 부분 제외하고) 반환하세요.
    //
    // 사용 가능한 Search Attribute:
    //   CustomerId (Keyword) / OrderAmount (Int) / ExecutionStatus (Keyword)
    // =====================================================================
    static String 문제2_쿼리() {
        // TODO: 여기에 작성
        return "";
    }

    // =====================================================================
    // 문제 3 — cancel 을 받아 보상 실행하기  ★ 이 스텝의 핵심
    //
    // catch (CanceledFailure e) 블록을 채워 보상 액티비티 3개를
    // release → refund → notifyCustomer 순으로 실행하세요.
    //
    // ⚠️ 그냥 부르면 즉시 취소됩니다. 검증 메서드가 이를 확인합니다.
    //    힌트: 워크플로우 전체가 하나의 CancellationScope 안에서 돕니다.
    //          catch 블록도 같은 스코프입니다. 어떻게 분리해야 할까요?
    // =====================================================================
    public static class Q3OrderWorkflowImpl implements OrderWorkflow {

        static final ActivityOptions ACT = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10))
                .build();

        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, ACT);
        private final InventoryActivity inventory =
                Workflow.newActivityStub(InventoryActivity.class, ACT);
        private final ShippingActivity shipping =
                Workflow.newActivityStub(ShippingActivity.class, ACT);
        private final NotificationActivity notification =
                Workflow.newActivityStub(NotificationActivity.class, ACT);

        private String status = "STARTED";

        @Override
        public String processOrder(OrderRequest req) {
            final String[] paymentId = {null};
            final String[] reservationId = {null};
            try {
                status = "PAYMENT";
                paymentId[0] = payment.charge(req.orderId(), req.amount());
                status = "INVENTORY";
                reservationId[0] = inventory.reserve(req.orderId(), req.sku(), req.qty());
                status = "WAITING_SHIPMENT";
                shipping.requestShipment(req.orderId(), req.address());
                status = "DONE";
                return req.orderId() + " COMPLETED";

            } catch (CanceledFailure e) {
                status = "CANCELED";

                // TODO: 여기에 작성 — 보상 3개를 끝까지 실행되게 만드세요
                //   if (reservationId[0] != null) inventory.release(reservationId[0]);
                //   if (paymentId[0] != null)     payment.refund(paymentId[0]);
                //   notification.notifyCustomer(req.orderId(), "주문이 취소되었습니다");

                throw e;
            }
        }

        @Override
        public void cancelRequested(String reason) {
            status = "CANCELED";
        }

        @Override
        public String getStatus() {
            return status;
        }
    }

    // =====================================================================
    // 문제 4 — Search Attribute 등록과 upsert
    //
    // (a) OrderStage 를 Keyword 타입으로 등록하는 CLI 명령을 반환하세요.
    // (b) STAGE 키 상수를 선언하세요.
    // (c) markStage() 를 구현하세요.
    //
    // 힌트: upsertTypedSearchAttributes 는 워크플로우 코드 안에서 부르므로
    //       결정적이어야 합니다. 조건문 안에서 부를 때는 그 조건이 리플레이 시에도
    //       같은 결과를 내는지 확인하세요 (Math.random() 같은 것 금지).
    // =====================================================================
    static String 문제4a_SA_등록_명령() {
        // TODO: 여기에 작성
        return "";
    }

    // TODO: 여기에 작성 — (b) SearchAttributeKey<String> STAGE 상수 선언
    // static final SearchAttributeKey<String> STAGE = ...;

    static void 문제4c_markStage(String stage) {
        // TODO: 여기에 작성 — (c) Workflow.upsertTypedSearchAttributes(...)
    }

    // =====================================================================
    // 문제 5 — Worker 튜닝 (데드락 방지)
    //
    // workflowCacheSize 는 2000 으로 이미 지정되어 있습니다.
    // maxWorkflowThreadCount 를 안전한 값으로 채우세요.
    //
    // 힌트: 캐시된 워크플로우 하나가 스레드를 최소 1개 점유합니다.
    //       모자라면 PotentialDeadlockException 이 납니다.
    // =====================================================================
    static WorkerFactory 문제5_factory(WorkflowClient client) {
        WorkerFactoryOptions options = WorkerFactoryOptions.newBuilder()
                .setWorkflowCacheSize(2000)
                // TODO: 여기에 작성 — setMaxWorkflowThreadCount(?)
                .build();
        return WorkerFactory.newInstance(client, options);
    }

    static int 문제5_선택한_threadCount() {
        // TODO: 여기에 작성 — 위에서 지정한 값을 그대로 반환 (채점용)
        return 0;
    }

    /*
     * =====================================================================
     * 문제 6 — 메트릭 판독
     *
     * 세 개의 스냅샷을 읽고 각각의 원인을 한 줄로 답하세요.
     * 답은 아래 세 가지 중 하나입니다: "결정성" / "Worker부족" / "캐시부족"
     *
     * ── 스냅샷 A ──────────────────────────────────────────
     * temporal_workflow_task_execution_failed_total{...}          8912.0
     * temporal_workflow_task_schedule_to_start_latency{q=0.95}    0.021
     * temporal_worker_task_slots_available{...}                   380.0
     * temporal_sticky_cache_miss_total{...}                       12.0
     *
     * ── 스냅샷 B ──────────────────────────────────────────
     * temporal_workflow_task_execution_failed_total{...}          0.0
     * temporal_workflow_task_schedule_to_start_latency{q=0.95}    6.412
     * temporal_activity_schedule_to_start_latency{q=0.95}         9.884
     * temporal_worker_task_slots_available{...}                   0.0
     * temporal_sticky_cache_miss_total{...}                       31.0
     *
     * ── 스냅샷 C ──────────────────────────────────────────
     * temporal_workflow_task_execution_failed_total{...}          0.0
     * temporal_workflow_task_schedule_to_start_latency{q=0.95}    0.412
     * temporal_workflow_task_execution_latency{q=0.95}            2.841
     * temporal_worker_task_slots_available{...}                   150.0
     * temporal_sticky_cache_miss_total{...}                       8421.0
     * =====================================================================
     */
    static String 문제6_A() {
        // TODO: 여기에 작성
        return "";
    }

    static String 문제6_B() {
        // TODO: 여기에 작성
        return "";
    }

    static String 문제6_C() {
        // TODO: 여기에 작성
        return "";
    }

    // =====================================================================
    // 문제 7 — 진단 명령 순서
    //
    // "order-1004 가 Running 인데 안 움직인다" 는 신고를 받았습니다.
    // 진단 1~4단계에 해당하는 명령을 순서대로 배열에 담아 반환하세요.
    //   1단계: 워크플로우가 무엇을 기다리는지
    //   2단계: Worker 가 붙어 있는지
    //   3단계: Worker 로그에서 예외 찾기
    //   4단계: 영향 범위 (Running 개수)
    // =====================================================================
    static String[] 문제7_진단_순서() {
        // TODO: 여기에 작성
        return new String[]{"", "", "", ""};
    }

    // =====================================================================
    // 자동 채점
    // =====================================================================
    public static void main(String[] args) {
        int pass = 0, total = 7;

        pass += check(1, 문제1_namespace_명령(),
                "namespace create", "--retention 720h");
        pass += check(2, 문제2_쿼리(),
                "CustomerId='C-77'", "OrderAmount > 100000", "ExecutionStatus='Failed'");
        pass += checkQ3();
        pass += check(4, 문제4a_SA_등록_명령(),
                "search-attribute create", "--name OrderStage", "--type Keyword");
        pass += checkQ5();
        pass += checkQ6();
        pass += checkQ7();

        System.out.printf("%n결과: %d / %d 통과%n", pass, total);
        if (pass < total) {
            System.out.println("Solution.java 로 정답과 해설을 확인하세요.");
        }
    }

    static int check(int no, String actual, String... requiredTokens) {
        for (String t : requiredTokens) {
            if (actual == null || !actual.contains(t)) {
                System.out.printf("문제 %d — FAIL (누락: %s)%n", no, t);
                return 0;
            }
        }
        System.out.printf("문제 %d — PASS%n", no);
        return 1;
    }

    static int checkQ3() {
        // Q3OrderWorkflowImpl 의 소스에 detached scope 를 썼는지는 런타임으로 알 수 없으므로,
        // 실제 검증은 Step 11 방식의 테스트로 합니다.
        // 여기서는 안내만 출력합니다.
        System.out.println("문제 3 — 수동 검증: 아래 두 가지를 모두 만족해야 정답입니다.");
        System.out.println("  (a) Workflow.newDetachedCancellationScope 를 사용했는가");
        System.out.println("  (b) 스코프를 만든 뒤 .run() 을 호출했는가 (만들기만 하면 실행되지 않습니다)");
        System.out.println("  확인법: 워크플로우를 시작해 cancel 한 뒤");
        System.out.println("          temporal workflow show -w order-XXXX 의 히스토리에");
        System.out.println("          ActivityTaskCompleted 가 3개 있으면 정답,");
        System.out.println("          ActivityTaskCanceled 가 있으면 오답입니다.");
        return 0;
    }

    static int checkQ5() {
        int t = 문제5_선택한_threadCount();
        if (t >= 4000) {
            System.out.println("문제 5 — PASS (threadCount=" + t + ")");
            return 1;
        }
        System.out.println("문제 5 — FAIL (threadCount=" + t
                + " — cacheSize 2000 의 최소 2배가 필요합니다)");
        return 0;
    }

    static int checkQ6() {
        boolean ok = "결정성".equals(문제6_A())
                && "Worker부족".equals(문제6_B())
                && "캐시부족".equals(문제6_C());
        System.out.println("문제 6 — " + (ok ? "PASS" : "FAIL"));
        return ok ? 1 : 0;
    }

    static int checkQ7() {
        String[] s = 문제7_진단_순서();
        boolean ok = s.length == 4
                && s[0].contains("workflow describe")
                && s[1].contains("task-queue describe")
                && s[2].contains("logs")
                && s[3].contains("workflow count");
        System.out.println("문제 7 — " + (ok ? "PASS" : "FAIL"));
        return ok ? 1 : 0;
    }
}

package com.example.order;

/*
 * Step 12 — 운영 : Solution (정답 + 해설)
 *
 * 실행 방법
 *   ./gradlew run -PmainClass=com.example.order.Solution
 *
 * Exercise.java 를 직접 풀어 본 뒤에 여세요.
 */

import io.temporal.activity.ActivityOptions;
import io.temporal.client.WorkflowClient;
import io.temporal.common.SearchAttributeKey;
import io.temporal.failure.CanceledFailure;
import io.temporal.worker.WorkerFactory;
import io.temporal.worker.WorkerFactoryOptions;
import io.temporal.workflow.CancellationScope;
import io.temporal.workflow.Workflow;

import java.time.Duration;

public class Solution {

    static final String TASK_QUEUE = "ORDER_TASK_QUEUE";

    /*
     * ─────────────────────────────────────────────────────────────────
     * 정답 1 — Namespace 생성 + Retention 30일
     * ─────────────────────────────────────────────────────────────────
     * 30일 = 720시간. Retention 은 시간 단위(h)로 지정합니다.
     *
     * 꼭 알아야 할 세 가지:
     *
     * (1) Retention 은 **종료된(Closed)** 워크플로우에만 적용됩니다.
     *     3년 도는 워크플로우는 Retention 이 72시간이어도 안전합니다.
     *     "장기 실행 워크플로우가 3일 뒤에 사라지나요?" — 아니요.
     *
     * (2) Retention 을 **줄이면** 이미 저장된 히스토리도 다음 정리 주기에 삭제됩니다.
     *     720h → 72h 로 되돌리는 순간 3일 넘은 히스토리가 전부 날아갑니다. 되돌릴 수 없습니다.
     *
     * (3) Retention 이 지나면 workflow show 도 describe 도 NotFound 입니다.
     *     사후 분석이 불가능해집니다. prod 는 최소 30일을 권장하고,
     *     규제 대응 등으로 더 오래 필요하면 Archival 을 켭니다(최대 Retention 은 90일 권장).
     */
    static String 정답1_namespace_명령() {
        return """
                temporal operator namespace create --namespace orders --retention 72h
                temporal operator namespace update --namespace orders --retention 720h""";
    }

    /*
     * ─────────────────────────────────────────────────────────────────
     * 정답 2 — Search Attribute 쿼리
     * ─────────────────────────────────────────────────────────────────
     * 쿼리 언어는 SQL 유사 문법(List Filter)입니다.
     *
     * 타입별 사용 가능한 연산자:
     *   Keyword  : = != IN     ← ★ 부분 일치(LIKE)를 못 합니다. 정확히 일치해야 합니다
     *   Text     : 토큰 단위 매칭 (전문 검색용). 정렬 불가
     *   Int/Double : = != > < >= <= BETWEEN
     *   Datetime : > < BETWEEN
     *   Bool     : = !=
     *
     * CustomerId 를 Keyword 로 만든 이유: 정확 일치 조회만 필요하고, 인덱스가 가볍습니다.
     * "C-7 로 시작하는 고객" 같은 조회가 필요하면 STARTS_WITH 를 쓰거나 Text 를 고려하세요.
     *
     * ⚠️ 주의 — 인덱싱은 비동기입니다.
     *    방금 시작한 워크플로우는 수백 ms ~ 수 초 동안 이 쿼리에 안 잡힐 수 있습니다.
     *    "워크플로우를 시작하고 곧바로 list 로 확인"하는 코드는 flaky 해집니다.
     *    확실한 확인이 필요하면 workflowId 로 describe 하세요 (이건 즉시 반영됩니다).
     */
    static String 정답2_쿼리() {
        return "CustomerId='C-77' AND OrderAmount > 100000 AND ExecutionStatus='Failed'";
    }

    /*
     * ─────────────────────────────────────────────────────────────────
     * 정답 3 — detached scope 로 보상 실행  ★ 이 스텝의 핵심
     * ─────────────────────────────────────────────────────────────────
     * 왜 그냥 부르면 안 되는가:
     *
     *   워크플로우 메서드 전체는 하나의 CancellationScope(루트 스코프) 안에서 실행됩니다.
     *   temporal workflow cancel 이 오면 서버가 WorkflowExecutionCancelRequested 이벤트를
     *   기록하고, SDK 는 루트 스코프를 "취소됨" 상태로 표시합니다.
     *   그 결과 현재 대기 중이던 지점에서 CanceledFailure 가 던져집니다.
     *
     *   여기서 중요한 점: catch 블록도 여전히 **같은 루트 스코프 안**입니다.
     *   취소된 스코프에서 새로 스케줄한 액티비티는 태어나자마자 취소 요청을 받습니다.
     *
     * 두 버전의 히스토리 대조:
     *
     *   [틀린 버전]                            [올바른 버전]
     *   11 WorkflowExecutionCancelRequested    11 WorkflowExecutionCancelRequested
     *   13 ActivityTaskScheduled  release      13 ActivityTaskScheduled  release
     *   14 ActivityTaskCancelRequested   ←!    14 ActivityTaskCompleted        ←!
     *   15 ActivityTaskCanceled                15 ActivityTaskScheduled  refund
     *   16 WorkflowExecutionCanceled           16 ActivityTaskCompleted
     *                                          17 ActivityTaskScheduled  notifyCustomer
     *                                          18 ActivityTaskCompleted
     *                                          19 WorkflowExecutionCanceled
     *
     *   Status: CANCELED                       Status: CANCELED
     *   ↑ ★ 둘 다 CANCELED 입니다.
     *
     * 이것이 이 코스가 말하는 "에러 없이 조용히 잘못 동작하는 코드"의 전형입니다.
     * 예외도, 실패 이벤트도, 경고 로그도 없습니다. 모니터링 대시보드에서는
     * "취소 처리 완료"로 정상 집계됩니다. 결제는 환불되지 않았고 재고는 잠긴 채로 남습니다.
     * 히스토리를 직접 열어 보기 전까지는 아무도 모릅니다.
     *
     * 해결: Workflow.newDetachedCancellationScope(Runnable)
     *   부모 스코프의 취소로부터 분리된 새 스코프를 만듭니다.
     *   반드시 .run() 을 불러야 실행됩니다 — 만들기만 하면 아무 일도 일어나지 않습니다.
     *   (이것도 흔한 실수입니다. 컴파일도 되고 예외도 없이 보상이 통째로 사라집니다.)
     *
     * 검증 방법 (Step 11 방식):
     *   verify(payment).refund("PAY-8821");
     *   verify(inventory).release("RSV-3310");
     *   Status 만 단언하는 테스트는 두 버전을 구분하지 못합니다.
     *
     * ⚠️ detached scope 에는 타임아웃을 짧게
     *   보상이 오래 걸리면 워크플로우가 CANCELED 로 넘어가지 못하고 매달립니다.
     *   보상 액티비티의 startToCloseTimeout 과 maximumAttempts 를
     *   정방향보다 짧고 적게 잡고, 실패하면 알림으로 사람에게 넘기는 편이 낫습니다.
     */
    public static class Q3OrderWorkflowImpl implements OrderWorkflow {

        static final ActivityOptions ACT = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10))
                .build();

        // 보상용 옵션 — 정방향보다 짧게, 재시도도 적게
        static final ActivityOptions COMPENSATE = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(5))
                .setRetryOptions(io.temporal.common.RetryOptions.newBuilder()
                        .setMaximumAttempts(3)
                        .build())
                .build();

        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, ACT);
        private final InventoryActivity inventory =
                Workflow.newActivityStub(InventoryActivity.class, ACT);
        private final ShippingActivity shipping =
                Workflow.newActivityStub(ShippingActivity.class, ACT);

        private final PaymentActivity paymentCompensate =
                Workflow.newActivityStub(PaymentActivity.class, COMPENSATE);
        private final InventoryActivity inventoryCompensate =
                Workflow.newActivityStub(InventoryActivity.class, COMPENSATE);
        private final NotificationActivity notification =
                Workflow.newActivityStub(NotificationActivity.class, COMPENSATE);

        private String status = "STARTED";

        @Override
        public String processOrder(OrderRequest req) {
            final String[] paymentId = {null};
            final String[] reservationId = {null};
            try {
                status = "PAYMENT";
                paymentId[0] = payment.charge(req.orderId(), req.amount());
                status = "INVENTORY";
                reservationId[0] = inventory.reserve(req.orderId(), req.sku(), req.qty());
                status = "WAITING_SHIPMENT";
                shipping.requestShipment(req.orderId(), req.address());
                status = "DONE";
                return req.orderId() + " COMPLETED";

            } catch (CanceledFailure e) {
                status = "CANCELED";

                CancellationScope compensation = Workflow.newDetachedCancellationScope(() -> {
                    // 실행의 역순으로 보상합니다 (Step 09).
                    if (reservationId[0] != null) {
                        inventoryCompensate.release(reservationId[0]);
                    }
                    if (paymentId[0] != null) {
                        paymentCompensate.refund(paymentId[0]);
                    }
                    notification.notifyCustomer(req.orderId(), "주문이 취소되었습니다");
                });
                compensation.run();   // ★ 이 줄이 없으면 보상이 통째로 사라집니다

                throw e;              // 워크플로우는 CANCELED 로 마무리
            }
        }

        @Override
        public void cancelRequested(String reason) {
            status = "CANCELED";
        }

        @Override
        public String getStatus() {
            return status;
        }
    }

    /*
     * ─────────────────────────────────────────────────────────────────
     * 정답 4 — Search Attribute 등록과 upsert
     * ─────────────────────────────────────────────────────────────────
     * 키를 static final 상수로 뽑는 이유:
     *   SearchAttributeKey.forKeyword("OrderStage") 를 호출 지점마다 새로 쓰면
     *   "OderStage" 같은 오타가 런타임에야 드러납니다.
     *   (등록되지 않은 이름으로 upsert 하면 워크플로우 태스크가 실패합니다.)
     *   상수 하나로 모으면 오타가 한 곳에만 있을 수 있고, IDE 가 자동완성해 줍니다.
     *
     * upsertTypedSearchAttributes 는 결정적입니다.
     *   히스토리에 UpsertWorkflowSearchAttributes 이벤트가 남으므로
     *   리플레이 시 같은 순서로 재현됩니다. 워크플로우 코드 안에서 안전하게 쓸 수 있습니다.
     *
     * ⚠️ 남발하지 마세요.
     *   upsert 한 번 = 히스토리 이벤트 한 개입니다.
     *   루프 안에서 매 반복마다 upsert 하면 히스토리가 폭증하고,
     *   Workflow Task 처리 시간도 같이 늘어납니다(캐시 미스 시 전부 리플레이하므로).
     *   "단계가 바뀔 때만" 부르세요.
     *
     * 판단 기준 — Search Attribute vs Query:
     *   list 로 **검색**할 일이 있다   → Search Attribute
     *   특정 한 건의 **상세**를 본다   → Query (Step 07)
     *   Search Attribute 는 인덱싱용이지 상태 저장소가 아닙니다.
     *   값 하나당 2KB, 워크플로우당 총 40KB 제한이 있고, 인덱싱이 비동기입니다.
     */
    static String 정답4a_SA_등록_명령() {
        return "temporal operator search-attribute create "
                + "--name OrderStage --type Keyword --namespace orders";
    }

    static final SearchAttributeKey<String> STAGE = SearchAttributeKey.forKeyword("OrderStage");

    static void 정답4c_markStage(String stage) {
        Workflow.upsertTypedSearchAttributes(STAGE.valueSet(stage));
    }

    /*
     * ─────────────────────────────────────────────────────────────────
     * 정답 5 — Worker 튜닝 (데드락 방지)
     * ─────────────────────────────────────────────────────────────────
     * cacheSize 2000 → threadCount 최소 4000.
     *
     * 왜인가:
     *   Sticky Cache 는 실행 중인 워크플로우 인스턴스를 메모리에 유지해,
     *   다음 Workflow Task 가 왔을 때 히스토리를 처음부터 리플레이하지 않게 합니다.
     *   그런데 캐시된 워크플로우는 **자기 스레드를 점유한 채** 대기합니다.
     *   Workflow.sleep() 이나 액티비티 완료를 기다리는 지점에서 스레드가 멈춰 있는 구조이기 때문입니다.
     *
     *   cacheSize == threadCount 로 두면, 캐시가 가득 차는 순간 스레드가 정확히 소진됩니다.
     *   여기에 자식 워크플로우나 Async.function 으로 스레드를 추가로 쓰는 워크플로우가 하나라도 있으면
     *   스레드를 못 얻어 데드락입니다.
     *
     * 규칙:
     *   maxWorkflowThreadCount >= workflowCacheSize x (워크플로우당 평균 스레드 수 + 1)
     *   - 단순 워크플로우 (자식 없음, Async 없음)     : 배수 2
     *   - 자식 워크플로우 / Async.function 여러 개    : 배수 3~4
     *
     * 부족할 때 나오는 실제 로그:
     *   ERROR i.t.i.w.WorkflowExecutionHandler -
     *     io.temporal.internal.sync.PotentialDeadlockException:
     *     Potential deadlock detected: workflow thread "workflow-method-order-2288-1"
     *     didn't yield control for over a second.
     *     Failure to yield can be caused by blocking calls or by exhausting the workflow thread pool.
     *     Current thread pool: 600/600 in use, 0 available.
     *
     *   "600/600 in use, 0 available" 이 결정적 단서입니다.
     *   블로킹 호출 때문이라고 오해하기 쉬운데, 스레드 풀 고갈일 때도 같은 예외가 납니다.
     *
     * 반대 방향의 실수 — cacheSize 를 너무 낮게:
     *   캐시 미스가 늘어 매번 전체 히스토리를 리플레이합니다.
     *   이벤트 5,000개짜리 워크플로우면 Workflow Task 하나당 5,000개를 다시 돌립니다.
     *
     *   cacheSize 600  → sticky_cache_miss 8,421건, task_execution_latency p95 = 2.841초
     *   cacheSize 2000 → sticky_cache_miss    37건, task_execution_latency p95 = 0.028초
     *   약 100배 차이입니다. 물론 threadCount 도 4000 으로 함께 올렸습니다.
     *
     * 메모리도 함께 보세요. 캐시된 워크플로우 하나가 수백 KB~수 MB 를 씁니다.
     * cacheSize 를 올리면 힙도 같이 늘려야 합니다.
     */
    static WorkerFactory 정답5_factory(WorkflowClient client) {
        WorkerFactoryOptions options = WorkerFactoryOptions.newBuilder()
                .setWorkflowCacheSize(2000)
                .setMaxWorkflowThreadCount(4000)     // cacheSize x 2
                .build();
        return WorkerFactory.newInstance(client, options);
    }

    static int 정답5_선택한_threadCount() {
        return 4000;
    }

    /*
     * ─────────────────────────────────────────────────────────────────
     * 정답 6 — 메트릭 판독
     * ─────────────────────────────────────────────────────────────────
     * [A] 결정성
     *   workflow_task_execution_failed 가 8912. 나머지는 전부 정상입니다.
     *   slots_available 380 (여유 있음), latency 0.021초 (빠름), cache_miss 12 (정상).
     *   즉 Worker 는 건강한데 워크플로우 코드 실행 자체가 실패하고 있습니다.
     *   정상 운영에서 이 지표는 0이어야 합니다. 0이 아니면 거의 항상 NonDeterministicException 입니다.
     *
     *   대응 순서:
     *     1. Worker 로그에서 NonDeterministicException 확인 (12-8 의 3단계)
     *     2. **즉시 롤백.** 이게 1순위입니다.
     *        NonDeterministicException 은 워크플로우를 망가뜨리지 않습니다.
     *        Workflow Task 가 실패할 뿐이고 히스토리는 그대로이므로,
     *        옛 코드로 돌아가면 워크플로우들이 아무 일 없었다는 듯 이어서 진행합니다.
     *     3. ★ 절대 terminate 하지 마세요. 보상이 하나도 안 돌고 영구히 방치됩니다.
     *     4. 롤백 후 Workflow.getVersion() 을 넣고 재배포.
     *        Step 11 의 리플레이 테스트를 CI 에 추가해 재발을 막습니다.
     *
     * [B] Worker부족
     *   slots_available 이 0.0 입니다. 그리고 workflow/activity 양쪽
     *   schedule_to_start_latency 가 6.4초 / 9.9초로 높습니다.
     *   Task 는 큐에 쌓이는데 Worker 가 가져갈 슬롯이 없습니다.
     *   failed 는 0이므로 코드 문제는 아닙니다.
     *
     *   대응 순서 (12-7 의 튜닝 순서):
     *     1. task-queue describe 로 Poller 가 정말 있는지 확인 (0대면 배포 문제)
     *     2. **Worker 증설이 먼저입니다.** 파라미터를 키우는 것보다
     *        프로세스를 늘리는 편이 장애 격리 면에서도 낫습니다.
     *     3. 그래도 부족하면 maxConcurrentActivityExecutionSize 증가
     *     4. 슬롯은 남는데 latency 가 높으면 그때 폴러 수(5 → 10~20) 증가
     *     5. 근본 해결: 성격이 다른 작업을 Task Queue 로 분리
     *        (3초짜리 결제와 5분짜리 리포트가 같은 큐에 있으면 리포트가 슬롯을 다 씁니다)
     *
     * [C] 캐시부족
     *   sticky_cache_miss 가 8421 로 압도적이고, workflow_task_execution_latency 가 2.841초입니다.
     *   반면 schedule_to_start 는 0.412초로 나쁘지 않고 slots 도 150개 남습니다.
     *   즉 Task 를 가져오는 건 문제없는데, 가져와서 처리하는 게 느립니다.
     *   캐시에서 밀려난 워크플로우가 매번 전체 히스토리를 리플레이하는 중입니다.
     *
     *   대응:
     *     1. workflowCacheSize 증가 (600 → 2000)
     *     2. ★ maxWorkflowThreadCount 를 **반드시 함께** 올릴 것 (정답 5)
     *        cacheSize 만 올리면 PotentialDeadlockException 으로 바뀝니다.
     *        문제를 다른 문제로 교체하는 셈입니다.
     *     3. 힙 크기도 함께 확인
     *     4. 근본적으로 히스토리가 너무 길면 Continue-As-New 를 검토 (Step 08)
     */
    static String 정답6_A() {
        return "결정성";
    }

    static String 정답6_B() {
        return "Worker부족";
    }

    static String 정답6_C() {
        return "캐시부족";
    }

    /*
     * ─────────────────────────────────────────────────────────────────
     * 정답 7 — 진단 명령 순서
     * ─────────────────────────────────────────────────────────────────
     * 순서가 중요합니다. 위에서부터 하세요.
     * 아래 단계부터 손대면 원인을 못 찾고 파라미터만 커집니다.
     *
     * 1단계 describe — 무엇을 기다리는가
     *   Pending Activities 있음 + Attempt 증가        → 외부 시스템 장애 (4단계로)
     *   Pending Activities 있음 + State Scheduled     → Worker 가 안 가져감 (2단계로)
     *   Pending Workflow Task 만 + Attempt 가 큼      → 결정성 문제 (3단계로)
     *
     * 2단계 task-queue describe — Worker 가 붙어 있는가
     *   Poller 목록이 비었으면 셋 중 하나입니다.
     *     (a) Worker 프로세스 죽음
     *     (b) Worker 가 다른 Task Queue 이름으로 붙음 ← 오타. 매우 흔합니다
     *     (c) Worker 가 다른 Namespace 에 붙음
     *   LastAccessTime 이 몇 분 전에서 멈췄으면 Worker 는 살아 있으나
     *   폴링을 못 하는 상태입니다(스레드 고갈 등).
     *
     * 3단계 Worker 로그 — 예외 실물 확인
     *   NonDeterministicException 이면 어느 eventId 에서 무엇이 어긋났는지까지 나옵니다.
     *
     * 4단계 count + 메트릭 — 영향 범위
     *   한 건인지 전체인지에 따라 조치가 완전히 달라집니다.
     *   한 건이면 개별 reset, 전체면 롤백입니다.
     *
     * 5단계 조치 — 12-8 의 표 참고.
     *   ★ 외부 시스템 장애일 때는 **아무것도 하지 않는 것**이 정답입니다.
     *     복구되면 재시도가 알아서 성공합니다. 그러라고 Temporal 을 쓰는 것입니다.
     *
     * ───────────────────────────────────────────────────────────────
     * 마지막으로 — 이 진단이 필요한 상황 자체를 예방할 수 있습니다.
     *
     * 3단계에서 NonDeterministicException 을 발견했다면, 그것은
     * Step 11 의 리플레이 테스트가 CI 에 없었다는 뜻입니다.
     * 운영 히스토리 5개를 src/test/resources/histories/ 에 커밋하고
     * 모든 PR 에서 WorkflowReplayer 를 돌렸다면, 이 사고는 3초짜리 CI 단계에서
     * 배포 전에 잡혔을 것입니다.
     *
     * 운영 대응 능력보다 중요한 것은 대응할 일을 만들지 않는 것입니다.
     * ───────────────────────────────────────────────────────────────
     */
    static String[] 정답7_진단_순서() {
        return new String[]{
                "temporal workflow describe -w order-1004 --namespace orders",
                "temporal task-queue describe --task-queue ORDER_TASK_QUEUE --namespace orders",
                "kubectl logs deploy/order-worker --since=10m | grep -E \"NonDeterministic|Deadlock|ERROR\"",
                "temporal workflow count --query \"ExecutionStatus='Running'\" --namespace orders"
        };
    }

    // =====================================================================
    public static void main(String[] args) {
        System.out.println("── 정답 1 ──\n" + 정답1_namespace_명령());
        System.out.println("\n── 정답 2 ──\ntemporal workflow list --query \""
                + 정답2_쿼리() + "\" --namespace orders");
        System.out.println("\n── 정답 3 ──\nQ3OrderWorkflowImpl 참고 "
                + "(Workflow.newDetachedCancellationScope + .run())");
        System.out.println("\n── 정답 4 ──\n" + 정답4a_SA_등록_명령());
        System.out.println("\n── 정답 5 ──\nworkflowCacheSize=2000, maxWorkflowThreadCount="
                + 정답5_선택한_threadCount());
        System.out.println("\n── 정답 6 ──\nA=" + 정답6_A() + " / B=" + 정답6_B()
                + " / C=" + 정답6_C());
        System.out.println("\n── 정답 7 ──");
        String[] steps = 정답7_진단_순서();
        for (int i = 0; i < steps.length; i++) {
            System.out.println("  " + (i + 1) + "단계: $ " + steps[i]);
        }
    }
}