콘텐츠로 이동
개발 기록
← 전체 글

시간 초과를 고친 뒤 찾아온 메모리 부족

당시 자원 측정에서 수집과 판정을 마친 요청 기록 36,000건을 복원해 큰 신고 하나를 만들려고 했다. 이벤트 목록 조회를 다룬 글과 건수는 같지만, 이번 기록은 그보다 앞서 진행한 자원 시험의 표본이다. 처음에는 증거를 찾는 SQL이 30초 제한을 넘었다. 반복 조회를 줄여 이 단계를 통과하자, 이번에는 앱이 메모리 부족으로 종료됐다. 처음에는 앞서 고친 작업이 잘못된 줄 알았다. 나중에 그게 아니라는 걸 알고 다행이다 싶었다.

신고문과 그 근거는 개정판으로 보존한다. 보존할 증거가 많아지자 신고를 만드는 단계에서 문제가 드러났다. 시험은 OCI ARM64 서버에서 PostgreSQL 1 GB·1 CPU, 앱 256 MB·1 CPU 제한으로 진행했다. 한도는 일부러 빡빡하게 잡았다. 무작정 자원만 늘리는 방법으로는 해결했다고 보기 어려웠다. 입력은 같은 호스트에서 만든 합성 요청이며 실제 신고 메일은 보내지 않았다. 수치는 공개하지 않은 개인 시험 기록 기준이고, 아래 코드는 공개 저장소 cheesetrap의 것이다.

같은 증거를 판정마다 다시 펼치고 있었다

섹션 제목: “같은 증거를 판정마다 다시 펼치고 있었다”

신고를 만들려면 후보로 고른 판정과 그 근거가 된 요청 기록을 모아야 했다. 여러 판정이 같은 기록 묶음을 근거로 쓸 수 있었는데, 기존 조회는 이 묶음을 판정마다 다시 읽고 있었다.

그래서 신고에 포함할 판정들이 가리키는 묶음을 먼저 모으되, 같은 묶음은 한 번만 남기도록 바꿨다. 그다음 각 묶음의 실제 기록을 읽고 판정별 증거 수와 연결 관계를 계산했다. 각 판정이 어떤 증거를 사용했는지는 유지하면서 반복 조회를 줄였고, SQL 시간 제한을 넘던 단계를 통과했다.

시간이 줄어든 뒤에도 메모리는 부족했다

섹션 제목: “시간이 줄어든 뒤에도 메모리는 부족했다”

첫 SQL 개선 후보는 초안 생성을 시작한 지 약 9.24초 만에 종료됐다. 컨테이너 기록에는 OOMKilled=true가 남았다. 메모리가 부족해 운영체제가 프로세스를 종료한 것이다. PostgreSQL의 OOM이나 재시작은 없었고, 앱이 256 MB 한도에 걸렸다.

앱이 종료되면서 진행 중이던 저장도 취소됐다. 신고와 증거 사본, 개정판은 남지 않았고 수집한 원본과 판정은 보존됐다.

어디서 메모리가 늘어나는지 좁히기 위해 마지막으로 끝난 SQL과 Go의 메모리 할당 기록을 함께 살폈다. 별도의 진단 재실행에서는 출발지 판정 조회가 약 2.36초, 후보 증거 조회가 약 1.28초에 끝났다. 이 실행은 증거 사본을 복사하는 단계 뒤, 개정판을 저장하기 전에 메모리 부족으로 종료됐다. 이 사이에서 증거를 어떤 형태로 만들고 전달하는지 확인할 차례였다.

전체 내용을 한 번 더 만드는 곳부터 줄이기

섹션 제목: “전체 내용을 한 번 더 만드는 곳부터 줄이기”

앞선 신고문·승인 글에서 다룬 digest는 내용이 같은지 대조하는 요약값이다. 기존에는 본문과 증거 등 전체 내용을 JSON 바이트 배열로 바꾼 뒤 이 값을 계산했다. 계산을 위해 전체 크기의 임시 배열이 하나 더 필요했던 셈이다.

이 과정을 항목 하나씩 JSON으로 바꾸고, 그 내용을 순서대로 계산에 반영하도록 고쳤다. 자료를 저장·전송할 형태로 바꾸는 직렬화를 나누어 수행해, 전체를 담는 임시 배열을 줄였다. 같은 내용에서 기존과 같은 digest가 나오는지도 대조했다.

하지만 이 후보도 OCI에서 8.840초 만에 OOM으로 끝났다. 요약값 계산을 바꾼 뒤에도 저장 준비 과정의 메모리를 더 줄여야 했다.

증거 사본을 데이터베이스에 넣을 때도 한꺼번에 전달하는 양을 줄이기 위해 1,000개씩 나눴다. 모든 배치를 하나의 트랜잭션으로 묶어, 중간에 실패하면 앞서 넣은 사본도 함께 취소되도록 했다. 공개 저장소의 해당 함수는 다음과 같다.

// Copy in bounded statements inside the existing draft transaction. This keeps
// the JSON encoder and pgx parameter buffers small; any later failure still
// rolls back the report, every prior batch, and its revision/candidate together.
func copyReportEvidence(ctx context.Context, q *db.Queries, reportID pgtype.UUID, evidence []domain.ReportEvidence) error {
const batchSize = 1000
for start := 0; start < len(evidence); start += batchSize {
data, err := json.Marshal(evidence[start:min(start+batchSize, len(evidence))])
if err != nil {
return err
}
if err := q.CopyReportEvidenceBatch(ctx, db.CopyReportEvidenceBatchParams{ReportID: reportID, Snapshots: data}); err != nil {
return err
}
}
return nil
}

개정판에 보존할 증거 묶음을 JSON으로 만드는 작업도 남아 있었다. 여기서는 최종 크기에 맞춘 임시 저장 공간인 버퍼 하나를 사용하도록 바꿨다. 만들어진 JSON은 기존 방식의 결과와 비교했다. 이 함수는 같은 JSON을 두 번 만든다. 첫 번째는 크기만 세고, 두 번째는 그 크기로 한 번 만든 버퍼에 쓴다.

// Count and validate before allocating the final buffer. Both passes marshal
// one array element at a time, so neither retains a second whole-snapshot
// encoding buffer. Domain marshaling preserves the exact former JSON bytes.
func marshalReportSnapshot(snapshot domain.ReportSnapshot) ([]byte, error) {
fields, err := snapshotJSONFields(snapshot)
if err != nil {
return nil, err
}
var size snapshotJSONSize
if err := writeSnapshotJSON(&size, fields, snapshot); err != nil {
return nil, err
}
output := snapshotJSONOutput{data: make([]byte, size.n)}
if err := writeSnapshotJSON(&output, fields, snapshot); err != nil {
return nil, err
}
if output.n != len(output.data) {
return nil, io.ErrShortWrite
}
return output.data, nil
}

사본 배치와 단일 JSON 버퍼까지 적용한 후보도 11.042초 만에 같은 256 MB 한도에 걸렸다. 다음 진단에서는 증거 사본 배치가 모두 끝났고, 개정판 저장을 시작한다는 기록 뒤에 종료됐다. 이제 증거 묶음을 데이터베이스로 보내는 부분을 살폈다.

데이터베이스에 넘기는 순서에도 복사가 숨어 있었다

섹션 제목: “데이터베이스에 넘기는 순서에도 복사가 숨어 있었다”

앱에서 PostgreSQL로 값을 보내는 Go 라이브러리인 pgx는 전송할 값을 버퍼에 담았다. 당시에는 큰 증거 JSON을 먼저 담고 그 뒤에 본문을 추가했다. 본문을 넣을 공간이 부족하면 더 큰 버퍼가 필요해졌고, 앞서 담은 큰 JSON도 새 버퍼로 복사되는 일이 생겼다.

사용 중이던 pgx 버전으로 이 과정을 로컬에서 따로 재현했다. 약 30.8 MB의 증거 JSON과 8 KB 본문을 입력으로 사용했다. 큰 JSON을 마지막에 담도록 값의 전달 순서를 바꾸자, 전송 버퍼를 만드는 동안 누적 할당한 메모리가 약 138.7 MB에서 61.7 MB로 줄었다. 이는 순간 최대 메모리가 아니라 그 과정에서 할당한 양의 합이다. 보내는 데이터의 양은 같아도, 중간에 버퍼를 키우며 복사하는 비용은 달라졌다.

이 결과를 바탕으로 데이터베이스에 값을 넘기는 파라미터 순서를 바꿨다. 순서를 바꾸면서 다른 열에 값이 저장되지 않도록 대응을 맞췄고, 실제 저장된 값도 대조했다.

변경은 두 곳이다. 먼저 쿼리에서 큰 snapshot이 들어갈 열의 위치는 두고, VALUES가 가리키는 번호만 $12로 옮겼다. 아래에서 - 줄은 변경 전, + 줄은 변경 후다.

INSERT INTO cheesetrap.report_revisions(report_id,version,snapshot,subject,body,recipient,reply_to,hold_reasons,state,auto_approval_allowed,body_edited,content_digest) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12) RETURNING revision_id;
INSERT INTO cheesetrap.report_revisions(report_id,version,snapshot,subject,body,recipient,reply_to,hold_reasons,state,auto_approval_allowed,body_edited,content_digest) VALUES($1,$2,$12,$3,$4,$5,$6,$7,$8,$9,$10,$11) RETURNING revision_id;

다음은 이 쿼리에서 sqlc가 생성한 Go 코드다. 여기서 arg.Snapshot을 마지막 인자로 넘겨야 pgx의 전송 버퍼에도 큰 JSON이 마지막에 담긴다.

row := q.db.QueryRow(ctx, appendReportRevision,
arg.ReportID,
arg.Version,
arg.Snapshot,
arg.Subject,
arg.Body,
arg.Recipient,
arg.ReplyTo,
arg.HoldReasons,
arg.State,
arg.AutoApprovalAllowed,
arg.BodyEdited,
arg.ContentDigest,
arg.Snapshot,
)

앞의 138.7 MB와 61.7 MB는 이 쿼리를 실행해 잰 값이 아니라, 같은 pgx 버전에서 전송 버퍼를 만드는 과정만 따로 호출한 로컬 재현의 값이다.

수정 뒤 OCI 실행에서는 초안 생성 함수가 약 9.12초에 성공했다. 신고 1개와 개정판 1개, 증거 사본 18,600개가 저장됐다. 그런데 저장한 내용을 확인하던 검증 도구가 메모리 부족으로 종료됐다.

저장한 내용을 다시 읽을 때도 확인하기

섹션 제목: “저장한 내용을 다시 읽을 때도 확인하기”

신고문은 저장한 뒤 다시 열어 검토하고 수정할 수 있어야 했다. 그래서 검증 도구도 실제 앱의 함수를 호출해 개정판을 읽고 내용을 대조했다. 다만 처음의 실패 기록만으로는 이 도구 안에서 어느 작업이 메모리를 넘겼는지 알기 어려웠다.

먼저 도구 자체가 전체 증거 배열을 다시 만들거나 데이터베이스로 재전송하는 중복 작업을 줄이고, 각 앱 함수를 호출하기 전후로 기록을 남겼다. 다음 시도에서는 초안 생성 뒤 개정판을 읽는 앱 함수가 반환하기 전에 OOM이 발생했다. 검증 도구의 부담을 덜어 낸 뒤에도 실제 읽기 작업이 메모리 한도에 걸린 것이다.

OCI에서 다시 읽은 것은 개정판에 보존한 전체 증거 묶음으로, JSON 문자열 기준 약 34.3 MB였다. 이 내용을 메모리의 자료 구조로 풀어야 하므로, 저장할 때의 임시 복사를 줄인 뒤에도 메모리가 필요했다.

앞의 30.8 MB는 로컬 재현용 입력의 크기다. 여기서 읽은 전체 증거 묶음은 메일 본문에 넣는 발췌와도 구별된다.

Go의 메모리 회수에도 예산을 두기

섹션 제목: “Go의 메모리 회수에도 예산을 두기”

cheesetrap은 Go로 만들었다. 지금까지는 Node.js만 써 왔지만, 에이전트와 함께 일하는 지금은 한 가지 언어만 쓸 이유가 더더욱 없다고 생각했다.

코드에서 불필요한 복사를 줄이는 작업에 이어, Go가 사용한 메모리를 회수하는 설정도 살폈다. Go의 GC는 더 이상 필요하지 않은 메모리를 찾아 회수한다. 컨테이너에는 앱을 종료시킬 수 있는 256 MB 한도가 있었지만, Go가 메모리를 관리할 때 참고할 예산은 별도로 설정할 수 있었다.

그 설정이 GOMEMLIMIT다. 이번에는 256 MB 컨테이너 한도와 64 MB 차이를 두는 시험값으로 GOMEMLIMIT=192MiB를 적용했다. Go에 이 예산을 알려 주어 메모리 회수 시점을 조절하도록 했다. Go GC 문서에서 설명하듯 이 값은 Go 런타임이 지키도록 노력하는 목표이며, 사용량을 항상 그 아래로 제한하지는 않는다.

설정의 영향을 확인하기 위해 앞선 코드 개선을 모두 적용한 앱과 검증 도구의 실행 파일, 256 MB·1 CPU 제한은 그대로 두었다. 같은 원본 데이터의 백업을 새로 복원한 뒤, 검증 도구의 GOMEMLIMIT만 바꿔 생성·읽기·수정을 다시 시험했다. 개선 전 코드에 이 설정만 적용한 시험이나 다른 예산값과의 비교 결과는 보존 기록에서 확인하지 못했다.

이 설정을 적용한 새 복원 표본에서는 다음 결과를 얻었다. 표는 각 앱 함수의 호출 시간이다.

실제 호출 소요 시간
신고 초안 생성 9.050초
첫 개정판 읽기 0.570초
두 번째 개정판 생성 3.966초
세 번째 개정판 생성 4.075초

검증을 포함한 전체 프로세스 시간은 생성·검증 14.244초, 두 번의 수정·검증 19.048초였다.

두 과정 모두 OOM 없이 끝났다. 컨테이너 전체에서 관측한 최대 메모리는 생성·검증 때 약 205 MB, 수정·검증 때 약 214 MB였다. 192 MB는 Go 런타임에 알려 준 예산이고, 이 두 값은 컨테이너 전체의 사용량을 측정한 결과다.

메모리를 줄이는 동안 증거가 빠지거나 내용이 달라지지 않았는지도 확인했다. 증거 18,600개와 각 판정의 규칙 정보, 세 개정판의 내용을 별도의 SQL로 대조했고 저장된 digest도 다시 계산했다.

이후 같은 메모리 설정을 반영한 배포 구성으로도 새로 준비한 두 표본에서 생성·읽기·수정과 내용 대조를 통과했다. 이 확인은 검증 환경에서 진행했다. 배포 구성에는 다음처럼 적었다. 컨테이너 한도는 같은 파일의 mem_limit: 256m이다.

# Go soft memory budget within the unchanged 256 MiB container limit.
x-app-env: &app-env
GOMEMLIMIT: 192MiB

이 결과는 해당 크기의 신고를 정해진 자원 안에서 처리한 기록이다.

생성에서 읽기와 수정까지 끝내기

섹션 제목: “생성에서 읽기와 수정까지 끝내기”

처음에는 증거를 찾는 SQL이 시간 제한에 걸렸다. 반복 조회를 줄인 뒤에는 증거를 JSON으로 만들고 전송하는 과정의 메모리가 문제가 됐다. 임시 배열과 버퍼 복사를 줄여 저장에 성공한 다음에는, 다시 읽고 수정하는 작업까지 같은 한도 안에서 확인했다.

이 표본에서는 컨테이너의 메모리 한도를 높이지 않고 생성·읽기·수정을 마칠 수 있었다. 신고를 만드는 데 쓴 증거와 세 개정판의 내용도 유지됐다. 검토할 신고문을 만드는 작업의 완료 기준을, 저장에 성공하는 데서 내용을 다시 열어 확인하고 고칠 수 있는 데까지 두게 됐다.

이번 작업은 에이전트의 도움을 많이 받았다. 성능 개선도 에이전트와 함께라면 충분히 해낼 수 있다는 걸 배웠다. 대신 방향을 잘 정해 줘야 한다. 그러지 않으면 한도를 올리는 것 같은 쉬운 길로 빠지려 할 것이다.