Audit LoggingAudit Logging

sự kiện audit mỗi ngàyaudit events a day

~3M

sự kiện audit mỗi ngàyaudit events a day

thời gian lưu cho dữ liệu tài chínhretention for financial data

7 năm

thời gian lưu cho dữ liệu tài chínhretention for financial data

tra lịch sử một đơn hàngto load one order's history

< 200 ms

tra lịch sử một đơn hàngto load one order's history

sự kiện bị mất hoặc bị sửaevents lost or altered

0

sự kiện bị mất hoặc bị sửaevents lost or altered

Service ghi thay đổi nghiệp vụ và một dòng audit_outbox trong cùng transaction. Relay (hoặc Debezium) đẩy sự kiện lên Kafka, Audit Writer chèn vào bảng audit_log chỉ cho INSERT, chia partition theo tháng. Bật “Xem lịch sử đơn hàng” để xem truy vấn; bật “Thử sửa dòng audit” để xem cơ sở dữ liệu từ chối.The service writes the business change and an audit_outbox row in one transaction. A relay (or Debezium) publishes the event to Kafka, and the Audit Writer inserts it into an INSERT-only audit_log table partitioned by month. Turn on “Order history” to see the query; turn on “Tamper attempt” to see the database refuse.

1. 1

   Ghi audit ở tầng nào?Where to capture changes

   Tầng service biết actor, lý do và tên hành động (PRICE_CHANGED) nên audit có ý nghĩa nghiệp vụ. JPA entity listener (@PostUpdate, Hibernate Envers) tự động nhưng chỉ thấy cột, không thấy ý định. Trigger DB bắt cả lệnh SQL tay nhưng không biết user ứng dụng. CDC (Debezium) đọc WAL, không đụng code, cũng thiếu actor nếu không có cột updated_by.The service layer knows the actor, the reason and the action name (PRICE_CHANGED), so entries carry business meaning. JPA entity listeners (@PostUpdate, Hibernate Envers) are automatic but see columns, not intent. DB triggers catch manual SQL too but do not know the application user. CDC (Debezium) reads the WAL without touching code, and also lacks the actor unless there is an updated_by column.

   ObserverDecorator
2. 2

   Mất audit khi ghi bất đồng bộLosing entries with async writes

   Gửi Kafka sau commit thì service có thể chết giữa chừng; ghi audit bằng @Async thì mất khi process dừng. Ghi audit_outbox trong cùng transaction, relay đẩy sau, Audit Writer idempotent theo event_id. Hệ thống nhỏ có thể INSERT thẳng audit_log trong transaction.Publishing to Kafka after commit can die halfway; an @Async audit write is lost when the process stops. Write audit_outbox in the same transaction, let a relay publish it, keep the Audit Writer idempotent on event_id. A small system can simply INSERT into audit_log inside the transaction.

   Transactional OutboxCommand
3. 3

   Dữ liệu nhạy cảm lọt vào auditSensitive data leaking into the audit

   Audit chụp nguyên đối tượng sẽ chép cả mật khẩu băm, số thẻ, token. Dùng danh sách trường cần che (password, card_number, national_id, token) áp lên cả before và after; số thẻ chỉ giữ 4 số cuối. Audit được giữ 7 năm nên rò rỉ ở đây rất lâu dài.Snapshotting the whole object copies password hashes, card numbers and tokens. Apply a mask list (password, card_number, national_id, token) to both before and after; keep only the last 4 digits of a card. Audit data lives for 7 years, so a leak here lasts a long time.

   Memento
4. 4

   Audit bị sửa hoặc xoáAudit rows being altered or deleted

   Role của ứng dụng chỉ có INSERT và SELECT; trigger BEFORE UPDATE OR DELETE chặn cả chủ bảng. Mỗi dòng lưu hash = sha256(prev_hash ‖ nội dung) nên sửa một dòng làm lệch cả chuỗi phía sau. Chuỗi hash cần một writer cho mỗi chuỗi (ví dụ một chuỗi trên mỗi partition Kafka).The application role has only INSERT and SELECT; a BEFORE UPDATE OR DELETE trigger stops even the owner. Each row stores hash = sha256(prev_hash ‖ content), so editing one row breaks the rest of the chain. A hash chain needs one writer per chain (for example one chain per Kafka partition).

   Repository
5. 5

   Bảng audit phình toThe audit table keeps growing

   3 triệu dòng mỗi ngày là khoảng 1 tỉ dòng mỗi năm. Chia partition theo tháng (pg_partman tạo trước), truy vấn luôn có khoảng thời gian để PostgreSQL bỏ qua partition không liên quan. Hết hạn lưu thì DETACH và DROP cả partition, hoặc xuất sang S3 Glacier trước khi xoá.3 million rows a day is about a billion rows a year. Partition by month (pg_partman creates them ahead), and always query with a time range so PostgreSQL prunes the other partitions. When retention ends, DETACH and DROP the whole partition, or export it to S3 Glacier first.

   Repository
6. 6

   Before/after lưu cả đối tượng hay chỉ phần đổi?Store the whole object or only the diff?

   Lưu cả đối tượng dễ đọc nhưng tốn chỗ và dễ dính trường nhạy cảm. Lưu phần khác biệt (các trường đã đổi) gọn hơn, đủ để trả lời “ai đổi gì”. Cột JSONB cho phép thêm trường mới mà không đổi schema.Storing whole objects is easy to read but costs space and drags in sensitive fields. Storing the diff (changed fields only) is compact and enough to answer “who changed what”. A JSONB column lets new fields appear without schema changes.

   Memento

Service chụp giá trị trước, áp thay đổi, che trường nhạy cảm và ghi sự kiện audit vào outbox trong cùng transaction. File SQL tạo bảng chia partition, chỉ cấp INSERT/SELECT và chặn UPDATE/DELETE bằng trigger.The service snapshots the old values, applies the change, masks sensitive fields and writes the audit event to the outbox in the same transaction. The SQL file creates the partitioned table, grants only INSERT/SELECT and blocks UPDATE/DELETE with a trigger.

@Service
@RequiredArgsConstructor
public class ProductAdminService {
    private final ProductRepository products;
    private final AuditOutboxRepository outbox;
    private final CurrentRequest request;          // actor + ip from the security context

    @Transactional1
    public Product changePrice(long id, BigDecimal newPrice) {
        Product p = products.findByIdForUpdate(id).orElseThrow();
        Map<String, Object> before = Map.of("price", p.getPrice());2
        p.setPrice(newPrice);
        Map<String, Object> after = Map.of("price", newPrice);
        outbox.save(AuditEvent.of(request.actor(), "PRICE_CHANGED",
                "product", String.valueOf(id), before, after, request.ip()));3
        return p;                                   // UPDATE + outbox INSERT, one commit
    }
}

record AuditEvent(UUID eventId, String actor, String action, String entity, String entityId,
                  Map<String, Object> before, Map<String, Object> after, String ip, Instant at) {
    private static final Set<String> SECRET = Set.of("password", "cardNumber", "nationalId", "token");

    static AuditEvent of(String actor, String action, String entity, String id,
                         Map<String, Object> before, Map<String, Object> after, String ip) {
        return new AuditEvent(UUID.randomUUID(), actor, action, entity, id,
                mask(before), mask(after), ip, Instant.now());
    }

    static Map<String, Object> mask(Map<String, Object> m) {
        Map<String, Object> out = new LinkedHashMap<>(m);
        out.replaceAll((k, v) -> SECRET.contains(k) ? "***" : v);4
        return out;
    }
}

var secret = map[string]bool{"password": true, "card_number": true, "national_id": true, "token": true}

func mask(m map[string]any) map[string]any {
	out := make(map[string]any, len(m))
	for k, v := range m {
		if secret[k] {
			v = "***"
		}
		out[k] = v
	}
	return out
}

type ProductAdmin struct{ tx TxRunner }

func (s *ProductAdmin) ChangePrice(ctx context.Context, id int64, price decimal.Decimal) error {
	actor, ip := auth.ActorFrom(ctx), auth.IPFrom(ctx)1
	return s.tx.Do(ctx, func(tx Tx) error {2
		p, err := tx.LockProduct(ctx, id) // SELECT … FOR UPDATE
		if err != nil {
			return err
		}
		if err := tx.UpdatePrice(ctx, id, price); err != nil {
			return err
		}
		ev := AuditEvent{
			EventID:  uuid.New(),
			Actor:    actor,
			Action:   "PRICE_CHANGED",
			Entity:   "product",
			EntityID: strconv.FormatInt(id, 10),
			Before:   mask(map[string]any{"price": p.Price}),
			After:    mask(map[string]any{"price": price}),
			IP:       ip,
			At:       time.Now().UTC(),
		}
		return tx.InsertAuditOutbox(ctx, ev) // same commit as the UPDATE3
	})
}

// Audit Writer: Kafka may redeliver, the unique key makes it harmless.
func (w *AuditWriter) Handle(ctx context.Context, ev AuditEvent) error {
	prev, err := w.store.LastHash(ctx, ev.Chain())
	if err != nil {
		return err
	}
	h := sha256.Sum256(append(prev, ev.Canonical()...))4
	return w.store.Insert(ctx, ev, prev, h[:]) // ON CONFLICT (event_id, at) DO NOTHING
}

Mỗi pattern mở bài học tương ứng trong menu Pattern.Each one opens its lesson in the Patterns menu.