eform-ops · 운영을 연결하는 플랫폼

1    public DbAccessRequestResponse approve(String requestNo, Authentication authentication) {
2        // ... 요청 검증·대상 계산과 중간 grant 준비 생략 ...
3        if (provisioningService.isProvisioningEnabled()) {
4            provisioningService.provisionAccess(
5                    target,
6                    request.getRequesterUsername(),
7                    temporaryPassword,
8                    request.getPermissionTemplate(),
9                    readPermissions(request.getCustomPermissionsJson())
10            );
11        }
12        // ... grant 저장과 sibling 처리 생략 ...
13        auditService.record(
14                saved,
15                saved.getGrant(),
16                "REQUEST_APPROVED",
17                actor,
18                "DB Access 요청이 승인되었습니다.",
19                Map.of(
20                        "expiresAt", format(expiresAt),
21                        "dbUsername", saved.getGrant().getDbUsername(),
22                        "targetKey", saved.getGrant().getTargetKey(),
23                        "provisioningEnabled", provisioningService.isProvisioningEnabled()
24                ),
25                widgetAuditContext(authentication)
26        );
27        dbAccessNotifyService.notifyRequestApproved(saved, actor);
28        recordAudit(authentication, saved, "DB_ACCESS_APPROVE", "SUCCESS", "HIGH",
29                Map.of("status", DbAccessStatus.REQUESTED.name()), Map.of("status", saved.getStatus().name()),
30                "DB access request approved");
31
32        return toResponse(saved, actor, true, OPERATION_APPROVED);
33    }

1    private String buildQuery(String regionCode, String targetDb, String dbUsername, Instant from, Instant to) {
2        List<String> dateFilters = enumerateDateFilters(from, to);
3        String escapedRegion = escapeSql(regionCode);
4        String escapedTargetDb = escapeSql(targetDb);
5        String escapedDbUser = escapeSql(dbUsername);
6        long fromEpochMillis = from.toEpochMilli();
7        long toEpochMillis = to.toEpochMilli();
8
9        return """
10                SELECT event_time, cloudwatch_event_timestamp_ms, db_user, client_host, event_type, status, query_text, query_id, connection_id
11                FROM %s.%s
12                WHERE region = '%s'
13                  AND target_db = '%s'
14                  AND db_user = '%s'
15                  AND (%s)
16                  AND cloudwatch_event_timestamp_ms >= %d
17                  AND cloudwatch_event_timestamp_ms <= %d
18                ORDER BY cloudwatch_event_timestamp_ms DESC
19                LIMIT %d
20                """.formatted(
21                props.getDatabaseName(),
22                props.getTableName(),
23                escapedRegion,
24                escapedTargetDb,
25                escapedDbUser,
26                String.join(" OR ", dateFilters),
27                fromEpochMillis,
28                toEpochMillis,
29                props.getMaxRows()
30        );
31    }

1    private void reconcileBuild(ReleaseRequest request) {
2        if (request.getBuildJobId() == null || request.getBuildJobId().isBlank()) return;
3        try {
4            BuildJob build = buildService.findForReconciliation(request.getBuildJobId());
5            releaseRequestService.observeBuildPhase(request.getId(), build);
6            if (build == null) return;
7            if (build.getStatus() == BuildStatus.SUCCESS) {
8                createJob(request, build.getId());
9            } else if (build.getStatus() == BuildStatus.FAILED) {
10                releaseRequestService.markFailed(request.getId(),
11                        "Build finished with status " + build.getStatus());
12            } else if (build.getStatus() == BuildStatus.CANCELLED) {
13                releaseRequestService.markCancelled(request.getId(),
14                        "Build finished with status " + build.getStatus());
15            }
16        } catch (RuntimeException exception) {
17            log.debug("[release-request] build reconciliation deferred requestNo={} message={}",
18                    request.getRequestNo(), safeMessage(exception));
19        }
20    }

1    private String startProviderBuild(
2            BuildJob job,
3            ManifestDto manifest,
4            String manifestBucket,
5            String env,
6            ManifestItemDto item,
7            int attempt,
8            RuntimeDispatch runtime,
9            BuildProviderExecution sourceExecution
10    ) {
11        StartBuildResponse resp = codeBuild.startBuild(r -> r
12                .projectName(props.getWorkerProjectName())
13                .idempotencyToken(idempotencyToken(job.getId(), env, item.region(), item.app(), attempt))
14                .environmentVariablesOverride(
15                        env("ARTIFACT_BUCKET", manifestBucket),
16                        env("ARTIFACT_KEY", item.s3Key()),
17                        env("SOURCE_MANIFEST_BUCKET", manifestBucket),
18                        env("SOURCE_MANIFEST_KEY", sourceExecution == null ? "" : sourceExecution.getManifestKey()),
19// ... 실행 대상·이미지·Runtime Contract 환경변수 중간 항목 생략 ...
20                        env("ECR_REPO_URI", runtime.ecrRepoUri()),
21                        env("ECR_REGION", runtime.ecrRegion())
22                )
23        );
24        return providerBuildId(resp);
25    }

1    private void executeMutationRun(String runId, List<String> laneIds, int preparationAttempt) {
2        try {
3            mutationGuard.assertMutationAllowed();
4            if (preparationAttempt == 0) {
5                stateStore.markRunRunning(runId);
6            }
7            // ... 준비 lane 실행과 중간 barrier 처리 생략 ...
8            EksUpgradeAvailabilityBarrierService.BarrierResult barrier =
9                    verifyGlobalAvailabilityBarrier(runId, laneIds);
10            if (barrier != null && !barrier.passed()) {
11                String reason = barrier.validation() == null || barrier.validation().blockers().isEmpty()
12                        ? "Global availability barrier timed out"
13                        : String.join("; ", barrier.validation().blockers());
14                abortPreparedLanes(laneIds, reason);
15                finalizeExecutionRunIfTerminal(runId);
16                return;
17            }
18            // ... 완료 lane 집계 전환 생략 ...
19            if (stateStore.allLanesTerminal(runId)) {
20                EksUpgradeRunStatus status = stateStore.finalizeRun(runId);
21                log.info("[UPGRADE][RUN][EXECUTE_DONE] runId={} status={} lanes={}", runId, status, laneIds.size());
22            } else {
23                log.info("[UPGRADE][RUN][WAITING_EXTERNAL] runId={} lanes={}", runId, laneIds.size());
24            }
25        } catch (CompletionException e) {
26            Throwable cause = e.getCause() == null ? e : e.getCause();
27            log.warn("[UPGRADE][RUN][EXECUTE_FAIL] runId={} message={}", runId, cause.getMessage(), cause);
28            stateStore.failRun(runId, message(cause));
29        } catch (Exception e) {
30            log.warn("[UPGRADE][RUN][EXECUTE_FAIL] runId={} message={}", runId, e.getMessage(), e);
31            stateStore.failRun(runId, message(e));
32        }
33    }

1    private JobAiAnalysisResponse startLocked(Long jobId, String sourceId, String actor, boolean force) {
2        // ... failed job 확인·중복 실행 조회·fingerprint 검증 생략 ...
3        ErrorLogDeepAnalysisJobResponse started;
4        if (evidenceCollector == null) {
5            // Kept for legacy embedding callers and focused tests that use the
6            // five-argument constructor.  The Spring path always has the
7            // collector and uses deferred collection below.
8            JobExecutionLogResponse logs = executionLogService.logs(jobId, null, 300, null, null, null);
9            JsonNode evidenceSnapshot = collectEvidenceSnapshot(job, failureEvidence.items(), logs);
10            String rawLog = buildPromptLog(job, logs, failureEvidence, evidenceSnapshot);
11            started = deepAnalysisService.startInfrastructureAssociated(
12                    new ErrorLogDeepAnalysisRequest(null, rawLog, evidenceSnapshot), actor,
13                    SOURCE_TYPE, sourceId, fingerprint
14            );
15        } else {
16            String pendingLog = pendingPromptLog(job, failureEvidence);
17            Supplier<ObservabilityErrorLogDeepAnalysisService.EvidencePreparation> supplier =
18                    () -> prepareEvidence(job, failureEvidence);
19            started = deepAnalysisService.startInfrastructureAssociatedDeferred(
20                    new ErrorLogDeepAnalysisRequest(null, pendingLog), actor,
21                    SOURCE_TYPE, sourceId, fingerprint, supplier
22            );
23        }
24        active.put(started.jobId(), new SourceRef(sourceId, fingerprint));
25        return response(started, sourceId, fingerprint, false);
26    }

1    public Map<String, Object> collect(AlarmAnalysisClaimResponse.Item item) {
2        Instant center = item.stateUpdatedAt() == null ? Instant.now() : item.stateUpdatedAt();
3        Instant start = center.minus(Duration.ofMinutes(Math.max(1, props.getAiops().getEvidenceWindowBeforeMinutes())));
4        Instant end = center.plus(Duration.ofMinutes(Math.max(1, props.getAiops().getEvidenceWindowAfterMinutes())));
5        int periodSeconds = Math.max(60, props.getAiops().getMetricPeriodSeconds());
6
7// ... metric·target health·EKS 수집 중간 단계 생략 ...
8        Map<String, Object> kubernetesEvidence = eksKubernetesEvidenceCollector.collect(item, targetHealth, toolResults, warnings);
9        evidence.put("eks", kubernetesEvidence.getOrDefault("eks", Map.of(
10                "status", "NOT_COLLECTED",
11                "reason", "Kubernetes evidence collector did not return EKS data."
12        )));
13        Map<String, Object> logEvidence = aiopsLogEvidenceCollector.collect(item, dimensions, start, end, toolResults, warnings);
14        evidence.put("logs", logEvidence);
15        evidence.put("deployments", kubernetesEvidence.getOrDefault("deployments", Map.of(
16                "status", "NOT_COLLECTED",
17                "reason", "Kubernetes evidence collector did not return deployment data."
18        )));
19        evidence.put("historicalErrorPatterns", historicalErrorPatternCollector.collect(logEvidence, warnings));
20        evidence.put("toolResults", toolResults);
21        evidence.put("warnings", warnings);
22        return evidence;
23    }

1    def search_global(self, req: OpsPlanRequest, plan: OpsQuestionPlan) -> list[dict[str, Any]]:
2        merged: dict[str, dict[str, Any]] = {}
3        rrf_k = env_int("QA_HYBRID_RRF_K", 60)
4        queries = list(dict.fromkeys(text(value) for value in [req.question, *plan.searchQueries] if text(value)))
5        filters = self.global_filters(req, plan)
6        for query in queries[: env_int("QA_SEARCH_MAX_QUERIES", 14)]:
7            lexical_body = {
8                "size": env_int("QA_LEXICAL_TOP_K", 30),
9                "query": {"bool": {"filter": filters, "must": [{"multi_match": {
10                    "query": query,
11                    "fields": ["title^4", "summary^3", "content_text^2", "actor^2", "resource_id^3", "correlation_id^2"],
12                    "type": "best_fields", "operator": "or",
13                }}]}},
14                "sort": self.global_sort_clause(plan),
15            }
16            response = self.request("POST", f"/{self.global_index}/_search", lexical_body)
17            # ... lexical 응답 처리·RRF 병합 생략 ...
18            vector = self.embedding.embed_query(query)
19            if vector:
20                vector_body = {"size": env_int("QA_VECTOR_TOP_K", 30), "query": {"knn": {"embedding": {
21                    "vector": vector,
22                    "k": env_int("QA_VECTOR_TOP_K", 30),
23                    "filter": {"bool": {"filter": filters}},
24                }}}}
25                response = self.request("POST", f"/{self.global_index}/_search", vector_body)
26                # ... vector 응답 처리·RRF 병합 생략 ...
27        docs = self.collapse_source_chunks(list(merged.values()))
28        # ... semantic score 계산과 정렬 생략 ...
29        return self.mmr_diversify(docs, env_int("QA_RETRIEVAL_TOP_K", 40))

1    public Decision authorizeQuestion(String roomId, String requesterMxid, String botMxid, String question) {
2        Optional<ElementAiRoomPolicy> policy = allowedRoom(roomId);
3        if (policy.isEmpty()) return Decision.deny("이 방은 OPS AI 상세 답변 허용 방이 아닙니다.");
4        Map<String, String> members = matrix.joinedMembers(roomId);
5        if (botMxid == null || !members.containsKey(botMxid)) return Decision.deny("OPS 봇이 이 방에 참여하고 있지 않습니다.");
6        RequesterResolution requesterResolution = requester(members, requesterMxid);
7        if (!requesterResolution.allowed()) return Decision.deny(requesterResolution.reason());
8        PortalUser requester = requesterResolution.user();
9        ElementAiSharedAuthorizationGateway gateway = sharedAuthorization.getIfAvailable();
10        if (gateway == null) return Decision.deny("OPS AI 권한 검증 모듈이 아직 연결되지 않았습니다.");
11        Set<Long> requesterOnly = Set.of(requester.getId());
12        ElementAiSharedAuthorizationGateway.Decision decision = gateway.authorize(roomId, requester.getId(), requesterOnly, question);
13        return decision.allowed() ? Decision.allow(requester.getId(), requesterOnly, policy.get().allowFiles(), policy.get().revision())
14                : Decision.deny(decision.reason());
15    }