diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 605fd90..bd945f6 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -16,7 +16,7 @@ concurrency:
jobs:
build:
runs-on: ubuntu-latest
- timeout-minutes: 20
+ timeout-minutes: 25
steps:
- name: Checkout
uses: actions/checkout@v6
@@ -26,26 +26,44 @@ jobs:
with:
distribution: temurin
java-version: 21
- cache: maven
+
+ - name: Set up Gradle
+ uses: gradle/actions/setup-gradle@v5
+ with:
+ gradle-home-cache-cleanup: true
+ # Configuration cache occasionally trips up the Vanniktech publish
+ # plugin's property-driven configuration — keep CI off it.
+ cache-read-only: ${{ github.ref != 'refs/heads/master' }}
- name: Build and test
- run: ./mvnw -B verify
+ # `build` runs compileJava + compileTestJava + test on every subproject.
+ # `jacocoTestReport` is wired in each module's build.gradle.kts but
+ # repeating it here makes the dependency explicit for the next step.
+ run: ./gradlew build jacocoTestReport --no-configuration-cache --stacktrace
- name: Upload coverage to Codecov
if: success() && github.event_name == 'push'
uses: codecov/codecov-action@v6
with:
- files: ./target/site/jacoco/jacoco.xml
+ # Glob across all subprojects so adding a future module (e.g.
+ # api-log-jdbc) picks up its coverage report without another edit.
+ files: |
+ ./core/build/reports/jacoco/test/jacocoTestReport.xml
+ ./jpa/build/reports/jacoco/test/jacocoTestReport.xml
+ ./r2dbc/build/reports/jacoco/test/jacocoTestReport.xml
+ ./mybatis/build/reports/jacoco/test/jacocoTestReport.xml
flags: unittests
- fail_ci_if_error: false # don't break CI if Codecov upload glitches
- token: ${{ secrets.CODECOV_TOKEN }} # optional for public repos
+ fail_ci_if_error: false
+ token: ${{ secrets.CODECOV_TOKEN }}
- name: Upload test reports on failure
if: failure()
uses: actions/upload-artifact@v7
with:
name: test-reports
+ # `**` so any future module's reports are also captured.
path: |
- target/surefire-reports/
- target/failsafe-reports/
+ **/build/reports/tests/
+ **/build/test-results/
+ **/build/reports/jacoco/
retention-days: 7
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index b11dfc3..a830b95 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -13,6 +13,7 @@ jobs:
publish:
runs-on: ubuntu-latest
timeout-minutes: 30
+ environment: maven-central
steps:
- name: Checkout
uses: actions/checkout@v6
@@ -22,26 +23,31 @@ jobs:
with:
distribution: temurin
java-version: 21
- cache: maven
- server-id: central # matches central in settings.xml below
- server-username: MAVEN_CENTRAL_USERNAME
- server-password: MAVEN_CENTRAL_PASSWORD
- gpg-private-key: ${{ secrets.SIGNING_KEY }}
- gpg-passphrase: MAVEN_GPG_PASSPHRASE # maven-gpg-plugin 3.x convention
+
+ - name: Set up Gradle
+ uses: gradle/actions/setup-gradle@v5
- name: Derive version from tag
id: ver
run: echo "version=${GITHUB_REF#refs/tags/v}" >> "$GITHUB_OUTPUT"
- - name: Set release version
- run: ./mvnw -B versions:set -DnewVersion=${{ steps.ver.outputs.version }} -DgenerateBackupPoms=false
+ - name: Build and test
+ run: ./gradlew build --no-configuration-cache --stacktrace -PVERSION=${{ steps.ver.outputs.version }}
- - name: Build, sign, and publish to Maven Central
+ - name: Publish to Maven Central
env:
- MAVEN_CENTRAL_USERNAME: ${{ secrets.MAVEN_CENTRAL_USERNAME }}
- MAVEN_CENTRAL_PASSWORD: ${{ secrets.MAVEN_CENTRAL_PASSWORD }}
- MAVEN_GPG_PASSPHRASE: ${{ secrets.SIGNING_KEY_PASSWORD }}
- run: ./mvnw -B -P release deploy
+ # Sonatype Central Portal credentials (https://central.sonatype.com/account)
+ ORG_GRADLE_PROJECT_mavenCentralUsername: ${{ secrets.MAVEN_CENTRAL_USERNAME }}
+ ORG_GRADLE_PROJECT_mavenCentralPassword: ${{ secrets.MAVEN_CENTRAL_PASSWORD }}
+ # ASCII-armored private key (`gpg --armor --export-secret-keys `)
+ ORG_GRADLE_PROJECT_signingInMemoryKey: ${{ secrets.SIGNING_KEY }}
+ ORG_GRADLE_PROJECT_signingInMemoryKeyId: ${{ secrets.SIGNING_KEY_ID }}
+ ORG_GRADLE_PROJECT_signingInMemoryKeyPassword: ${{ secrets.SIGNING_KEY_PASSWORD }}
+ run: |
+ ./gradlew publishAndReleaseToMavenCentral \
+ --no-configuration-cache \
+ --stacktrace \
+ -PVERSION=${{ steps.ver.outputs.version }}
- name: Create GitHub Release
uses: softprops/action-gh-release@v3
@@ -49,6 +55,8 @@ jobs:
generate_release_notes: true
name: ${{ github.ref_name }}
fail_on_unmatched_files: false
+ # Glob across every module's build/libs/ so the release page picks up
+ # api-log-core / -jpa / -r2dbc / -mybatis without per-module entries.
files: |
- target/*.jar
- target/*.asc
+ **/build/libs/*.jar
+ **/build/libs/*.asc
diff --git a/.gitignore b/.gitignore
index 54d84eb..68089bb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,10 +1,20 @@
-HELP.md
-target/
-.mvn/wrapper/maven-wrapper.jar
-!**/src/main/**/target/
-!**/src/test/**/target/
+# Gradle
+.gradle/
+build/
+!gradle/wrapper/gradle-wrapper.jar
+!**/src/main/**/build/
+!**/src/test/**/build/
-### STS ###
+# IDE - IntelliJ
+.idea/
+*.iws
+*.iml
+*.ipr
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+# IDE - Eclipse / STS
.apt_generated
.classpath
.factorypath
@@ -12,33 +22,47 @@ target/
.settings
.springBeans
.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
-### IntelliJ IDEA ###
-.idea
-*.iws
-*.iml
-*.ipr
+# IDE - VS Code
+.vscode/
-### NetBeans ###
+# NetBeans
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
-build/
-!**/src/main/**/build/
-!**/src/test/**/build/
-### VS Code ###
-.vscode/
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
-### PostgreSQL data ###
+# Secrets / signing
+*.gpg
+secring.*
+local.properties
+gradle-local.properties
+*.env
+.env*
+!.env.example
+
+# PostgreSQL data
data/
-### Claude ###
+# Claude
.claude/
-### Application properties (root level duplicate) ###
+# Application properties (root level duplicate; test fixtures are kept)
application.properties
-# Test fixtures should be tracked though
!src/test/resources/application.properties
+
+# Test results
+/test-results/
+/reports/
diff --git a/.mvn/wrapper/maven-wrapper.properties b/.mvn/wrapper/maven-wrapper.properties
deleted file mode 100644
index c0bcafe..0000000
--- a/.mvn/wrapper/maven-wrapper.properties
+++ /dev/null
@@ -1,3 +0,0 @@
-wrapperVersion=3.3.4
-distributionType=only-script
-distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.11/apache-maven-3.9.11-bin.zip
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6719876..85bc82a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,35 @@ The source of truth for the entries below is [docs/changelog.md](docs/changelog.
## [Unreleased]
+## [0.6.0] — Multi-module split (Gradle), pluggable JPA / R2DBC / MyBatis backends
+
+### Changed
+
+- **The single `api-log-spring-boot-starter` artifact is split.** Consumers now add `kr.devslab:api-log-core` plus exactly one backend artifact: `api-log-jpa` (drop-in for v0.5.x), `api-log-r2dbc` (reactive), or `api-log-mybatis`.
+- **Build system: Maven → Gradle 8.10** with Vanniktech maven-publish per module.
+- **Package renames**: `model.dto` → `dto`, `model.ApiLogEntity` → `jpa.model.ApiLogEntity`, `service.ApiLogService` → `jpa.writer.JpaApiLogWriter`. Full mapping in [docs/changelog.md](docs/changelog.md#060--multi-module-split-gradle-pluggable-jpa--r2dbc--mybatis-backends).
+
+### Added
+
+- **`ApiLogWriter` SPI** — backend-agnostic three-method interface (`writeInitiated` / `writeSuccess` / `writeError`). Each backend artifact registers one implementation; the core listener routes events through it.
+- **`api-log-r2dbc`** — reactive backend using R2DBC's `DatabaseClient`. Pure-reactive schema initializer; no JDBC pull-in.
+- **`api-log-mybatis`** — MyBatis mapper backend with `::jsonb` cast on inserts.
+
+### Fixed
+
+- `V1.0__create_api_log.sql` now uses `IF NOT EXISTS` on both CREATE TABLE and CREATE INDEX — idempotent across boots under BUILTIN mode.
+
+Full migration notes in [docs/changelog.md](docs/changelog.md#060--multi-module-split-gradle-pluggable-jpa--r2dbc--mybatis-backends).
+
+## [0.5.2] — Fix bean registration in real consumer apps
+
+### Fixed
+
+- `RestApiClientUtil` + four `@Configuration` classes were never registered in consumer apps (relied on `@ComponentScan` reaching the starter's package). Fixed by splitting into three `@AutoConfiguration` classes registered via `META-INF/spring/.../AutoConfiguration.imports`.
+- `spring-boot-starter-web` is now `true` — pure-WebFlux apps no longer get a Servlet stack forced onto their classpath.
+
+Full notes in [docs/changelog.md](docs/changelog.md#052--fix-bean-registration-in-real-consumer-apps).
+
## [0.5.1] — Reactive (WebFlux) client + end-to-end HTTP tests
### Added
@@ -75,7 +104,9 @@ See [docs/changelog.md](docs/changelog.md#020--schema-management-opt-in) for the
First public release. See [docs/changelog.md](docs/changelog.md#010--initial-release) for details.
-[Unreleased]: https://github.com/devslab-kr/api-log/compare/v0.5.1...HEAD
+[Unreleased]: https://github.com/devslab-kr/api-log/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/devslab-kr/api-log/releases/tag/v0.6.0
+[0.5.2]: https://github.com/devslab-kr/api-log/releases/tag/v0.5.2
[0.5.1]: https://github.com/devslab-kr/api-log/releases/tag/v0.5.1
[0.5.0]: https://github.com/devslab-kr/api-log/releases/tag/v0.5.0
[0.4.0]: https://github.com/devslab-kr/api-log/releases/tag/v0.4.0
diff --git a/README.ko.md b/README.ko.md
index a63d19c..a41ccc4 100644
--- a/README.ko.md
+++ b/README.ko.md
@@ -4,7 +4,7 @@
> Spring Boot용 이벤트 드리븐 API 호출 로깅. 비동기 이벤트 파이프라인 + PostgreSQL JSONB. 요청 경로를 막지 않고 외부 API 호출을 모두 기록합니다.
-[](https://central.sonatype.com/artifact/kr.devslab/api-log-spring-boot-starter)
+[](https://central.sonatype.com/artifact/kr.devslab/api-log-core)
[](https://github.com/devslab-kr/api-log/actions/workflows/ci.yml)
[](https://codecov.io/gh/devslab-kr/api-log)
[](LICENSE)
@@ -57,35 +57,64 @@ public class UserService {
```
Caller code
↓
-RestApiClientUtil (또는 자체 HTTP 클라이언트)
+RestApiClientUtil / ReactiveApiClientUtil (또는 자체 HTTP 클라이언트)
↓ publishEvent
ApplicationEventPublisher
- ↓ @EventListener (async)
-ApiEventListener
- ↓
-ApiLogService
- ↓
-ApiLogRepository (JPA)
- ↓
-PostgreSQL (api_log · JSONB columns)
+ ↓ @EventListener (virtual threads)
+ApiEventListener (api-log-core)
+ ↓ ApiLogWriter (SPI)
+ ├─ JpaApiLogWriter (api-log-jpa)
+ ├─ R2dbcApiLogWriter (api-log-r2dbc)
+ └─ MybatisApiLogWriter (api-log-mybatis)
+ ↓
+ PostgreSQL (api_log · JSONB columns)
```
## 설치
+v0.6.0부터 스타터가 4개 아티팩트로 분리됐습니다 — 백엔드 비종속 코어 1개 +
+영속화 백엔드 1개. **`api-log-core` 1개 + 백엔드 1개**를 직접 골라 추가:
+
+| 좌표 | 언제 쓰나 |
+| --- | --- |
+| `kr.devslab:api-log-jpa` | Servlet / JPA 앱 (v0.5.x 드롭인) |
+| `kr.devslab:api-log-r2dbc` | WebFlux / R2DBC 앱 — JDBC 의존성 없음 |
+| `kr.devslab:api-log-mybatis` | 이미 MyBatis를 쓰고, JPA를 원치 않을 때 |
+
+백엔드 아티팩트 각각이 `api-log-core`를 transitive하게 가져오므로
+좌표 하나만 추가하면 됩니다.
+
### Maven
```xml
+
+
+ kr.devslab
+ api-log-jpa
+ 0.6.0
+
+
+
+
+ kr.devslab
+ api-log-r2dbc
+ 0.6.0
+
+
+
kr.devslab
- api-log-spring-boot-starter
- 0.5.1
+ api-log-mybatis
+ 0.6.0
```
### Gradle
```kotlin
-implementation("kr.devslab:api-log-spring-boot-starter:0.5.1")
+implementation("kr.devslab:api-log-jpa:0.6.0")
+// 또는 "kr.devslab:api-log-r2dbc:0.6.0"
+// 또는 "kr.devslab:api-log-mybatis:0.6.0"
```
## 설정
diff --git a/README.md b/README.md
index 319b446..07cc6c7 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
> Event-driven API call logging for Spring Boot. Async event pipeline with PostgreSQL JSONB storage.
-[](https://central.sonatype.com/artifact/kr.devslab/api-log-spring-boot-starter)
+[](https://central.sonatype.com/artifact/kr.devslab/api-log-core)
[](https://github.com/devslab-kr/api-log/actions/workflows/ci.yml)
[](https://codecov.io/gh/devslab-kr/api-log)
[](LICENSE)
@@ -57,35 +57,65 @@ Bodies are stored as JSONB, so you can query them with `->`, `->>`, and GIN inde
```
Caller code
↓
-RestApiClientUtil (or your own HTTP client)
+RestApiClientUtil / ReactiveApiClientUtil (or your own HTTP client)
↓ publishEvent
ApplicationEventPublisher
- ↓ @EventListener (async)
-ApiEventListener
- ↓
-ApiLogService
- ↓
-ApiLogRepository (JPA)
- ↓
-PostgreSQL (api_log · JSONB columns)
+ ↓ @EventListener (virtual threads)
+ApiEventListener (api-log-core)
+ ↓ ApiLogWriter (SPI)
+ ├─ JpaApiLogWriter (api-log-jpa)
+ ├─ R2dbcApiLogWriter (api-log-r2dbc)
+ └─ MybatisApiLogWriter (api-log-mybatis)
+ ↓
+ PostgreSQL (api_log · JSONB columns)
```
## Installation
+v0.6.0 splits the starter into four artifacts: a backend-agnostic core, plus
+one of three persistence backends. Add **`api-log-core` plus exactly one
+backend** to your build:
+
+| Coordinate | When to use it |
+| --- | --- |
+| `kr.devslab:api-log-jpa` | Servlet / JPA app (the v0.5.x drop-in) |
+| `kr.devslab:api-log-r2dbc` | WebFlux / R2DBC app — no JDBC pull-in |
+| `kr.devslab:api-log-mybatis` | Already on MyBatis, don't want JPA |
+
+Each backend artifact transitively depends on `api-log-core`, so one
+coordinate is enough.
+
### Maven
```xml
+
+
+ kr.devslab
+ api-log-jpa
+ 0.6.0
+
+
+
+
+ kr.devslab
+ api-log-r2dbc
+ 0.6.0
+
+
+
kr.devslab
- api-log-spring-boot-starter
- 0.3.0
+ api-log-mybatis
+ 0.6.0
```
### Gradle
```kotlin
-implementation("kr.devslab:api-log-spring-boot-starter:0.3.0")
+implementation("kr.devslab:api-log-jpa:0.6.0")
+// or "kr.devslab:api-log-r2dbc:0.6.0"
+// or "kr.devslab:api-log-mybatis:0.6.0"
```
## Configuration
diff --git a/build.gradle.kts b/build.gradle.kts
new file mode 100644
index 0000000..2cad94b
--- /dev/null
+++ b/build.gradle.kts
@@ -0,0 +1,18 @@
+// Multi-module orchestration. The root project is not published — each
+// publishable artifact lives under its own subproject (see settings.gradle.kts)
+// and applies the publishing plugin itself.
+//
+// Plugin versions are declared here with `apply false` so subprojects can
+// apply them without repeating version numbers, and so the version drift
+// between modules stays at zero.
+
+plugins {
+ id("org.springframework.boot") version "3.5.6" apply false
+ id("io.spring.dependency-management") version "1.1.6" apply false
+ id("com.vanniktech.maven.publish") version "0.30.0" apply false
+}
+
+allprojects {
+ group = providers.gradleProperty("GROUP").get()
+ version = providers.gradleProperty("VERSION").get()
+}
diff --git a/core/build.gradle.kts b/core/build.gradle.kts
new file mode 100644
index 0000000..ad88614
--- /dev/null
+++ b/core/build.gradle.kts
@@ -0,0 +1,182 @@
+// :core — backend-agnostic foundation for the api-log starter.
+//
+// Published as `kr.devslab:api-log-core`. Holds:
+// - The event objects (ApiCallInitiatedEvent / SuccessEvent / ErrorEvent)
+// - The `ApiLogWriter` SPI that backend modules implement
+// - The async event listener that drives writers off the event bus
+// - The HTTP client utilities (RestApiClientUtil for sync, ReactiveApiClientUtil for reactive)
+// - The shared Jackson customizer (Blackbird), retry config, and properties
+//
+// Backend modules (`:jpa`, `:r2dbc`, `:mybatis`) depend on this and each
+// register exactly one `ApiLogWriter` bean — consumers pick by adding the
+// backend artifact they want.
+
+plugins {
+ `java-library`
+ jacoco
+ id("org.springframework.boot") apply false
+ id("io.spring.dependency-management")
+ id("com.vanniktech.maven.publish")
+}
+
+base {
+ // On-disk jar filename. Vanniktech overrides the *publish* coordinates
+ // separately via `mavenPublishing.coordinates(...)`; this controls only
+ // the local `build/libs/*.jar` name so GitHub Release assets are readable.
+ archivesName.set("api-log-core")
+}
+
+// Vanniktech's javadoc jar task hardcodes its archive base name to
+// `-maven-javadoc` and only sets it inside its plugin's own
+// `afterEvaluate`. Without this override the GitHub Release ends up with a
+// confusing `core-maven-javadoc-X.Y.Z-javadoc.jar` next to the properly named
+// main jar. Configuring inside `afterEvaluate` makes us the last writer.
+afterEvaluate {
+ tasks.named("mavenPlainJavadocJar").configure {
+ archiveBaseName.set("api-log-core")
+ }
+}
+
+java {
+ toolchain {
+ languageVersion.set(JavaLanguageVersion.of(21))
+ }
+}
+
+tasks.withType().configureEach {
+ options.encoding = "UTF-8"
+ // -parameters: keep AOP-readable param names. -Xlint enabled but the noisy
+ // categories (classfile/processing/serial) are excluded so -Werror stays
+ // usable for real code issues without tripping on annotation-processor noise.
+ options.compilerArgs.addAll(listOf(
+ "-parameters",
+ "-Xlint:all,-classfile,-processing,-serial",
+ "-Werror"
+ ))
+}
+
+tasks.withType().configureEach {
+ options.encoding = "UTF-8"
+ (options as StandardJavadocDocletOptions).apply {
+ addBooleanOption("Xdoclint:none", true)
+ addBooleanOption("html5", true)
+ locale = "en_US"
+ }
+}
+
+dependencyManagement {
+ imports {
+ mavenBom("org.springframework.boot:spring-boot-dependencies:3.5.6")
+ }
+}
+
+dependencies {
+ // Pulled in transitively for every consumer of any api-log-* artifact:
+ // spring-context + spring-boot give us @EventListener, @EnableAsync,
+ // ApplicationEventPublisher, @ConditionalOnProperty, etc.
+ api("org.springframework.boot:spring-boot-starter")
+
+ // The listener's @Retryable wraps each persistence attempt — without
+ // spring-retry on the classpath consumers can't use the retry semantics.
+ api("org.springframework.retry:spring-retry")
+ // @Retryable needs Spring AOP at runtime to weave the proxy.
+ api("org.springframework.boot:spring-boot-starter-aop")
+
+ // Events / payloads use Jackson directly (JsonNode in payloads, error JSON).
+ api("com.fasterxml.jackson.core:jackson-databind")
+
+ // Blackbird = ~30-50% Jackson serialization speedup. The Jackson2ObjectMapperBuilderCustomizer
+ // we register installs it into Spring Boot's default ObjectMapper.
+ api("com.fasterxml.jackson.module:jackson-module-blackbird")
+
+ // Lombok — compile + annotation-processor only.
+ compileOnly("org.projectlombok:lombok")
+ annotationProcessor("org.projectlombok:lombok")
+
+ // Auto-configuration metadata processor.
+ annotationProcessor("org.springframework.boot:spring-boot-configuration-processor")
+
+ // HTTP client API surfaces — `compileOnly` because consumers may have
+ // either, both, or neither. The corresponding @AutoConfigurations gate
+ // themselves with @ConditionalOnClass so absence is silent.
+ compileOnly("org.springframework.boot:spring-boot-starter-web")
+ compileOnly("org.springframework:spring-webflux")
+ compileOnly("io.projectreactor.netty:reactor-netty-http")
+
+ // Silences cosmetic "cannot find javax.annotation.Nonnull" warnings from
+ // resolving Spring's @Nullable. Not exposed to consumers.
+ compileOnly("com.google.code.findbugs:jsr305:3.0.2")
+
+ // Test
+ testImplementation("org.springframework.boot:spring-boot-starter-test")
+ testImplementation("org.springframework.boot:spring-boot-starter-web")
+ testImplementation("org.springframework.boot:spring-boot-starter-webflux")
+ testImplementation("io.projectreactor:reactor-test")
+ testImplementation("org.assertj:assertj-core")
+
+ // MockWebServer drives the HTTP-client utils against a real socket.
+ testImplementation("com.squareup.okhttp3:mockwebserver:4.12.0")
+
+ // Explicit launcher pin. JUnit Jupiter 5.11+ requires junit-platform-launcher
+ // >= 1.11; Gradle 8.10 still bundles 1.10.x. Without this declaration the
+ // BOM's 1.11 doesn't make it onto the test runtime classpath.
+ testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+}
+
+tasks.test {
+ useJUnitPlatform()
+ testLogging {
+ events("passed", "skipped", "failed")
+ exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
+ showStandardStreams = false
+ }
+ systemProperty("file.encoding", "UTF-8")
+ finalizedBy(tasks.jacocoTestReport)
+}
+
+jacoco {
+ toolVersion = "0.8.13"
+}
+
+tasks.jacocoTestReport {
+ dependsOn(tasks.test)
+ reports {
+ xml.required.set(true)
+ html.required.set(true)
+ csv.required.set(false)
+ }
+}
+
+mavenPublishing {
+ coordinates(
+ providers.gradleProperty("GROUP").get(),
+ "api-log-core",
+ providers.gradleProperty("VERSION").get()
+ )
+
+ pom {
+ name.set("API Log Spring Boot Starter - Core")
+ description.set("Backend-agnostic core for api-log: events, SPI, async listener, HTTP client utilities. Pair with api-log-jpa / api-log-r2dbc / api-log-mybatis.")
+
+ developers {
+ developer {
+ id.set(providers.gradleProperty("POM_DEVELOPER_ID"))
+ name.set(providers.gradleProperty("POM_DEVELOPER_NAME"))
+ url.set(providers.gradleProperty("POM_DEVELOPER_URL"))
+ email.set(providers.gradleProperty("POM_DEVELOPER_EMAIL"))
+ organization.set(providers.gradleProperty("POM_ORGANIZATION_NAME"))
+ organizationUrl.set(providers.gradleProperty("POM_ORGANIZATION_URL"))
+ }
+ }
+
+ organization {
+ name.set(providers.gradleProperty("POM_ORGANIZATION_NAME"))
+ url.set(providers.gradleProperty("POM_ORGANIZATION_URL"))
+ }
+
+ issueManagement {
+ system.set(providers.gradleProperty("POM_ISSUE_SYSTEM"))
+ url.set(providers.gradleProperty("POM_ISSUE_URL"))
+ }
+ }
+}
diff --git a/core/src/main/java/kr/devslab/apilog/Constants.java b/core/src/main/java/kr/devslab/apilog/Constants.java
new file mode 100644
index 0000000..44b5727
--- /dev/null
+++ b/core/src/main/java/kr/devslab/apilog/Constants.java
@@ -0,0 +1,19 @@
+package kr.devslab.apilog;
+
+/**
+ * Shared string constants for the {@code event_type} column written to
+ * {@code api_log}. Kept as plain string constants (rather than an enum) so
+ * downstream queries — e.g., {@code WHERE event_type = 'SUCCESS'} from a BI
+ * tool — match what the application writes.
+ */
+public final class Constants {
+
+ public static final String INITIATED = "INITIATED";
+ public static final String SUCCESS = "SUCCESS";
+ public static final String RETRY_ERROR = "RETRY_ERROR";
+ public static final String ERROR = "ERROR";
+
+ private Constants() {
+ // utility class — no instances
+ }
+}
diff --git a/src/main/java/kr/devslab/apilog/autoconfigure/ApiLogAutoConfiguration.java b/core/src/main/java/kr/devslab/apilog/autoconfigure/ApiLogCoreAutoConfiguration.java
similarity index 56%
rename from src/main/java/kr/devslab/apilog/autoconfigure/ApiLogAutoConfiguration.java
rename to core/src/main/java/kr/devslab/apilog/autoconfigure/ApiLogCoreAutoConfiguration.java
index 5c4ee4f..8b24a73 100644
--- a/src/main/java/kr/devslab/apilog/autoconfigure/ApiLogAutoConfiguration.java
+++ b/core/src/main/java/kr/devslab/apilog/autoconfigure/ApiLogCoreAutoConfiguration.java
@@ -2,85 +2,85 @@
import kr.devslab.apilog.config.RetryConfig;
import kr.devslab.apilog.listener.ApiEventListener;
-import kr.devslab.apilog.repository.ApiLogRepository;
-import kr.devslab.apilog.service.ApiLogService;
+import kr.devslab.apilog.spi.ApiLogWriter;
+import kr.devslab.apilog.spi.PayloadJsonMapper;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.module.blackbird.BlackbirdModule;
import org.springframework.boot.autoconfigure.AutoConfiguration;
-import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
+import org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
-import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.core.task.TaskExecutor;
import org.springframework.core.task.VirtualThreadTaskExecutor;
-import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
-import javax.sql.DataSource;
-
/**
- * Core auto-configuration — always loads when the starter is on the classpath.
+ * Backend-agnostic core auto-configuration. Loads whenever the starter is on
+ * the classpath; registers everything that doesn't depend on a persistence
+ * backend.
*
- *
Wires the event pipeline (service, listener), schema initializer, async
- * executor, and a BlackbirdModule-equipped {@link ObjectMapper}. Does not
- * register either HTTP client — those live in
- * {@link RestApiClientAutoConfiguration} (Web/Servlet) and
- * {@link ReactiveApiClientAutoConfiguration} (WebFlux), each gated by
- * {@code @ConditionalOnClass} so consumers only pay for what's on their
- * classpath.
+ *
Wires the async event listener, the {@link PayloadJsonMapper} helper, the
+ * Blackbird-enabled Jackson customizer, the retry config, and a virtual-thread
+ * / platform-thread executor for the listener.
+ *
+ *
The actual {@link ApiLogWriter} bean comes from whichever backend module
+ * the consumer added — {@code api-log-jpa}, {@code api-log-r2dbc}, or
+ * {@code api-log-mybatis}. {@link ApiEventListener} just declares
+ * {@code ApiLogWriter} as a constructor parameter so Spring DI resolves the
+ * backend writer lazily; if no backend is on the classpath, the context fails
+ * fast at startup with a clear {@code NoSuchBeanDefinitionException}.
+ *
+ *
{@code after = JacksonAutoConfiguration.class} guarantees Spring Boot's
+ * {@code ObjectMapper} is registered before this class is evaluated, so the
+ * {@code PayloadJsonMapper} bean can take it as a parameter without timing
+ * games. Backend auto-configs declare {@code after = ApiLogCoreAutoConfiguration.class}
+ * to chain the ordering further.
*/
-@AutoConfiguration
-@ConditionalOnClass({ApiEventListener.class, ApiLogService.class})
+@AutoConfiguration(after = JacksonAutoConfiguration.class)
+@ConditionalOnClass({ApiEventListener.class, ApiLogWriter.class})
@EnableConfigurationProperties(ApiLogProperties.class)
@ConditionalOnProperty(name = "api.log.enabled", havingValue = "true", matchIfMissing = true)
-@EntityScan(basePackages = "kr.devslab.apilog.model")
-@EnableJpaRepositories(basePackages = "kr.devslab.apilog.repository")
-@Import({RetryConfig.class, ApiLogFlywayConfig.class})
+@Import(RetryConfig.class)
@EnableAsync
-public class ApiLogAutoConfiguration {
-
- @Bean
- @ConditionalOnMissingBean
- @ConditionalOnBean(ObjectMapper.class)
- public ApiLogService apiLogService(ApiLogRepository repository, ObjectMapper objectMapper) {
- return new ApiLogService(repository, objectMapper);
- }
+public class ApiLogCoreAutoConfiguration {
+ /**
+ * Shared JSON helper used by every backend writer. Lifted out of the old
+ * {@code ApiLogService} so backend modules don't each re-implement it.
+ *
+ *
{@code ObjectMapper} comes from Spring Boot's
+ * {@code JacksonAutoConfiguration} (we run after it via the
+ * {@code @AutoConfiguration(after = ...)} hint on the class).
+ */
@Bean
@ConditionalOnMissingBean
- @ConditionalOnBean(ApiLogService.class)
- public ApiEventListener apiEventListener(ApiLogService apiLogService) {
- return new ApiEventListener(apiLogService);
+ public PayloadJsonMapper apiLogPayloadJsonMapper(ObjectMapper objectMapper) {
+ return new PayloadJsonMapper(objectMapper);
}
/**
- * Creates the api_log table at startup when the consumer hasn't picked a
- * different management strategy (the default — BUILTIN). The CREATE TABLE
- * statements use IF NOT EXISTS, so this is idempotent and safe to re-run
- * on every boot.
+ * Event-bus listener that routes events to the consumer's chosen
+ * {@link ApiLogWriter}. Spring DI resolves the writer lazily — if no
+ * backend artifact is present the application context fails fast at
+ * startup with {@code NoSuchBeanDefinitionException}, which is more
+ * actionable than silently dropping events.
*/
@Bean
@ConditionalOnMissingBean
- @ConditionalOnProperty(
- prefix = "api.log.schema",
- name = "management",
- havingValue = "builtin",
- matchIfMissing = true
- )
- public ApiLogSchemaInitializer apiLogSchemaInitializer(DataSource dataSource) {
- return new ApiLogSchemaInitializer(dataSource);
+ public ApiEventListener apiEventListener(ApiLogWriter writer) {
+ return new ApiEventListener(writer);
}
/**
* Adds the Blackbird module to Spring Boot's auto-configured
* {@code ObjectMapper} — ~30-50% Jackson serialization speedup, which
- * matters because every API call writes JSONB payloads to {@code api_log}.
+ * matters because every API call writes JSON payloads to {@code api_log}.
*
*
Using {@link Jackson2ObjectMapperBuilderCustomizer} (rather than
* defining our own {@code @Primary ObjectMapper} bean) keeps Spring Boot's
diff --git a/core/src/main/java/kr/devslab/apilog/autoconfigure/ApiLogProperties.java b/core/src/main/java/kr/devslab/apilog/autoconfigure/ApiLogProperties.java
new file mode 100644
index 0000000..8a5e32a
--- /dev/null
+++ b/core/src/main/java/kr/devslab/apilog/autoconfigure/ApiLogProperties.java
@@ -0,0 +1,87 @@
+package kr.devslab.apilog.autoconfigure;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+/**
+ * Top-level configuration namespace for the api-log starter.
+ *
+ *
v0.6.0 — the {@code schema.management} property still applies to the
+ * JPA / MyBatis backends (both run a JDBC initializer). The R2DBC backend has
+ * its own toggle ({@code api.log.r2dbc.schema.enabled}) because reactive
+ * initialization runs against a {@code ConnectionFactory} rather than a
+ * {@code DataSource}.
+ */
+@ConfigurationProperties(prefix = "api.log")
+public class ApiLogProperties {
+
+ /**
+ * Master switch — when false no api-log beans are registered (listener,
+ * writer, schema initializer, HTTP utilities). Default: true.
+ */
+ private boolean enabled = true;
+
+ /**
+ * How the {@code api_log} table's schema is provisioned. See {@link Schema}.
+ * Applies to the JPA + MyBatis backends. The R2DBC backend uses its own
+ * reactive initializer keyed off {@code api.log.r2dbc.schema.enabled}.
+ */
+ private Schema schema = new Schema();
+
+ public boolean isEnabled() {
+ return enabled;
+ }
+
+ public void setEnabled(boolean enabled) {
+ this.enabled = enabled;
+ }
+
+ public Schema getSchema() {
+ return schema;
+ }
+
+ public void setSchema(Schema schema) {
+ this.schema = schema;
+ }
+
+ public static class Schema {
+ /**
+ * Schema management strategy for the {@code api_log} table.
+ *
+ *
+ *
BUILTIN (default) — the starter runs the bundled DDL on
+ * application startup. The SQL uses {@code IF NOT EXISTS}, so it's
+ * idempotent and safe to leave on every boot.
+ * Use this if you don't have (or don't want) Flyway / Liquibase
+ * in your project.
+ *
NONE — the starter does not touch the schema. Apply the
+ * DDL yourself (see api-log.devslab.kr/reference/schema).
+ * Use this if your team's policy is that third-party libraries
+ * must never touch the schema.
+ *
FLYWAY — the starter registers a
+ * {@code FlywayConfigurationCustomizer} that appends
+ * {@code classpath:db/api-log} to Flyway's locations, so the
+ * bundled {@code V1.0__create_api_log.sql} runs alongside your
+ * own migrations and gets recorded in
+ * {@code flyway_schema_history}. Requires
+ * {@code org.flywaydb:flyway-core} on the classpath (the starter
+ * declares it as optional, so the consumer must add it). Only
+ * applies when the JPA backend is in use.
+ *
+ */
+ private Management management = Management.BUILTIN;
+
+ public Management getManagement() {
+ return management;
+ }
+
+ public void setManagement(Management management) {
+ this.management = management;
+ }
+
+ public enum Management {
+ BUILTIN,
+ NONE,
+ FLYWAY
+ }
+ }
+}
diff --git a/src/main/java/kr/devslab/apilog/autoconfigure/ReactiveApiClientAutoConfiguration.java b/core/src/main/java/kr/devslab/apilog/autoconfigure/ReactiveApiClientAutoConfiguration.java
similarity index 96%
rename from src/main/java/kr/devslab/apilog/autoconfigure/ReactiveApiClientAutoConfiguration.java
rename to core/src/main/java/kr/devslab/apilog/autoconfigure/ReactiveApiClientAutoConfiguration.java
index 294be63..d20a6a6 100644
--- a/src/main/java/kr/devslab/apilog/autoconfigure/ReactiveApiClientAutoConfiguration.java
+++ b/core/src/main/java/kr/devslab/apilog/autoconfigure/ReactiveApiClientAutoConfiguration.java
@@ -22,7 +22,7 @@
* codecs, etc.) flow through. Provide your own {@link ReactiveApiClientUtil}
* bean to fully replace the wiring.
*/
-@AutoConfiguration(after = ApiLogAutoConfiguration.class)
+@AutoConfiguration(after = ApiLogCoreAutoConfiguration.class)
@ConditionalOnClass(WebClient.class)
@ConditionalOnProperty(name = "api.log.enabled", havingValue = "true", matchIfMissing = true)
public class ReactiveApiClientAutoConfiguration {
diff --git a/src/main/java/kr/devslab/apilog/autoconfigure/RestApiClientAutoConfiguration.java b/core/src/main/java/kr/devslab/apilog/autoconfigure/RestApiClientAutoConfiguration.java
similarity index 94%
rename from src/main/java/kr/devslab/apilog/autoconfigure/RestApiClientAutoConfiguration.java
rename to core/src/main/java/kr/devslab/apilog/autoconfigure/RestApiClientAutoConfiguration.java
index 2eeb00c..4866396 100644
--- a/src/main/java/kr/devslab/apilog/autoconfigure/RestApiClientAutoConfiguration.java
+++ b/core/src/main/java/kr/devslab/apilog/autoconfigure/RestApiClientAutoConfiguration.java
@@ -28,8 +28,8 @@
*
*
{@link ClientHttpRequestFactory} with configurable timeouts
* ({@code rest.client.connect-timeout}, {@code rest.client.read-timeout})
- *
{@link MappingJackson2HttpMessageConverter} using the core
- * {@code apiLogObjectMapper} (Blackbird-enabled)
+ *
{@link MappingJackson2HttpMessageConverter} using the Spring Boot
+ * {@link ObjectMapper} (Blackbird-enabled by the core customizer)
*
{@link RestClient} with the converter wired in, optional base URL via
* {@code rest.client.base-url}
*
{@link RestApiClientUtil} — the actual API surface consumers inject
@@ -38,7 +38,7 @@
*
Each bean is {@link ConditionalOnMissingBean} so the consumer can swap any
* piece (e.g., provide their own {@code RestClient} with auth headers).
*/
-@AutoConfiguration(after = ApiLogAutoConfiguration.class)
+@AutoConfiguration(after = ApiLogCoreAutoConfiguration.class)
@ConditionalOnClass(RestClient.class)
@ConditionalOnProperty(name = "api.log.enabled", havingValue = "true", matchIfMissing = true)
public class RestApiClientAutoConfiguration {
diff --git a/src/main/java/kr/devslab/apilog/config/RetryConfig.java b/core/src/main/java/kr/devslab/apilog/config/RetryConfig.java
similarity index 69%
rename from src/main/java/kr/devslab/apilog/config/RetryConfig.java
rename to core/src/main/java/kr/devslab/apilog/config/RetryConfig.java
index 949cbaf..2f83845 100644
--- a/src/main/java/kr/devslab/apilog/config/RetryConfig.java
+++ b/core/src/main/java/kr/devslab/apilog/config/RetryConfig.java
@@ -1,9 +1,9 @@
package kr.devslab.apilog.config;
+import kr.devslab.apilog.dto.ApiRequest;
import kr.devslab.apilog.event.ApiCallErrorEvent;
import kr.devslab.apilog.event.ApiCallInitiatedEvent;
import kr.devslab.apilog.event.ApiCallSuccessEvent;
-import kr.devslab.apilog.model.dto.ApiRequest;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@@ -12,6 +12,15 @@
import org.springframework.retry.RetryListener;
import org.springframework.retry.annotation.EnableRetry;
+/**
+ * Enables Spring Retry across the api-log starter and registers a
+ * {@link RetryListener} that re-publishes a {@link ApiCallErrorEvent} marked
+ * {@code isRetry=true} on every failed attempt past the first, so each retry
+ * is recorded as its own {@code RETRY_ERROR} row in {@code api_log}.
+ *
+ *
Imported by {@code ApiLogCoreAutoConfiguration} so consumers don't need to
+ * declare {@code @EnableRetry} on their own {@code @SpringBootApplication}.
+ */
@Configuration
@EnableRetry
public class RetryConfig {
@@ -30,7 +39,7 @@ public boolean open(RetryContext context, RetryCallback
@Override
public void onSuccess(RetryContext context, RetryCallback callback, T result) {
- // 성공 시 추가 작업 없음
+ // no-op
}
@Override
@@ -46,19 +55,19 @@ public void onError(RetryContext context, RetryCallback
@Override
public void close(RetryContext context, RetryCallback callback, Throwable throwable) {
- // 종료 시 추가 작업 없음
+ // no-op
}
private ApiRequest extractRequest(Object event) {
- if (event instanceof ApiCallInitiatedEvent) {
- return ((ApiCallInitiatedEvent) event).getRequest();
- } else if (event instanceof ApiCallSuccessEvent) {
- return ((ApiCallSuccessEvent) event).getRequest();
- } else if (event instanceof ApiCallErrorEvent) {
- return ((ApiCallErrorEvent) event).getRequest();
+ if (event instanceof ApiCallInitiatedEvent initiated) {
+ return initiated.getRequest();
+ } else if (event instanceof ApiCallSuccessEvent success) {
+ return success.getRequest();
+ } else if (event instanceof ApiCallErrorEvent error) {
+ return error.getRequest();
}
return null;
}
};
}
-}
\ No newline at end of file
+}
diff --git a/core/src/main/java/kr/devslab/apilog/dto/ApiRequest.java b/core/src/main/java/kr/devslab/apilog/dto/ApiRequest.java
new file mode 100644
index 0000000..b5c2a71
--- /dev/null
+++ b/core/src/main/java/kr/devslab/apilog/dto/ApiRequest.java
@@ -0,0 +1,27 @@
+package kr.devslab.apilog.dto;
+
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.UUID;
+
+/**
+ * Caller-supplied request descriptor handed to the HTTP client utilities and
+ * carried across the event pipeline.
+ *
+ *
{@code requestId} defaults to a fresh UUID so each call has a unique
+ * correlation key in {@code api_log}. Override it when multiple calls form a
+ * logical group (e.g., a retry sequence) and you want them to share an id.
+ *
+ *
v0.6.0 note — moved from {@code kr.devslab.apilog.model.dto} as part of
+ * the multi-module split (the {@code model/} package now belongs to the
+ * backend modules, which carry their own entity types).
+ */
+@Getter
+@Builder
+public class ApiRequest {
+ @Builder.Default
+ private final String requestId = UUID.randomUUID().toString();
+ private final String payload;
+ private final String endpoint;
+}
diff --git a/core/src/main/java/kr/devslab/apilog/dto/ApiResponse.java b/core/src/main/java/kr/devslab/apilog/dto/ApiResponse.java
new file mode 100644
index 0000000..219b9c7
--- /dev/null
+++ b/core/src/main/java/kr/devslab/apilog/dto/ApiResponse.java
@@ -0,0 +1,16 @@
+package kr.devslab.apilog.dto;
+
+import lombok.Builder;
+import lombok.Getter;
+
+/**
+ * Wrapper for the response body + HTTP status code emitted by the HTTP client
+ * utilities. Stored verbatim in {@code api_log.response} (body) +
+ * {@code api_log.status_code} on success.
+ */
+@Getter
+@Builder
+public class ApiResponse {
+ private final String data;
+ private final int statusCode;
+}
diff --git a/src/main/java/kr/devslab/apilog/event/ApiCallErrorEvent.java b/core/src/main/java/kr/devslab/apilog/event/ApiCallErrorEvent.java
similarity index 67%
rename from src/main/java/kr/devslab/apilog/event/ApiCallErrorEvent.java
rename to core/src/main/java/kr/devslab/apilog/event/ApiCallErrorEvent.java
index e5d122d..6f18385 100644
--- a/src/main/java/kr/devslab/apilog/event/ApiCallErrorEvent.java
+++ b/core/src/main/java/kr/devslab/apilog/event/ApiCallErrorEvent.java
@@ -1,11 +1,19 @@
package kr.devslab.apilog.event;
-import kr.devslab.apilog.model.dto.ApiRequest;
+import kr.devslab.apilog.dto.ApiRequest;
import lombok.Getter;
import org.springframework.context.ApplicationEvent;
import java.time.LocalDateTime;
+/**
+ * Fired when an HTTP call fails (exception thrown by RestClient / WebClient,
+ * or a non-2xx response surfaced as an exception).
+ *
+ *
{@code retryCount} + {@code isRetry} let downstream consumers distinguish
+ * a first-attempt failure ({@code ERROR}) from a retry failure
+ * ({@code RETRY_ERROR}).
+ */
@Getter
public class ApiCallErrorEvent extends ApplicationEvent {
private final ApiRequest request;
@@ -22,4 +30,4 @@ public ApiCallErrorEvent(Object source, ApiRequest request, Throwable error, int
this.retryCount = retryCount;
this.isRetry = isRetry;
}
-}
\ No newline at end of file
+}
diff --git a/src/main/java/kr/devslab/apilog/event/ApiCallInitiatedEvent.java b/core/src/main/java/kr/devslab/apilog/event/ApiCallInitiatedEvent.java
similarity index 68%
rename from src/main/java/kr/devslab/apilog/event/ApiCallInitiatedEvent.java
rename to core/src/main/java/kr/devslab/apilog/event/ApiCallInitiatedEvent.java
index a6755f3..c4b819a 100644
--- a/src/main/java/kr/devslab/apilog/event/ApiCallInitiatedEvent.java
+++ b/core/src/main/java/kr/devslab/apilog/event/ApiCallInitiatedEvent.java
@@ -1,12 +1,16 @@
package kr.devslab.apilog.event;
-import kr.devslab.apilog.model.dto.ApiRequest;
+import kr.devslab.apilog.dto.ApiRequest;
import lombok.Getter;
-import lombok.Setter;
import org.springframework.context.ApplicationEvent;
import java.time.LocalDateTime;
+/**
+ * Fired just before an outbound HTTP call leaves the client. The listener
+ * persists an {@code INITIATED} row so the call is traceable even if the
+ * response never arrives.
+ */
@Getter
public class ApiCallInitiatedEvent extends ApplicationEvent {
private final ApiRequest request;
@@ -18,4 +22,4 @@ public ApiCallInitiatedEvent(Object source, ApiRequest request) {
this.eventTimestamp = LocalDateTime.now();
}
-}
\ No newline at end of file
+}
diff --git a/src/main/java/kr/devslab/apilog/event/ApiCallSuccessEvent.java b/core/src/main/java/kr/devslab/apilog/event/ApiCallSuccessEvent.java
similarity index 71%
rename from src/main/java/kr/devslab/apilog/event/ApiCallSuccessEvent.java
rename to core/src/main/java/kr/devslab/apilog/event/ApiCallSuccessEvent.java
index 5fdea28..3120706 100644
--- a/src/main/java/kr/devslab/apilog/event/ApiCallSuccessEvent.java
+++ b/core/src/main/java/kr/devslab/apilog/event/ApiCallSuccessEvent.java
@@ -1,12 +1,16 @@
package kr.devslab.apilog.event;
-import kr.devslab.apilog.model.dto.ApiRequest;
-import kr.devslab.apilog.model.dto.ApiResponse;
+import kr.devslab.apilog.dto.ApiRequest;
+import kr.devslab.apilog.dto.ApiResponse;
import lombok.Getter;
import org.springframework.context.ApplicationEvent;
import java.time.LocalDateTime;
+/**
+ * Fired after a successful (2xx) HTTP response. The listener persists a
+ * {@code SUCCESS} row carrying the response body + status code.
+ */
@Getter
public class ApiCallSuccessEvent extends ApplicationEvent {
private final ApiRequest request;
@@ -20,4 +24,4 @@ public ApiCallSuccessEvent(Object source, ApiRequest request, ApiResponse respon
this.eventTimestamp = LocalDateTime.now();
}
-}
\ No newline at end of file
+}
diff --git a/src/main/java/kr/devslab/apilog/listener/ApiEventListener.java b/core/src/main/java/kr/devslab/apilog/listener/ApiEventListener.java
similarity index 55%
rename from src/main/java/kr/devslab/apilog/listener/ApiEventListener.java
rename to core/src/main/java/kr/devslab/apilog/listener/ApiEventListener.java
index 2220e04..9db2cfe 100644
--- a/src/main/java/kr/devslab/apilog/listener/ApiEventListener.java
+++ b/core/src/main/java/kr/devslab/apilog/listener/ApiEventListener.java
@@ -3,28 +3,54 @@
import kr.devslab.apilog.event.ApiCallErrorEvent;
import kr.devslab.apilog.event.ApiCallInitiatedEvent;
import kr.devslab.apilog.event.ApiCallSuccessEvent;
-import kr.devslab.apilog.service.ApiLogService;
+import kr.devslab.apilog.spi.ApiLogWriter;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.event.EventListener;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Retryable;
-import org.springframework.stereotype.Component;
-import org.springframework.transaction.annotation.Propagation;
-import org.springframework.transaction.annotation.Transactional;
+import org.springframework.scheduling.annotation.Async;
+/**
+ * Drives the {@link ApiLogWriter} off the application event bus.
+ *
+ *
v0.6.0 change — this used to call {@code ApiLogService} directly (JPA-only).
+ * It now talks to whichever {@link ApiLogWriter} the consumer's chosen backend
+ * registered ({@code api-log-jpa} → JpaApiLogWriter,
+ * {@code api-log-r2dbc} → R2dbcApiLogWriter,
+ * {@code api-log-mybatis} → MybatisApiLogWriter). The listener stays
+ * backend-agnostic; routing happens by which jar is on the classpath.
+ *
+ *
{@code @Async} so the persistence hop runs on the executor configured in
+ * {@code :core} (virtual-thread by default, platform-thread pool as fallback)
+ * — the HTTP caller never waits for a {@code api_log} write. The R2DBC writer
+ * also bridges its reactive {@code Mono} to a blocking call inside this
+ * executor thread; nothing on the request path blocks.
+ *
+ *
{@code @Retryable} wraps each write in up to three attempts with 1s
+ * backoff so transient persistence failures (connection blips, dead pool
+ * connection on first use) don't drop a log row. Caught exceptions are logged,
+ * never rethrown — losing one {@code api_log} row must never break the actual
+ * outbound API call.
+ *
+ *
Transaction semantics are intentionally not declared here. The JPA
+ * + MyBatis writers wrap their own writes in {@code REQUIRES_NEW} (so the log
+ * write doesn't pollute the consumer's surrounding tx). The R2DBC writer
+ * relies on the driver's auto-commit. Keeping the tx boundary inside the
+ * writer lets each backend pick the semantics that make sense.
+ */
@Slf4j
-@Component
@RequiredArgsConstructor
public class ApiEventListener {
- private final ApiLogService apiLogService;
+
+ private final ApiLogWriter writer;
@EventListener
- @Transactional(propagation = Propagation.REQUIRES_NEW)
+ @Async
@Retryable(maxAttempts = 3, backoff = @Backoff(delay = 1000))
public void handleApiCallInitiated(ApiCallInitiatedEvent event) {
try {
- apiLogService.saveApiCallInitiated(event);
+ writer.writeInitiated(event);
log.debug("Saved API Call Initiated: RequestId={}, Endpoint={}",
event.getRequest().getRequestId(), event.getRequest().getEndpoint());
} catch (Exception e) {
@@ -34,11 +60,11 @@ public void handleApiCallInitiated(ApiCallInitiatedEvent event) {
}
@EventListener
- @Transactional(propagation = Propagation.REQUIRES_NEW)
+ @Async
@Retryable(maxAttempts = 3, backoff = @Backoff(delay = 1000))
public void handleApiCallSuccess(ApiCallSuccessEvent event) {
try {
- apiLogService.saveApiCallSuccess(event);
+ writer.writeSuccess(event);
log.debug("Saved API Call Success: RequestId={}, Endpoint={}, Status={}",
event.getRequest().getRequestId(), event.getRequest().getEndpoint(),
event.getResponse().getStatusCode());
@@ -49,11 +75,11 @@ public void handleApiCallSuccess(ApiCallSuccessEvent event) {
}
@EventListener
- @Transactional(propagation = Propagation.REQUIRES_NEW)
+ @Async
@Retryable(maxAttempts = 3, backoff = @Backoff(delay = 1000))
public void handleApiCallError(ApiCallErrorEvent event) {
try {
- apiLogService.saveApiCallError(event);
+ writer.writeError(event);
log.info("Saved API Call {}: RequestId={}, Endpoint={}, RetryCount={}",
event.isRetry() ? "Retry Error" : "Error",
event.getRequest().getRequestId(), event.getRequest().getEndpoint(),
@@ -64,4 +90,4 @@ public void handleApiCallError(ApiCallErrorEvent event) {
event.getRequest().getRequestId(), e.getMessage(), e);
}
}
-}
\ No newline at end of file
+}
diff --git a/core/src/main/java/kr/devslab/apilog/spi/ApiLogWriter.java b/core/src/main/java/kr/devslab/apilog/spi/ApiLogWriter.java
new file mode 100644
index 0000000..c744e38
--- /dev/null
+++ b/core/src/main/java/kr/devslab/apilog/spi/ApiLogWriter.java
@@ -0,0 +1,40 @@
+package kr.devslab.apilog.spi;
+
+import kr.devslab.apilog.event.ApiCallErrorEvent;
+import kr.devslab.apilog.event.ApiCallInitiatedEvent;
+import kr.devslab.apilog.event.ApiCallSuccessEvent;
+
+/**
+ * Backend-agnostic SPI that each {@code api-log-*} persistence module implements.
+ *
+ *
One {@code ApiLogWriter} bean is expected per application context — provided
+ * by the backend artifact the consumer chose (see {@code api-log-jpa},
+ * {@code api-log-r2dbc}, {@code api-log-mybatis}). The core listener
+ * ({@code ApiEventListener}) routes every event through the registered writer
+ * so the wire format (events) stays backend-independent.
+ *
+ *
Append-only semantics. Every call writes a new row keyed by an
+ * auto-generated {@code id}. The same {@code request_id} can show up multiple
+ * times — once for {@code INITIATED}, once for {@code SUCCESS} or {@code ERROR},
+ * and once per {@code RETRY_ERROR} — because the table is a chronological log,
+ * not a state machine.
+ *
+ *
Threading. Calls arrive on the executor configured in {@code :core}
+ * (virtual threads by default; falls back to a platform thread pool). Reactive
+ * implementations may subscribe inline — the listener does not consume any
+ * returned reactive type, so writers own their own subscription lifecycle.
+ */
+public interface ApiLogWriter {
+
+ /** Persist an {@code INITIATED} row when a request leaves the client. */
+ void writeInitiated(ApiCallInitiatedEvent event);
+
+ /** Persist a {@code SUCCESS} row when a 2xx response arrives. */
+ void writeSuccess(ApiCallSuccessEvent event);
+
+ /**
+ * Persist an {@code ERROR} or {@code RETRY_ERROR} row when the call fails.
+ * The {@code event_type} is selected from {@link ApiCallErrorEvent#isRetry()}.
+ */
+ void writeError(ApiCallErrorEvent event);
+}
diff --git a/core/src/main/java/kr/devslab/apilog/spi/HttpErrorExtractor.java b/core/src/main/java/kr/devslab/apilog/spi/HttpErrorExtractor.java
new file mode 100644
index 0000000..cfcd0a3
--- /dev/null
+++ b/core/src/main/java/kr/devslab/apilog/spi/HttpErrorExtractor.java
@@ -0,0 +1,51 @@
+package kr.devslab.apilog.spi;
+
+import org.springframework.web.client.HttpStatusCodeException;
+import org.springframework.web.client.RestClientResponseException;
+
+/**
+ * Pulls HTTP status + response body off a thrown exception so backend writers
+ * can record them into {@code api_log.status_code} / {@code api_log.error_message}.
+ *
+ *
Direct {@code instanceof} works for the Spring Web (blocking) hierarchy —
+ * we depend on {@code spring-web} via {@code compileOnly}, so the symbols
+ * resolve when consumers have it on their classpath. For Spring WebFlux's
+ * {@link RestClientResponseException} cousins ({@code WebClientResponseException}
+ * and its concrete subclasses), we duck-type via reflection because
+ * {@code spring-webflux} is also optional and we don't want to force its
+ * classpath presence just to identify it.
+ *
+ *
Used by every backend writer ({@code JpaApiLogWriter},
+ * {@code R2dbcApiLogWriter}, {@code MybatisApiLogWriter}). Kept stateless +
+ * thread-safe so it can be invoked from any async/reactive context.
+ */
+public final class HttpErrorExtractor {
+
+ private HttpErrorExtractor() {
+ // utility class — no instances
+ }
+
+ public static HttpErrorInfo extract(Throwable error) {
+ if (error instanceof HttpStatusCodeException ex) {
+ return new HttpErrorInfo(ex.getStatusCode().value(), ex.getResponseBodyAsString());
+ }
+ if (error instanceof RestClientResponseException ex) {
+ return new HttpErrorInfo(ex.getStatusCode().value(), ex.getResponseBodyAsString());
+ }
+ // Match WebClientResponseException + its concrete subclasses
+ // (NotFound, BadRequest, etc.) by package prefix so unrelated
+ // exceptions that happen to share method names don't get matched.
+ if (error.getClass().getName()
+ .startsWith("org.springframework.web.reactive.function.client.WebClientResponseException")) {
+ try {
+ Object status = error.getClass().getMethod("getStatusCode").invoke(error);
+ Integer statusValue = (Integer) status.getClass().getMethod("value").invoke(status);
+ Object body = error.getClass().getMethod("getResponseBodyAsString").invoke(error);
+ return new HttpErrorInfo(statusValue, body == null ? null : body.toString());
+ } catch (ReflectiveOperationException ignored) {
+ // Shape didn't match — fall through to EMPTY.
+ }
+ }
+ return HttpErrorInfo.EMPTY;
+ }
+}
diff --git a/core/src/main/java/kr/devslab/apilog/spi/HttpErrorInfo.java b/core/src/main/java/kr/devslab/apilog/spi/HttpErrorInfo.java
new file mode 100644
index 0000000..a291581
--- /dev/null
+++ b/core/src/main/java/kr/devslab/apilog/spi/HttpErrorInfo.java
@@ -0,0 +1,12 @@
+package kr.devslab.apilog.spi;
+
+/**
+ * HTTP error metadata pulled off a thrown exception by {@link HttpErrorExtractor}.
+ * Both fields may be {@code null} when the exception isn't an HTTP error
+ * carrier (e.g., a timeout or network error before the response landed).
+ */
+public record HttpErrorInfo(Integer statusCode, String responseBody) {
+
+ /** Sentinel for the no-HTTP-context case — avoids spraying null checks at call sites. */
+ public static final HttpErrorInfo EMPTY = new HttpErrorInfo(null, null);
+}
diff --git a/core/src/main/java/kr/devslab/apilog/spi/PayloadJsonMapper.java b/core/src/main/java/kr/devslab/apilog/spi/PayloadJsonMapper.java
new file mode 100644
index 0000000..99c5d62
--- /dev/null
+++ b/core/src/main/java/kr/devslab/apilog/spi/PayloadJsonMapper.java
@@ -0,0 +1,80 @@
+package kr.devslab.apilog.spi;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/**
+ * Shared JSON conversion used by every backend writer when building rows for
+ * the {@code payload} / {@code response} / {@code error_message} JSONB columns.
+ *
+ *
The two methods cover the two patterns every writer needs:
+ *
+ *
{@link #toJsonNode(String)} — turn a string body into a {@code JsonNode}.
+ * Falls back to {@code { "raw": "..." }} when parsing fails so non-JSON
+ * payloads still land in the column intact.
+ * The {@code responseBody} field only appears when {@link HttpErrorExtractor}
+ * found one — saves a few bytes per row for non-HTTP failures.
+ *
+ */
+public final class PayloadJsonMapper {
+
+ private final ObjectMapper objectMapper;
+
+ public PayloadJsonMapper(ObjectMapper objectMapper) {
+ this.objectMapper = objectMapper;
+ }
+
+ public JsonNode toJsonNode(String data) {
+ if (data == null) {
+ return objectMapper.createObjectNode();
+ }
+ try {
+ return objectMapper.readTree(data);
+ } catch (Exception e) {
+ ObjectNode node = objectMapper.createObjectNode();
+ node.put("raw", data);
+ return node;
+ }
+ }
+
+ public JsonNode buildErrorJson(Throwable error, String responseBody) {
+ ObjectNode node = objectMapper.createObjectNode();
+ node.put("type", error.getClass().getName());
+ node.put("message", error.getMessage());
+ if (responseBody != null && !responseBody.isEmpty()) {
+ node.put("responseBody", responseBody);
+ }
+ return node;
+ }
+
+ /**
+ * String form of {@link #toJsonNode(String)} — JSON canonical form for
+ * backends (R2DBC, MyBatis) that store the column as text rather than as
+ * Jackson's {@code JsonNode}.
+ */
+ public String toJsonString(String data) {
+ try {
+ return objectMapper.writeValueAsString(toJsonNode(data));
+ } catch (Exception e) {
+ // Should be impossible — toJsonNode always returns a valid JsonNode
+ // and ObjectMapper.writeValueAsString of one can't throw a parse error.
+ // Wrap as RuntimeException so the call site doesn't need to declare.
+ throw new IllegalStateException("Failed to serialize JsonNode to String", e);
+ }
+ }
+
+ /**
+ * Convenience for backends that store {@code error_message} as JSON text.
+ */
+ public String buildErrorJsonString(Throwable error, String responseBody) {
+ try {
+ return objectMapper.writeValueAsString(buildErrorJson(error, responseBody));
+ } catch (Exception e) {
+ throw new IllegalStateException("Failed to serialize error JsonNode to String", e);
+ }
+ }
+}
diff --git a/src/main/java/kr/devslab/apilog/util/ReactiveApiClientUtil.java b/core/src/main/java/kr/devslab/apilog/util/ReactiveApiClientUtil.java
similarity index 95%
rename from src/main/java/kr/devslab/apilog/util/ReactiveApiClientUtil.java
rename to core/src/main/java/kr/devslab/apilog/util/ReactiveApiClientUtil.java
index c99977e..37e5f5c 100644
--- a/src/main/java/kr/devslab/apilog/util/ReactiveApiClientUtil.java
+++ b/core/src/main/java/kr/devslab/apilog/util/ReactiveApiClientUtil.java
@@ -1,10 +1,10 @@
package kr.devslab.apilog.util;
+import kr.devslab.apilog.dto.ApiRequest;
+import kr.devslab.apilog.dto.ApiResponse;
import kr.devslab.apilog.event.ApiCallErrorEvent;
import kr.devslab.apilog.event.ApiCallInitiatedEvent;
import kr.devslab.apilog.event.ApiCallSuccessEvent;
-import kr.devslab.apilog.model.dto.ApiRequest;
-import kr.devslab.apilog.model.dto.ApiResponse;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.ApplicationEventPublisher;
@@ -27,9 +27,10 @@
* {@code api_log} rows asynchronously — no reactor-vs-Spring-AOP friction
* because the event publish is fire-and-forget.
*
- *
Registered automatically when {@code org.springframework:spring-webflux} is
- * on the classpath (the starter declares it as optional); see
- * {@code ReactiveApiClientConfig}.
+ *
Registered automatically by
+ * {@link kr.devslab.apilog.autoconfigure.ReactiveApiClientAutoConfiguration}
+ * when {@code org.springframework:spring-webflux} is on the classpath (the
+ * starter declares it as optional).
*/
public class ReactiveApiClientUtil {
diff --git a/src/main/java/kr/devslab/apilog/util/RestApiClientUtil.java b/core/src/main/java/kr/devslab/apilog/util/RestApiClientUtil.java
similarity index 99%
rename from src/main/java/kr/devslab/apilog/util/RestApiClientUtil.java
rename to core/src/main/java/kr/devslab/apilog/util/RestApiClientUtil.java
index f06820b..f6ded6e 100644
--- a/src/main/java/kr/devslab/apilog/util/RestApiClientUtil.java
+++ b/core/src/main/java/kr/devslab/apilog/util/RestApiClientUtil.java
@@ -1,10 +1,10 @@
package kr.devslab.apilog.util;
+import kr.devslab.apilog.dto.ApiRequest;
+import kr.devslab.apilog.dto.ApiResponse;
import kr.devslab.apilog.event.ApiCallErrorEvent;
import kr.devslab.apilog.event.ApiCallInitiatedEvent;
import kr.devslab.apilog.event.ApiCallSuccessEvent;
-import kr.devslab.apilog.model.dto.ApiRequest;
-import kr.devslab.apilog.model.dto.ApiResponse;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.ApplicationEventPublisher;
diff --git a/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports b/core/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
similarity index 68%
rename from src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
rename to core/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
index 679bb13..c4d22b2 100644
--- a/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
+++ b/core/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
@@ -1,3 +1,3 @@
-kr.devslab.apilog.autoconfigure.ApiLogAutoConfiguration
+kr.devslab.apilog.autoconfigure.ApiLogCoreAutoConfiguration
kr.devslab.apilog.autoconfigure.RestApiClientAutoConfiguration
kr.devslab.apilog.autoconfigure.ReactiveApiClientAutoConfiguration
diff --git a/src/main/resources/db/api-log/V1.0__create_api_log.sql b/core/src/main/resources/db/api-log/V1.0__create_api_log.sql
similarity index 69%
rename from src/main/resources/db/api-log/V1.0__create_api_log.sql
rename to core/src/main/resources/db/api-log/V1.0__create_api_log.sql
index e00ef02..3e8134a 100644
--- a/src/main/resources/db/api-log/V1.0__create_api_log.sql
+++ b/core/src/main/resources/db/api-log/V1.0__create_api_log.sql
@@ -1,4 +1,4 @@
-CREATE TABLE api_log
+CREATE TABLE IF NOT EXISTS api_log
(
id BIGSERIAL PRIMARY KEY,
event_type VARCHAR(50) NOT NULL,
@@ -13,5 +13,5 @@ CREATE TABLE api_log
is_retry BOOLEAN DEFAULT FALSE
);
-CREATE INDEX idx_request_id ON api_log (request_id);
-CREATE INDEX idx_timestamp ON api_log (timestamp);
\ No newline at end of file
+CREATE INDEX IF NOT EXISTS idx_request_id ON api_log (request_id);
+CREATE INDEX IF NOT EXISTS idx_timestamp ON api_log (timestamp);
diff --git a/core/src/test/java/kr/devslab/apilog/TestApp.java b/core/src/test/java/kr/devslab/apilog/TestApp.java
new file mode 100644
index 0000000..460d7de
--- /dev/null
+++ b/core/src/test/java/kr/devslab/apilog/TestApp.java
@@ -0,0 +1,14 @@
+package kr.devslab.apilog;
+
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+/**
+ * Bootstrap class for {@code @SpringBootTest} in the :core module.
+ *
+ *
The library itself is not a Spring Boot application, so it ships no
+ * {@code @SpringBootApplication} of its own. Tests need one for context
+ * lookup — this empty class satisfies that requirement.
+ */
+@SpringBootApplication
+public class TestApp {
+}
diff --git a/core/src/test/java/kr/devslab/apilog/listener/ApiEventListenerTest.java b/core/src/test/java/kr/devslab/apilog/listener/ApiEventListenerTest.java
new file mode 100644
index 0000000..73ea4f5
--- /dev/null
+++ b/core/src/test/java/kr/devslab/apilog/listener/ApiEventListenerTest.java
@@ -0,0 +1,116 @@
+package kr.devslab.apilog.listener;
+
+import kr.devslab.apilog.dto.ApiRequest;
+import kr.devslab.apilog.dto.ApiResponse;
+import kr.devslab.apilog.event.ApiCallErrorEvent;
+import kr.devslab.apilog.event.ApiCallInitiatedEvent;
+import kr.devslab.apilog.event.ApiCallSuccessEvent;
+import kr.devslab.apilog.spi.ApiLogWriter;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+
+/**
+ * Verifies the listener routes events through whatever {@link ApiLogWriter}
+ * bean is injected — the v0.6.0 SPI seam. The writer is a {@link RecordingWriter}
+ * that captures calls; tests assert ordering / arguments / fault-tolerance.
+ *
+ *
{@code @EntityScan} + {@code @EnableJpaRepositories} are pointed explicitly
+ * at this module's packages so the consumer doesn't need to add them to their
+ * own {@code @SpringBootApplication} setup.
+ *
+ *
{@code ApiLogFlywayConfig} is {@code @Imported} so it gets picked up too
+ * — its own {@code @ConditionalOnClass} + {@code @ConditionalOnProperty}
+ * gates keep it dormant unless Flyway is on the classpath AND the consumer
+ * opted in via {@code api.log.schema.management=flyway}.
+ */
+@AutoConfiguration(after = ApiLogCoreAutoConfiguration.class)
+@ConditionalOnClass(jakarta.persistence.Entity.class)
+@ConditionalOnProperty(name = "api.log.enabled", havingValue = "true", matchIfMissing = true)
+@EntityScan(basePackageClasses = ApiLogEntity.class)
+@EnableJpaRepositories(basePackageClasses = ApiLogRepository.class)
+@Import(ApiLogFlywayConfig.class)
+public class ApiLogJpaAutoConfiguration {
+
+ /**
+ * Wire the JPA writer as the {@link ApiLogWriter} implementation. Spring
+ * DI resolves {@link ApiLogRepository} (registered by
+ * {@code @EnableJpaRepositories} above) and {@link PayloadJsonMapper}
+ * (from {@code ApiLogCoreAutoConfiguration}) lazily — no
+ * {@code @ConditionalOnBean} guards needed here, and removing them avoids
+ * the "same-class @Bean evaluated before its own siblings are registered"
+ * pitfall that bit v0.6.0's first CI run.
+ */
+ @Bean
+ @ConditionalOnMissingBean(ApiLogWriter.class)
+ public JpaApiLogWriter jpaApiLogWriter(ApiLogRepository repository, PayloadJsonMapper jsonMapper) {
+ return new JpaApiLogWriter(repository, jsonMapper);
+ }
+
+ /**
+ * Creates the {@code api_log} table at startup when the consumer hasn't
+ * picked a different management strategy (the default — BUILTIN). The
+ * CREATE TABLE statements use IF NOT EXISTS, so this is idempotent and
+ * safe to re-run on every boot.
+ */
+ @Bean
+ @ConditionalOnMissingBean
+ @ConditionalOnProperty(
+ prefix = "api.log.schema",
+ name = "management",
+ havingValue = "builtin",
+ matchIfMissing = true
+ )
+ public ApiLogJpaSchemaInitializer apiLogJpaSchemaInitializer(DataSource dataSource) {
+ return new ApiLogJpaSchemaInitializer(dataSource);
+ }
+}
diff --git a/src/main/java/kr/devslab/apilog/autoconfigure/ApiLogSchemaInitializer.java b/jpa/src/main/java/kr/devslab/apilog/jpa/autoconfigure/ApiLogJpaSchemaInitializer.java
similarity index 88%
rename from src/main/java/kr/devslab/apilog/autoconfigure/ApiLogSchemaInitializer.java
rename to jpa/src/main/java/kr/devslab/apilog/jpa/autoconfigure/ApiLogJpaSchemaInitializer.java
index 85e6901..798cc48 100644
--- a/src/main/java/kr/devslab/apilog/autoconfigure/ApiLogSchemaInitializer.java
+++ b/jpa/src/main/java/kr/devslab/apilog/jpa/autoconfigure/ApiLogJpaSchemaInitializer.java
@@ -1,4 +1,4 @@
-package kr.devslab.apilog.autoconfigure;
+package kr.devslab.apilog.jpa.autoconfigure;
import org.springframework.boot.jdbc.init.DataSourceScriptDatabaseInitializer;
import org.springframework.boot.sql.init.DatabaseInitializationMode;
@@ -25,12 +25,12 @@
*
To opt out of this behavior, set {@code api.log.schema.management=none}
* (apply the DDL yourself) or {@code flyway} (let Flyway own it).
*/
-public class ApiLogSchemaInitializer extends DataSourceScriptDatabaseInitializer {
+public class ApiLogJpaSchemaInitializer extends DataSourceScriptDatabaseInitializer {
- /** Classpath path of the bundled schema script (shared with {@link ApiLogFlywayConfig}). */
+ /** Classpath path of the bundled schema script (shared with {@code ApiLogFlywayConfig}). */
public static final String SCHEMA_SCRIPT = "classpath:db/api-log/V1.0__create_api_log.sql";
- public ApiLogSchemaInitializer(DataSource dataSource) {
+ public ApiLogJpaSchemaInitializer(DataSource dataSource) {
super(dataSource, settings());
}
diff --git a/src/main/java/kr/devslab/apilog/model/ApiLogEntity.java b/jpa/src/main/java/kr/devslab/apilog/jpa/model/ApiLogEntity.java
similarity index 67%
rename from src/main/java/kr/devslab/apilog/model/ApiLogEntity.java
rename to jpa/src/main/java/kr/devslab/apilog/jpa/model/ApiLogEntity.java
index f9cc527..cf54444 100644
--- a/src/main/java/kr/devslab/apilog/model/ApiLogEntity.java
+++ b/jpa/src/main/java/kr/devslab/apilog/jpa/model/ApiLogEntity.java
@@ -1,4 +1,4 @@
-package kr.devslab.apilog.model;
+package kr.devslab.apilog.jpa.model;
import com.fasterxml.jackson.databind.JsonNode;
import jakarta.persistence.Column;
@@ -17,6 +17,20 @@
import java.time.LocalDateTime;
+/**
+ * JPA entity mapping for the {@code api_log} table.
+ *
+ *
The three JSONB columns ({@code payload}, {@code response},
+ * {@code error_message}) use Hibernate's {@code @JdbcTypeCode(SqlTypes.JSON)}
+ * which delegates to the PostgreSQL dialect's JSONB binder. The corresponding
+ * R2DBC + MyBatis backends store the same columns differently
+ * (Json type / TypeHandler).
+ *
+ *
v0.6.0 — moved from {@code kr.devslab.apilog.model} to
+ * {@code kr.devslab.apilog.jpa.model} as part of the multi-module split.
+ * Consumers who imported {@code ApiLogEntity} directly will need to update
+ * their import.
+ */
@Entity
@Table(name = "api_log")
@Getter
@@ -57,4 +71,4 @@ public class ApiLogEntity {
@Column(name = "is_retry")
private Boolean isRetry;
-}
\ No newline at end of file
+}
diff --git a/src/main/java/kr/devslab/apilog/repository/ApiLogRepository.java b/jpa/src/main/java/kr/devslab/apilog/jpa/repository/ApiLogRepository.java
similarity index 54%
rename from src/main/java/kr/devslab/apilog/repository/ApiLogRepository.java
rename to jpa/src/main/java/kr/devslab/apilog/jpa/repository/ApiLogRepository.java
index bd60801..77d8fdf 100644
--- a/src/main/java/kr/devslab/apilog/repository/ApiLogRepository.java
+++ b/jpa/src/main/java/kr/devslab/apilog/jpa/repository/ApiLogRepository.java
@@ -1,11 +1,16 @@
-package kr.devslab.apilog.repository;
+package kr.devslab.apilog.jpa.repository;
-import kr.devslab.apilog.model.ApiLogEntity;
+import kr.devslab.apilog.jpa.model.ApiLogEntity;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
+/**
+ * Spring Data JPA repository for {@link ApiLogEntity}. Only convenience
+ * lookups are exposed; rich querying belongs in the consumer's own services
+ * (this starter's job is to keep the table populated, not to be a reporting API).
+ */
@Repository
public interface ApiLogRepository extends JpaRepository {
@@ -14,4 +19,4 @@ public interface ApiLogRepository extends JpaRepository {
List findByEventType(String eventType);
List findByEndpoint(String endpoint);
-}
\ No newline at end of file
+}
diff --git a/jpa/src/main/java/kr/devslab/apilog/jpa/writer/JpaApiLogWriter.java b/jpa/src/main/java/kr/devslab/apilog/jpa/writer/JpaApiLogWriter.java
new file mode 100644
index 0000000..651689a
--- /dev/null
+++ b/jpa/src/main/java/kr/devslab/apilog/jpa/writer/JpaApiLogWriter.java
@@ -0,0 +1,94 @@
+package kr.devslab.apilog.jpa.writer;
+
+import kr.devslab.apilog.event.ApiCallErrorEvent;
+import kr.devslab.apilog.event.ApiCallInitiatedEvent;
+import kr.devslab.apilog.event.ApiCallSuccessEvent;
+import kr.devslab.apilog.jpa.model.ApiLogEntity;
+import kr.devslab.apilog.jpa.repository.ApiLogRepository;
+import kr.devslab.apilog.spi.ApiLogWriter;
+import kr.devslab.apilog.spi.HttpErrorExtractor;
+import kr.devslab.apilog.spi.HttpErrorInfo;
+import kr.devslab.apilog.spi.PayloadJsonMapper;
+import lombok.RequiredArgsConstructor;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+
+import static kr.devslab.apilog.Constants.ERROR;
+import static kr.devslab.apilog.Constants.INITIATED;
+import static kr.devslab.apilog.Constants.RETRY_ERROR;
+import static kr.devslab.apilog.Constants.SUCCESS;
+
+/**
+ * JPA implementation of {@link ApiLogWriter}. Persists every event as a new
+ * row in the {@code api_log} table.
+ *
+ *
Each write runs in {@link Propagation#REQUIRES_NEW} so the audit write
+ * never participates in (and never breaks) the consumer's outer transaction —
+ * a rollback in the caller's business code mustn't erase log rows for calls
+ * that already happened.
+ *
+ *
v0.6.0 — this is the same logic that lived in the old
+ * {@code kr.devslab.apilog.service.ApiLogService}, now repackaged as a writer
+ * and exposed via the {@link ApiLogWriter} SPI so the core listener can talk
+ * to it without an import cycle.
+ */
+@RequiredArgsConstructor
+public class JpaApiLogWriter implements ApiLogWriter {
+
+ private final ApiLogRepository repository;
+ private final PayloadJsonMapper jsonMapper;
+
+ @Override
+ @Transactional(propagation = Propagation.REQUIRES_NEW)
+ public void writeInitiated(ApiCallInitiatedEvent event) {
+ ApiLogEntity entity = ApiLogEntity.builder()
+ .eventType(INITIATED)
+ .requestId(event.getRequest().getRequestId())
+ .endpoint(event.getRequest().getEndpoint())
+ .payload(jsonMapper.toJsonNode(event.getRequest().getPayload()))
+ .timestamp(LocalDateTime.now())
+ .retryCount(0)
+ .isRetry(false)
+ .build();
+ repository.save(entity);
+ }
+
+ @Override
+ @Transactional(propagation = Propagation.REQUIRES_NEW)
+ public void writeSuccess(ApiCallSuccessEvent event) {
+ ApiLogEntity entity = ApiLogEntity.builder()
+ .eventType(SUCCESS)
+ .requestId(event.getRequest().getRequestId())
+ .endpoint(event.getRequest().getEndpoint())
+ .payload(jsonMapper.toJsonNode(event.getRequest().getPayload()))
+ .response(jsonMapper.toJsonNode(event.getResponse().getData()))
+ .statusCode(event.getResponse().getStatusCode())
+ .timestamp(LocalDateTime.now())
+ .retryCount(0)
+ .isRetry(false)
+ .build();
+ repository.save(entity);
+ }
+
+ @Override
+ @Transactional(propagation = Propagation.REQUIRES_NEW)
+ public void writeError(ApiCallErrorEvent event) {
+ Throwable error = event.getError();
+ HttpErrorInfo info = HttpErrorExtractor.extract(error);
+
+ ApiLogEntity entity = ApiLogEntity.builder()
+ .eventType(event.isRetry() ? RETRY_ERROR : ERROR)
+ .requestId(event.getRequest().getRequestId())
+ .endpoint(event.getRequest().getEndpoint())
+ .payload(jsonMapper.toJsonNode(event.getRequest().getPayload()))
+ .errorMessage(jsonMapper.buildErrorJson(error, info.responseBody()))
+ .statusCode(info.statusCode())
+ .timestamp(LocalDateTime.now())
+ .retryCount(event.getRetryCount())
+ .isRetry(event.isRetry())
+ .build();
+ repository.save(entity);
+ }
+}
diff --git a/jpa/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports b/jpa/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
new file mode 100644
index 0000000..e0a8cfe
--- /dev/null
+++ b/jpa/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
@@ -0,0 +1 @@
+kr.devslab.apilog.jpa.autoconfigure.ApiLogJpaAutoConfiguration
diff --git a/jpa/src/test/java/kr/devslab/apilog/TestApp.java b/jpa/src/test/java/kr/devslab/apilog/TestApp.java
new file mode 100644
index 0000000..e29efea
--- /dev/null
+++ b/jpa/src/test/java/kr/devslab/apilog/TestApp.java
@@ -0,0 +1,10 @@
+package kr.devslab.apilog;
+
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+/**
+ * Bootstrap class for {@code @SpringBootTest} in the :jpa module.
+ */
+@SpringBootApplication
+public class TestApp {
+}
diff --git a/jpa/src/test/java/kr/devslab/apilog/jpa/autoconfigure/ConfigurationTest.java b/jpa/src/test/java/kr/devslab/apilog/jpa/autoconfigure/ConfigurationTest.java
new file mode 100644
index 0000000..7a74831
--- /dev/null
+++ b/jpa/src/test/java/kr/devslab/apilog/jpa/autoconfigure/ConfigurationTest.java
@@ -0,0 +1,117 @@
+package kr.devslab.apilog.jpa.autoconfigure;
+
+import kr.devslab.apilog.spi.ApiLogWriter;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.module.blackbird.BlackbirdModule;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.ApplicationContext;
+import org.springframework.core.task.TaskExecutor;
+import org.springframework.core.task.VirtualThreadTaskExecutor;
+import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
+import org.springframework.test.context.DynamicPropertyRegistry;
+import org.springframework.test.context.DynamicPropertySource;
+import org.springframework.web.client.RestClient;
+import org.testcontainers.containers.PostgreSQLContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Boots a full Spring context with the JPA backend installed and verifies the
+ * v0.6.0 module split wires everything up correctly:
+ *
+ *
The three auto-configurations from :core load (core / rest / reactive).
+ *
The JPA auto-config from :jpa loads, registering a {@link ApiLogWriter}.
+ *
Blackbird-enabled ObjectMapper + RestClient + virtual-thread executor
+ * are all in the context.
{@link MapperScan} is pointed at {@link ApiLogMapper}'s package so the
+ * consumer doesn't need to add their own {@code @MapperScan} or
+ * {@code @Mapper} bean override. If the consumer already drives MyBatis with
+ * their own scan, our mapper still gets picked up because MapperScan annotations
+ * compose additively.
+ *
+ *
Schema management strategies: {@code BUILTIN} (default) registers the
+ * initializer above; {@code NONE} does nothing; {@code FLYWAY} is honored if
+ * the JPA module is also on the classpath (its FlywayConfigurationCustomizer
+ * activates via the same property). Pure-MyBatis setups can install Flyway
+ * directly — Spring Boot's stock Flyway autoconfig will pick up
+ * {@code classpath:db/api-log} when added to their {@code spring.flyway.locations}.
+ */
+@AutoConfiguration(after = {ApiLogCoreAutoConfiguration.class, MybatisAutoConfiguration.class})
+@ConditionalOnClass(org.apache.ibatis.session.SqlSessionFactory.class)
+@ConditionalOnProperty(name = "api.log.enabled", havingValue = "true", matchIfMissing = true)
+@MapperScan(basePackageClasses = ApiLogMapper.class)
+public class ApiLogMybatisAutoConfiguration {
+
+ /**
+ * Wire the MyBatis writer as the {@link ApiLogWriter} implementation.
+ * Spring DI resolves {@link ApiLogMapper} (registered via the
+ * {@code @MapperScan} above) and {@link PayloadJsonMapper} (from
+ * {@code ApiLogCoreAutoConfiguration}) lazily — no
+ * {@code @ConditionalOnBean} guards, since those evaluate before the
+ * sibling beans are registered and were what bit the first CI run.
+ */
+ @Bean
+ @ConditionalOnMissingBean(ApiLogWriter.class)
+ public MybatisApiLogWriter mybatisApiLogWriter(ApiLogMapper mapper, PayloadJsonMapper jsonMapper) {
+ return new MybatisApiLogWriter(mapper, jsonMapper);
+ }
+
+ @Bean
+ @ConditionalOnMissingBean
+ @ConditionalOnProperty(
+ prefix = "api.log.schema",
+ name = "management",
+ havingValue = "builtin",
+ matchIfMissing = true
+ )
+ public ApiLogMybatisSchemaInitializer apiLogMybatisSchemaInitializer(DataSource dataSource) {
+ return new ApiLogMybatisSchemaInitializer(dataSource);
+ }
+}
diff --git a/mybatis/src/main/java/kr/devslab/apilog/mybatis/autoconfigure/ApiLogMybatisSchemaInitializer.java b/mybatis/src/main/java/kr/devslab/apilog/mybatis/autoconfigure/ApiLogMybatisSchemaInitializer.java
new file mode 100644
index 0000000..e98d092
--- /dev/null
+++ b/mybatis/src/main/java/kr/devslab/apilog/mybatis/autoconfigure/ApiLogMybatisSchemaInitializer.java
@@ -0,0 +1,38 @@
+package kr.devslab.apilog.mybatis.autoconfigure;
+
+import org.springframework.boot.jdbc.init.DataSourceScriptDatabaseInitializer;
+import org.springframework.boot.sql.init.DatabaseInitializationMode;
+import org.springframework.boot.sql.init.DatabaseInitializationSettings;
+
+import javax.sql.DataSource;
+import java.util.List;
+
+/**
+ * Runs the bundled {@code V1.0__create_api_log.sql} against the consumer's
+ * {@link DataSource} when {@code api.log.schema.management=builtin} (default).
+ *
+ *
Identical shape to {@code ApiLogJpaSchemaInitializer} — both backends
+ * use JDBC, so both can reuse Spring Boot's
+ * {@link DataSourceScriptDatabaseInitializer}. Kept as separate classes to
+ * keep each backend self-contained (no awkward "import the JPA module's bean
+ * just for the initializer").
+ *
+ *
The DDL is idempotent ({@code CREATE TABLE IF NOT EXISTS}) so re-running
+ * it on every boot is safe.
+ */
+public class ApiLogMybatisSchemaInitializer extends DataSourceScriptDatabaseInitializer {
+
+ public static final String SCHEMA_SCRIPT = "classpath:db/api-log/V1.0__create_api_log.sql";
+
+ public ApiLogMybatisSchemaInitializer(DataSource dataSource) {
+ super(dataSource, settings());
+ }
+
+ private static DatabaseInitializationSettings settings() {
+ DatabaseInitializationSettings settings = new DatabaseInitializationSettings();
+ settings.setSchemaLocations(List.of(SCHEMA_SCRIPT));
+ settings.setMode(DatabaseInitializationMode.ALWAYS);
+ settings.setContinueOnError(false);
+ return settings;
+ }
+}
diff --git a/mybatis/src/main/java/kr/devslab/apilog/mybatis/mapper/ApiLogMapper.java b/mybatis/src/main/java/kr/devslab/apilog/mybatis/mapper/ApiLogMapper.java
new file mode 100644
index 0000000..c5d1a51
--- /dev/null
+++ b/mybatis/src/main/java/kr/devslab/apilog/mybatis/mapper/ApiLogMapper.java
@@ -0,0 +1,54 @@
+package kr.devslab.apilog.mybatis.mapper;
+
+import kr.devslab.apilog.mybatis.model.ApiLogRow;
+import org.apache.ibatis.annotations.Insert;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Options;
+
+import java.util.List;
+
+/**
+ * MyBatis mapper for the {@code api_log} table.
+ *
+ *
The {@code ::jsonb} cast on each JSON parameter lets MyBatis bind a Java
+ * {@link String} into a PostgreSQL {@code JSONB} column without needing a
+ * custom {@code TypeHandler}. {@code #{payload,jdbcType=VARCHAR}} forces the
+ * VARCHAR binding even when the value is {@code null}, which side-steps
+ * PostgreSQL's "could not determine data type of parameter" error on null
+ * JSONB binds.
+ *
+ *
{@code @Options(useGeneratedKeys=true)} flows the {@code BIGSERIAL}
+ * {@code id} back onto the {@link ApiLogRow} after insert — handy for tests
+ * that want to assert on a specific row even though the writer itself doesn't
+ * read it back.
+ */
+@Mapper
+public interface ApiLogMapper {
+
+ @Insert("""
+ INSERT INTO api_log
+ (event_type, request_id, endpoint, payload, response,
+ status_code, error_message, timestamp, retry_count, is_retry)
+ VALUES
+ (#{eventType},
+ #{requestId},
+ #{endpoint},
+ CAST(#{payload,jdbcType=VARCHAR} AS jsonb),
+ CAST(#{response,jdbcType=VARCHAR} AS jsonb),
+ #{statusCode,jdbcType=INTEGER},
+ CAST(#{errorMessage,jdbcType=VARCHAR} AS jsonb),
+ #{timestamp},
+ #{retryCount},
+ #{isRetry})
+ """)
+ @Options(useGeneratedKeys = true, keyProperty = "id", keyColumn = "id")
+ void insert(ApiLogRow row);
+
+ @org.apache.ibatis.annotations.Select(
+ "SELECT id, event_type AS eventType, request_id AS requestId, endpoint, " +
+ "payload::text AS payload, response::text AS response, status_code AS statusCode, " +
+ "error_message::text AS errorMessage, timestamp, retry_count AS retryCount, is_retry AS isRetry " +
+ "FROM api_log WHERE request_id = #{requestId} ORDER BY id ASC"
+ )
+ List findByRequestId(String requestId);
+}
diff --git a/mybatis/src/main/java/kr/devslab/apilog/mybatis/model/ApiLogRow.java b/mybatis/src/main/java/kr/devslab/apilog/mybatis/model/ApiLogRow.java
new file mode 100644
index 0000000..9974dea
--- /dev/null
+++ b/mybatis/src/main/java/kr/devslab/apilog/mybatis/model/ApiLogRow.java
@@ -0,0 +1,39 @@
+package kr.devslab.apilog.mybatis.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+
+/**
+ * Plain row carrier handed to the MyBatis mapper. Mirrors the {@code api_log}
+ * table — the JPA backend's {@code ApiLogEntity} has the same shape but
+ * carries the Hibernate {@code @JdbcTypeCode(JSON)} annotations; here we
+ * keep it framework-free since MyBatis handles the parameter binding via the
+ * {@code ::jsonb} cast in the mapper SQL.
+ *
+ *
Each write runs in {@link Propagation#REQUIRES_NEW} so the audit insert
+ * doesn't piggy-back on (or roll back with) the consumer's outer transaction
+ * — same contract as {@code JpaApiLogWriter}.
+ *
+ *
{@link DatabaseClient} (only if the consumer didn't already provide one)
+ * built off the consumer's {@code ConnectionFactory} bean.
+ *
{@link R2dbcApiLogWriter} — the reactive {@link ApiLogWriter} the core
+ * listener routes through.
+ *
{@link ApiLogR2dbcSchemaInitializer} — pure-reactive
+ * {@code CREATE TABLE IF NOT EXISTS} initializer when
+ * {@code api.log.schema.management=builtin} (default).
+ *
+ *
+ *
Schema management strategies under R2DBC:
+ *
+ *
BUILTIN (default) — registers the reactive initializer above.
+ *
NONE — does nothing; apply the DDL yourself.
+ *
FLYWAY — not supported in R2DBC mode. Flyway needs a
+ * JDBC {@code DataSource}; consumers who want Flyway should run it from
+ * a separate JDBC connection at boot (Spring Boot's standard Flyway
+ * autoconfig works fine alongside R2DBC for this) or switch to the JPA
+ * backend.
+ *
+ */
+@AutoConfiguration(after = {ApiLogCoreAutoConfiguration.class, R2dbcAutoConfiguration.class})
+@ConditionalOnClass(ConnectionFactory.class)
+@ConditionalOnProperty(name = "api.log.enabled", havingValue = "true", matchIfMissing = true)
+public class ApiLogR2dbcAutoConfiguration {
+
+ /**
+ * Lazily-built {@link DatabaseClient}. Skipped if the consumer (or
+ * Spring Boot's reactive autoconfig) already registered one — most
+ * R2DBC apps will already have it via {@code spring-boot-starter-data-r2dbc}.
+ * {@link ConnectionFactory} is supplied via constructor injection; we sit
+ * {@code after = R2dbcAutoConfiguration.class} so Spring Boot's auto-built
+ * one is in place by the time this method is invoked.
+ */
+ @Bean
+ @ConditionalOnMissingBean
+ public DatabaseClient apiLogR2dbcDatabaseClient(ConnectionFactory connectionFactory) {
+ return DatabaseClient.create(connectionFactory);
+ }
+
+ /**
+ * Wire the R2DBC writer as the {@link ApiLogWriter} implementation. No
+ * {@code @ConditionalOnBean} guards on {@link DatabaseClient} /
+ * {@link PayloadJsonMapper} — those would race against the same class's
+ * own {@code @Bean} declarations (a Spring Boot pitfall). Spring DI
+ * resolves the parameters lazily, which avoids the ordering problem.
+ */
+ @Bean
+ @ConditionalOnMissingBean(ApiLogWriter.class)
+ public R2dbcApiLogWriter r2dbcApiLogWriter(DatabaseClient databaseClient, PayloadJsonMapper jsonMapper) {
+ return new R2dbcApiLogWriter(databaseClient, jsonMapper);
+ }
+
+ @Bean
+ @ConditionalOnMissingBean
+ @ConditionalOnProperty(
+ prefix = "api.log.schema",
+ name = "management",
+ havingValue = "builtin",
+ matchIfMissing = true
+ )
+ public ApiLogR2dbcSchemaInitializer apiLogR2dbcSchemaInitializer(ConnectionFactory connectionFactory) {
+ return new ApiLogR2dbcSchemaInitializer(connectionFactory);
+ }
+}
diff --git a/r2dbc/src/main/java/kr/devslab/apilog/r2dbc/autoconfigure/ApiLogR2dbcSchemaInitializer.java b/r2dbc/src/main/java/kr/devslab/apilog/r2dbc/autoconfigure/ApiLogR2dbcSchemaInitializer.java
new file mode 100644
index 0000000..92a1a81
--- /dev/null
+++ b/r2dbc/src/main/java/kr/devslab/apilog/r2dbc/autoconfigure/ApiLogR2dbcSchemaInitializer.java
@@ -0,0 +1,39 @@
+package kr.devslab.apilog.r2dbc.autoconfigure;
+
+import io.r2dbc.spi.ConnectionFactory;
+import org.springframework.boot.r2dbc.init.R2dbcScriptDatabaseInitializer;
+import org.springframework.boot.sql.init.DatabaseInitializationMode;
+import org.springframework.boot.sql.init.DatabaseInitializationSettings;
+
+import java.util.List;
+
+/**
+ * Pure-reactive schema initializer — runs {@code V1.0__create_api_log.sql}
+ * against a {@link ConnectionFactory} without ever opening a JDBC connection.
+ *
+ *
Mirrors {@code ApiLogJpaSchemaInitializer} but routes through Spring
+ * Boot's {@link R2dbcScriptDatabaseInitializer} (vs. {@code DataSourceScript...}).
+ * That keeps R2DBC-only applications honest — no surprise JDBC driver pull-in
+ * just because the audit table needs to be created.
+ *
+ *
Activated when {@code api.log.schema.management=builtin} (default) AND
+ * the R2DBC autoconfig is active. The DDL is idempotent
+ * ({@code CREATE TABLE IF NOT EXISTS}), so re-running on every boot is safe.
+ */
+public class ApiLogR2dbcSchemaInitializer extends R2dbcScriptDatabaseInitializer {
+
+ /** Classpath path of the bundled schema script (shared with the JPA + MyBatis backends). */
+ public static final String SCHEMA_SCRIPT = "classpath:db/api-log/V1.0__create_api_log.sql";
+
+ public ApiLogR2dbcSchemaInitializer(ConnectionFactory connectionFactory) {
+ super(connectionFactory, settings());
+ }
+
+ private static DatabaseInitializationSettings settings() {
+ DatabaseInitializationSettings settings = new DatabaseInitializationSettings();
+ settings.setSchemaLocations(List.of(SCHEMA_SCRIPT));
+ settings.setMode(DatabaseInitializationMode.ALWAYS);
+ settings.setContinueOnError(false);
+ return settings;
+ }
+}
diff --git a/r2dbc/src/main/java/kr/devslab/apilog/r2dbc/writer/R2dbcApiLogWriter.java b/r2dbc/src/main/java/kr/devslab/apilog/r2dbc/writer/R2dbcApiLogWriter.java
new file mode 100644
index 0000000..2a065c8
--- /dev/null
+++ b/r2dbc/src/main/java/kr/devslab/apilog/r2dbc/writer/R2dbcApiLogWriter.java
@@ -0,0 +1,173 @@
+package kr.devslab.apilog.r2dbc.writer;
+
+import kr.devslab.apilog.event.ApiCallErrorEvent;
+import kr.devslab.apilog.event.ApiCallInitiatedEvent;
+import kr.devslab.apilog.event.ApiCallSuccessEvent;
+import kr.devslab.apilog.spi.ApiLogWriter;
+import kr.devslab.apilog.spi.HttpErrorExtractor;
+import kr.devslab.apilog.spi.HttpErrorInfo;
+import kr.devslab.apilog.spi.PayloadJsonMapper;
+import io.r2dbc.spi.Parameters;
+import io.r2dbc.spi.R2dbcType;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.r2dbc.core.DatabaseClient;
+import reactor.core.scheduler.Schedulers;
+
+import java.time.LocalDateTime;
+
+import static kr.devslab.apilog.Constants.ERROR;
+import static kr.devslab.apilog.Constants.INITIATED;
+import static kr.devslab.apilog.Constants.RETRY_ERROR;
+import static kr.devslab.apilog.Constants.SUCCESS;
+
+/**
+ * Reactive (R2DBC) implementation of {@link ApiLogWriter}.
+ *
+ *
Talks to a {@link DatabaseClient} directly rather than going through a
+ * Spring Data R2DBC repository — this keeps the dependency footprint small
+ * (no spring-data-r2dbc, no Spring Data Commons), and gives us a clean place
+ * to do the explicit {@code ::jsonb} cast PostgreSQL needs when binding a
+ * {@code TEXT} parameter into a {@code JSONB} column.
+ *
+ *
The writer subscribes to the resulting {@code Mono} inline via
+ * {@code .subscribe()} so it matches the fire-and-forget semantics the core
+ * listener expects (the listener doesn't consume return values, and the
+ * surrounding {@code @Async} executor wouldn't propagate a {@code Mono}
+ * usefully anyway).
+ *
+ *
Subscription errors are logged but not rethrown — losing one audit row
+ * must never break the consumer's actual outbound HTTP call. Same contract
+ * as the JPA writer.
+ */
+@Slf4j
+@RequiredArgsConstructor
+public class R2dbcApiLogWriter implements ApiLogWriter {
+
+ // PostgreSQL won't implicitly cast TEXT -> JSONB the way I'd hoped --
+ // r2dbc-postgresql binds CLOB params as text and the server rejects the
+ // insert with "column 'payload' is of type jsonb but expression is of
+ // type text". Explicit `::jsonb` on every JSONB column fixes it without
+ // requiring a custom codec or the r2dbc-postgresql Json type.
+ private static final String INSERT_SQL = """
+ INSERT INTO api_log
+ (event_type, request_id, endpoint, payload, response,
+ status_code, error_message, timestamp, retry_count, is_retry)
+ VALUES
+ (:eventType, :requestId, :endpoint,
+ :payload::jsonb, :response::jsonb,
+ :statusCode,
+ :errorMessage::jsonb,
+ :timestamp, :retryCount, :isRetry)
+ """;
+
+ private final DatabaseClient databaseClient;
+ private final PayloadJsonMapper jsonMapper;
+
+ @Override
+ public void writeInitiated(ApiCallInitiatedEvent event) {
+ executeInsert(
+ INITIATED,
+ event.getRequest().getRequestId(),
+ event.getRequest().getEndpoint(),
+ jsonMapper.toJsonString(event.getRequest().getPayload()),
+ null,
+ null,
+ null,
+ 0,
+ false
+ );
+ }
+
+ @Override
+ public void writeSuccess(ApiCallSuccessEvent event) {
+ executeInsert(
+ SUCCESS,
+ event.getRequest().getRequestId(),
+ event.getRequest().getEndpoint(),
+ jsonMapper.toJsonString(event.getRequest().getPayload()),
+ jsonMapper.toJsonString(event.getResponse().getData()),
+ event.getResponse().getStatusCode(),
+ null,
+ 0,
+ false
+ );
+ }
+
+ @Override
+ public void writeError(ApiCallErrorEvent event) {
+ Throwable error = event.getError();
+ HttpErrorInfo info = HttpErrorExtractor.extract(error);
+
+ executeInsert(
+ event.isRetry() ? RETRY_ERROR : ERROR,
+ event.getRequest().getRequestId(),
+ event.getRequest().getEndpoint(),
+ jsonMapper.toJsonString(event.getRequest().getPayload()),
+ null,
+ info.statusCode(),
+ jsonMapper.buildErrorJsonString(error, info.responseBody()),
+ event.getRetryCount(),
+ event.isRetry()
+ );
+ }
+
+ /**
+ * Common write path — every event type funnels through this.
+ *
+ *
Each JSONB parameter is bound as a {@link R2dbcType#CLOB CLOB} via
+ * {@link Parameters#in(io.r2dbc.spi.Type, Object)} and the driver hands it
+ * to PostgreSQL as text. The PostgreSQL R2DBC driver applies the column's
+ * implicit cast (TEXT → JSONB) on insert, so no manual {@code ::jsonb} is
+ * needed — keeps the SQL portable to other dialects that may follow.
+ */
+ private void executeInsert(String eventType,
+ String requestId,
+ String endpoint,
+ String payload,
+ String response,
+ Integer statusCode,
+ String errorMessage,
+ int retryCount,
+ boolean isRetry) {
+ DatabaseClient.GenericExecuteSpec spec = databaseClient.sql(INSERT_SQL)
+ .bind("eventType", eventType)
+ .bind("requestId", requestId)
+ .bind("endpoint", endpoint)
+ .bind("payload", asJsonbParam(payload))
+ .bind("response", asJsonbParam(response))
+ .bind("statusCode", statusCode == null
+ ? Parameters.in(R2dbcType.INTEGER)
+ : Parameters.in(R2dbcType.INTEGER, statusCode))
+ .bind("errorMessage", asJsonbParam(errorMessage))
+ .bind("timestamp", LocalDateTime.now())
+ .bind("retryCount", retryCount)
+ .bind("isRetry", isRetry);
+
+ // Fire-and-forget — the whole point of this backend is to NOT block
+ // the caller's reactor thread. Pinning the subscription to
+ // boundedElastic guarantees the insert actually runs on a worker thread
+ // (without it the chain can starve when the caller hands control
+ // straight back to a CPU-bound test loop or a single-core CI runner —
+ // which is what bit the v0.6.0 first integration run).
+ spec.fetch()
+ .rowsUpdated()
+ .subscribeOn(Schedulers.boundedElastic())
+ .doOnSuccess(rows -> log.debug(
+ "R2DBC api_log insert ok: requestId={}, eventType={}, rows={}",
+ requestId, eventType, rows))
+ .doOnError(ex -> log.error(
+ "R2DBC api_log insert failed: requestId={}, eventType={}",
+ requestId, eventType, ex))
+ .subscribe();
+ }
+
+ private static Object asJsonbParam(String value) {
+ // CLOB binding triggers the driver's TEXT path. Passing null with a
+ // typed Parameters.in(...) preserves the NULL JSONB semantics — a raw
+ // null would let the driver guess the type and bind it as untyped NULL.
+ return value == null
+ ? Parameters.in(R2dbcType.CLOB)
+ : Parameters.in(R2dbcType.CLOB, value);
+ }
+}
diff --git a/r2dbc/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports b/r2dbc/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
new file mode 100644
index 0000000..530830f
--- /dev/null
+++ b/r2dbc/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
@@ -0,0 +1 @@
+kr.devslab.apilog.r2dbc.autoconfigure.ApiLogR2dbcAutoConfiguration
diff --git a/r2dbc/src/test/java/kr/devslab/apilog/TestApp.java b/r2dbc/src/test/java/kr/devslab/apilog/TestApp.java
new file mode 100644
index 0000000..5c6b143
--- /dev/null
+++ b/r2dbc/src/test/java/kr/devslab/apilog/TestApp.java
@@ -0,0 +1,10 @@
+package kr.devslab.apilog;
+
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+/**
+ * Bootstrap class for {@code @SpringBootTest} in the :r2dbc module.
+ */
+@SpringBootApplication
+public class TestApp {
+}
diff --git a/r2dbc/src/test/java/kr/devslab/apilog/r2dbc/writer/R2dbcApiLogWriterIntegrationTest.java b/r2dbc/src/test/java/kr/devslab/apilog/r2dbc/writer/R2dbcApiLogWriterIntegrationTest.java
new file mode 100644
index 0000000..e695a19
--- /dev/null
+++ b/r2dbc/src/test/java/kr/devslab/apilog/r2dbc/writer/R2dbcApiLogWriterIntegrationTest.java
@@ -0,0 +1,183 @@
+package kr.devslab.apilog.r2dbc.writer;
+
+import kr.devslab.apilog.dto.ApiRequest;
+import kr.devslab.apilog.dto.ApiResponse;
+import kr.devslab.apilog.event.ApiCallErrorEvent;
+import kr.devslab.apilog.event.ApiCallInitiatedEvent;
+import kr.devslab.apilog.event.ApiCallSuccessEvent;
+import kr.devslab.apilog.spi.ApiLogWriter;
+import org.awaitility.Awaitility;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.r2dbc.core.DatabaseClient;
+import org.springframework.test.context.DynamicPropertyRegistry;
+import org.springframework.test.context.DynamicPropertySource;
+import org.testcontainers.containers.PostgreSQLContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration test for the R2DBC backend — boots a Spring context with the
+ * reactive autoconfig, drives events through the registered
+ * {@link ApiLogWriter}, then asserts the rows landed in PostgreSQL using a
+ * second JDBC-free {@link DatabaseClient} query.
+ *
+ *
This is also the regression guard for the v0.6.0 "R2DBC actually works"
+ * promise — if the writer's parameter binding or the reactive schema
+ * initializer breaks, this test fails before any release reaches Maven Central.
+ */
+@SpringBootTest
+@Testcontainers
+class R2dbcApiLogWriterIntegrationTest {
+
+ @Container
+ static PostgreSQLContainer postgres = new PostgreSQLContainer<>("postgres:15")
+ .withDatabaseName("apilog_r2dbc_it")
+ .withUsername("test")
+ .withPassword("test");
+
+ @DynamicPropertySource
+ static void configure(DynamicPropertyRegistry registry) {
+ // Spring Boot's R2dbcAutoConfiguration reads spring.r2dbc.* — the
+ // r2dbc:postgresql:// scheme is what tells it which driver to load.
+ registry.add("spring.r2dbc.url", () -> String.format(
+ "r2dbc:postgresql://%s:%d/%s",
+ postgres.getHost(),
+ postgres.getMappedPort(5432),
+ postgres.getDatabaseName()));
+ registry.add("spring.r2dbc.username", postgres::getUsername);
+ registry.add("spring.r2dbc.password", postgres::getPassword);
+ }
+
+ @Autowired
+ ApiLogWriter writer;
+
+ @Autowired
+ DatabaseClient databaseClient;
+
+ @BeforeEach
+ void clearTable() {
+ databaseClient.sql("DELETE FROM api_log").fetch().rowsUpdated().block();
+ }
+
+ @Test
+ void writer_isWiredFromR2dbcBackend() {
+ // The R2DBC writer has no @Transactional today so it's not proxied,
+ // but matching the JPA/MyBatis tests' substring approach keeps it
+ // proxy-safe if that ever changes.
+ assertThat(writer.getClass().getName()).contains("R2dbcApiLogWriter");
+ }
+
+ @Test
+ void writeInitiated_insertsRowWithJsonbPayload() {
+ String reqId = UUID.randomUUID().toString();
+ ApiRequest request = ApiRequest.builder()
+ .endpoint("/charges")
+ .payload("{\"amount\":100}")
+ .requestId(reqId)
+ .build();
+
+ writer.writeInitiated(new ApiCallInitiatedEvent(this, request));
+
+ Awaitility.await().atMost(Duration.ofSeconds(10)).untilAsserted(() -> {
+ List> rows = fetchByRequestId(reqId);
+ assertThat(rows).hasSize(1);
+ Map row = rows.get(0);
+ assertThat(row.get("event_type")).isEqualTo("INITIATED");
+ assertThat(row.get("endpoint")).isEqualTo("/charges");
+ assertThat(row.get("retry_count")).isEqualTo(0);
+ assertThat(row.get("is_retry")).isEqualTo(false);
+ // payload is JSONB; toString round-trips to canonical JSON
+ assertThat(row.get("payload").toString()).contains("\"amount\": 100");
+ });
+ }
+
+ @Test
+ void writeSuccess_insertsRowWithResponseJsonAndStatusCode() {
+ String reqId = UUID.randomUUID().toString();
+ ApiRequest request = ApiRequest.builder()
+ .endpoint("/charges").requestId(reqId).build();
+ ApiResponse response = ApiResponse.builder()
+ .data("{\"id\":\"ch_1\"}").statusCode(201).build();
+
+ writer.writeSuccess(new ApiCallSuccessEvent(this, request, response));
+
+ Awaitility.await().atMost(Duration.ofSeconds(10)).untilAsserted(() -> {
+ List> rows = fetchByRequestId(reqId);
+ assertThat(rows).hasSize(1);
+ Map row = rows.get(0);
+ assertThat(row.get("event_type")).isEqualTo("SUCCESS");
+ assertThat(row.get("status_code")).isEqualTo(201);
+ assertThat(row.get("response").toString()).contains("\"id\": \"ch_1\"");
+ });
+ }
+
+ @Test
+ void writeError_insertsStructuredErrorMessage() {
+ String reqId = UUID.randomUUID().toString();
+ ApiRequest request = ApiRequest.builder()
+ .endpoint("/charges").requestId(reqId).build();
+ IllegalStateException error = new IllegalStateException("connection broken");
+ ApiCallErrorEvent event = new ApiCallErrorEvent(this, request, error, 0, false);
+
+ writer.writeError(event);
+
+ Awaitility.await().atMost(Duration.ofSeconds(10)).untilAsserted(() -> {
+ List> rows = fetchByRequestId(reqId);
+ assertThat(rows).hasSize(1);
+ Map row = rows.get(0);
+ assertThat(row.get("event_type")).isEqualTo("ERROR");
+ // Non-HTTP exception → no status_code
+ assertThat(row.get("status_code")).isNull();
+ assertThat(row.get("error_message").toString())
+ .contains("\"type\": \"java.lang.IllegalStateException\"")
+ .contains("\"message\": \"connection broken\"");
+ });
+ }
+
+ @Test
+ void writeError_marksRetryErrorWhenRetryFlagSet() {
+ String reqId = UUID.randomUUID().toString();
+ ApiRequest request = ApiRequest.builder()
+ .endpoint("/charges").requestId(reqId).build();
+ ApiCallErrorEvent event = new ApiCallErrorEvent(this, request,
+ new RuntimeException("retry"), 2, true);
+
+ writer.writeError(event);
+
+ Awaitility.await().atMost(Duration.ofSeconds(10)).untilAsserted(() -> {
+ List> rows = fetchByRequestId(reqId);
+ assertThat(rows).hasSize(1);
+ Map row = rows.get(0);
+ assertThat(row.get("event_type")).isEqualTo("RETRY_ERROR");
+ assertThat(row.get("retry_count")).isEqualTo(2);
+ assertThat(row.get("is_retry")).isEqualTo(true);
+ });
+ }
+
+ private List> fetchByRequestId(String requestId) {
+ return databaseClient.sql("""
+ SELECT event_type, endpoint, payload::text AS payload,
+ response::text AS response, status_code,
+ error_message::text AS error_message,
+ retry_count, is_retry
+ FROM api_log
+ WHERE request_id = :rid
+ ORDER BY id ASC
+ """)
+ .bind("rid", requestId)
+ .fetch()
+ .all()
+ .collectList()
+ .block();
+ }
+}
diff --git a/settings.gradle.kts b/settings.gradle.kts
new file mode 100644
index 0000000..3c389d8
--- /dev/null
+++ b/settings.gradle.kts
@@ -0,0 +1,29 @@
+pluginManagement {
+ repositories {
+ gradlePluginPortal()
+ mavenCentral()
+ }
+}
+
+dependencyResolutionManagement {
+ repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+ repositories {
+ mavenCentral()
+ }
+}
+
+rootProject.name = "api-log"
+
+// Subprojects. Each publishable artifact lives under its own subproject.
+// The on-disk directory name is short (`core`, `jpa`, `r2dbc`, `mybatis`);
+// the Maven artifact ID is pinned via `mavenPublishing.coordinates(...)` in
+// each module's build file.
+//
+// core → kr.devslab:api-log-core (events, SPI, HTTP utils, listener)
+// jpa → kr.devslab:api-log-jpa (JPA writer + entity + Flyway hook)
+// r2dbc → kr.devslab:api-log-r2dbc (reactive R2DBC writer)
+// mybatis → kr.devslab:api-log-mybatis (MyBatis mapper writer)
+include("core")
+include("jpa")
+include("r2dbc")
+include("mybatis")
diff --git a/src/main/java/kr/devslab/apilog/Constants.java b/src/main/java/kr/devslab/apilog/Constants.java
deleted file mode 100644
index b39a1b6..0000000
--- a/src/main/java/kr/devslab/apilog/Constants.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package kr.devslab.apilog;
-
-public class Constants {
-
- public static final String INITIATED = "INITIATED";
- public static final String SUCCESS = "SUCCESS";
- public static final String RETRY_ERROR = "RETRY_ERROR";
- public static final String ERROR = "ERROR";
-}
\ No newline at end of file
diff --git a/src/main/java/kr/devslab/apilog/autoconfigure/ApiLogProperties.java b/src/main/java/kr/devslab/apilog/autoconfigure/ApiLogProperties.java
deleted file mode 100644
index 99115ab..0000000
--- a/src/main/java/kr/devslab/apilog/autoconfigure/ApiLogProperties.java
+++ /dev/null
@@ -1,72 +0,0 @@
-package kr.devslab.apilog.autoconfigure;
-
-import org.springframework.boot.context.properties.ConfigurationProperties;
-
-@ConfigurationProperties(prefix = "api.log")
-public class ApiLogProperties {
-
- /**
- * Enable the API logging infrastructure (listener, service, repository, RestApiClientUtil).
- * When false, no beans are registered.
- * Default: true.
- */
- private boolean enabled = true;
-
- /**
- * How the api_log table's schema is provisioned. See {@link Schema}.
- */
- private Schema schema = new Schema();
-
- public boolean isEnabled() {
- return enabled;
- }
-
- public void setEnabled(boolean enabled) {
- this.enabled = enabled;
- }
-
- public Schema getSchema() {
- return schema;
- }
-
- public void setSchema(Schema schema) {
- this.schema = schema;
- }
-
- public static class Schema {
- /**
- * Schema management strategy for the {@code api_log} table.
- *
- *
- *
BUILTIN (default) — the starter runs {@code CREATE TABLE IF NOT EXISTS}
- * on application startup, so the table just exists without any other tool.
- * The SQL is idempotent, so this is safe to leave on every boot.
- * Use this if you don't have (or don't want) Flyway / Liquibase in your project.
- *
NONE — the starter does not touch the schema. Apply the DDL yourself
- * (see api-log.devslab.kr/reference/schema).
- * Use this if your team's policy is that third-party libraries must never touch the schema,
- * or if you've already provisioned the table some other way.
- *
FLYWAY — the starter registers a {@code FlywayConfigurationCustomizer} that
- * appends {@code classpath:db/api-log} to Flyway's locations, so the bundled
- * {@code V1.0__create_api_log.sql} runs alongside your own migrations and is
- * recorded in {@code flyway_schema_history}. Requires {@code org.flywaydb:flyway-core}
- * on the classpath (the starter declares it as optional, so the consumer must add it).
Direct {@code instanceof} works for the Spring Web (blocking)
- * hierarchy because we depend on {@code spring-web} unconditionally. For
- * Spring WebFlux's {@code WebClientResponseException}, we duck-type via
- * reflection — {@code spring-webflux} is an optional dependency on this
- * starter, so we can't import its types directly without forcing it onto
- * the classpath of consumers who only want the blocking client.
- */
- private HttpErrorInfo extractHttpErrorInfo(Throwable error) {
- if (error instanceof HttpStatusCodeException ex) {
- return new HttpErrorInfo(ex.getStatusCode().value(), ex.getResponseBodyAsString());
- }
- if (error instanceof RestClientResponseException ex) {
- return new HttpErrorInfo(ex.getStatusCode().value(), ex.getResponseBodyAsString());
- }
- // Match WebClientResponseException + its concrete subclasses (NotFound,
- // BadRequest, etc.) by package prefix so unrelated exceptions that
- // happen to share method names don't match.
- if (error.getClass().getName()
- .startsWith("org.springframework.web.reactive.function.client.WebClientResponseException")) {
- try {
- Object status = error.getClass().getMethod("getStatusCode").invoke(error);
- Integer statusValue = (Integer) status.getClass().getMethod("value").invoke(status);
- Object body = error.getClass().getMethod("getResponseBodyAsString").invoke(error);
- return new HttpErrorInfo(statusValue, body == null ? null : body.toString());
- } catch (ReflectiveOperationException ignored) {
- // Shape didn't match — fall through to EMPTY.
- }
- }
- return HttpErrorInfo.EMPTY;
- }
-
- /**
- * Build the structured error JSON written into the {@code error_message} column.
- *
- *