@sun-asterisk/sunlint 1.3.47 → 1.3.49

package/skill-assets/sunlint-code-quality/rules/swift/C033-separate-data-access.md

@@ -0,0 +1,89 @@
+---
+title: Tách biệt logic xử lý và truy cập dữ liệu trong tầng service
+impact: HIGH
+impactDescription: Kết hợp logic nghiệp vụ và data access trong cùng một class làm khó test, khó thay đổi storage layer và vi phạm Single Responsibility.
+tags: swift, ios, architecture, repository-pattern, service, code-quality
+---
+
+## Tách biệt logic xử lý và truy cập dữ liệu trong tầng service
+
+ViewModel/Presenter không nên gọi trực tiếp Core Data, UserDefaults, hay network. Tách thành **Repository** (data access) và **UseCase/Service** (business logic). Điều này tuân theo kiến trúc Clean Architecture được Apple khuyến nghị.
+
+**Incorrect (trộn lẫn nghiệp vụ và data access):**
+
+```swift
+class OrderViewModel {
+    func placeOrder(items: [CartItem], userId: String) {
+        // Gọi API trực tiếp trong ViewModel
+        let request = URLRequest(url: URL(string: "https://api.example.com/orders")!)
+        URLSession.shared.dataTask(with: request) { data, _, error in
+            // Xử lý JSON thủ công trong ViewModel
+            guard let data = data,
+                  let order = try? JSONDecoder().decode(Order.self, from: data) else { return }
+
+            // Lưu Core Data trực tiếp trong ViewModel
+            let context = (UIApplication.shared.delegate as! AppDelegate).persistentContainer.viewContext
+            let entity = OrderEntity(context: context)
+            entity.id = order.id
+            try? context.save()
+        }.resume()
+    }
+}
+```
+
+**Correct (Repository + UseCase tách biệt):**
+
+```swift
+// Repository: chỉ lo data access
+protocol OrderRepositoryProtocol {
+    func createOrder(request: CreateOrderRequest) async throws -> Order
+    func saveOrderLocally(_ order: Order) throws
+}
+
+class OrderRepository: OrderRepositoryProtocol {
+    private let apiClient: APIClientProtocol
+    private let coreDataManager: CoreDataManagerProtocol
+
+    init(apiClient: APIClientProtocol, coreDataManager: CoreDataManagerProtocol) {
+        self.apiClient = apiClient
+        self.coreDataManager = coreDataManager
+    }
+
+    func createOrder(request: CreateOrderRequest) async throws -> Order {
+        return try await apiClient.post("/orders", body: request)
+    }
+
+    func saveOrderLocally(_ order: Order) throws {
+        try coreDataManager.insert(order, entityType: OrderEntity.self)
+    }
+}
+
+// UseCase: chỉ lo nghiệp vụ
+class PlaceOrderUseCase {
+    private let orderRepository: OrderRepositoryProtocol
+    private let inventoryService: InventoryServiceProtocol
+
+    func execute(items: [CartItem], userId: String) async throws -> Order {
+        // Kiểm tra tồn kho
+        try await inventoryService.validateAvailability(items: items)
+        let request = CreateOrderRequest(items: items, userId: userId)
+        let order = try await orderRepository.createOrder(request: request)
+        try orderRepository.saveOrderLocally(order)
+        return order
+    }
+}
+
+// ViewModel: chỉ gọi UseCase
+class OrderViewModel {
+    private let placeOrderUseCase: PlaceOrderUseCase
+
+    func placeOrder(items: [CartItem]) async {
+        do {
+            order = try await placeOrderUseCase.execute(items: items, userId: currentUserId)
+        } catch { /* handle */ }
+    }
+}
+```
+
+**Tools:** Code Review, Unit Tests (mock repository dễ dàng)
+

package/skill-assets/sunlint-code-quality/rules/swift/C035-error-context-logging.md

@@ -0,0 +1,66 @@
+---
+title: Log đầy đủ context khi xử lý lỗi
+impact: HIGH
+impactDescription: Thiếu context trong log làm mất khả năng correlate sự kiện, không tái hiện được lỗi production và tăng MTTR (Mean Time To Resolve).
+tags: swift, ios, logging, error-handling, debugging, observability
+---
+
+## Log đầy đủ context khi xử lý lỗi
+
+Khi log lỗi, phải bao gồm: định danh entity (userId, orderId), action đang thực hiện, loại lỗi cụ thể. Dùng `os.Logger` với privacy annotation để tránh log PII ra console.
+
+**Incorrect (log thiếu context):**
+
+```swift
+private let logger = Logger()
+
+func processPayment(_ payment: Payment) async {
+    do {
+        try await paymentService.charge(payment)
+    } catch {
+        logger.error("Payment failed")  // !! Không biết payment nào, tại sao?
+    }
+}
+
+func syncUserData() async {
+    do {
+        try await syncService.fullSync()
+    } catch {
+        print("Sync error: \(error)")  // print thay vì logger, không có user context
+    }
+}
+```
+
+**Correct (log đầy đủ context với privacy):**
+
+```swift
+import OSLog
+
+private let logger = Logger(subsystem: "com.app.payment", category: "Processing")
+
+func processPayment(_ payment: Payment) async {
+    do {
+        try await paymentService.charge(payment)
+        logger.info("Payment succeeded. paymentId=\(payment.id, privacy: .public), amount=\(payment.amount)")
+    } catch PaymentError.insufficientFunds {
+        // Lỗi business - warning
+        logger.warning("Insufficient funds. paymentId=\(payment.id, privacy: .public), userId=\(payment.userId, privacy: .private)")
+    } catch PaymentError.cardDeclined(let code) {
+        logger.error("Card declined. paymentId=\(payment.id, privacy: .public), declineCode=\(code, privacy: .public)")
+    } catch {
+        // Lỗi không ngờ - error level với full context
+        logger.error("Unexpected payment failure. paymentId=\(payment.id, privacy: .public), error=\(error.localizedDescription, privacy: .public)")
+    }
+}
+```
+
+**Privacy annotation cho os.Logger:**
+
+| Annotation | Khi nào dùng |
+|-----------|-------------|
+| `.public` | ID kỹ thuật, error code (an toàn để log) |
+| `.private` | Email, tên, phone (ẩn trong log, chỉ hiện khi debug) |
+| `.sensitive` | Token, mật khẩu (luôn ẩn) |
+
+**Tools:** `os.Logger` với Privacy API, Code Review
+

package/skill-assets/sunlint-code-quality/rules/swift/C041-no-hardcoded-secrets.md

@@ -0,0 +1,65 @@
+---
+title: Không hardcode thông tin nhạy cảm trong source code
+impact: CRITICAL
+impactDescription: Secret hardcode trong source sẽ bị lộ qua Git history, binary dump hay reverse engineering, gây rò rỉ toàn bộ hệ thống.
+tags: swift, ios, secrets, security, api-keys, hardcoded
+---
+
+## Không hardcode thông tin nhạy cảm trong source code
+
+API key, token, password, private key không được viết trực tiếp trong `.swift` file hay `.plist`. Dùng biến môi trường (CI/CD), `.xcconfig` file (không commit), hay Keychain để lưu runtime secrets.
+
+**Incorrect (hardcode secrets):**
+
+```swift
+// !! API key visible trong source code
+struct APIConfig {
+    static let apiKey = "sk_live_AbC123XyZ789"
+    static let secretToken = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9..."
+    static let databasePassword = "MyS3cr3tPass!"
+}
+
+class AnalyticsService {
+    private let firebaseKey = "AIzaSyC-abc123-real-key"  // hardcode
+    private let mixpanelToken = "a1b2c3d4e5f6"            // hardcode
+}
+```
+
+**Correct (lấy secret từ xcconfig hay environment):**
+
+```swift
+// Config.xcconfig (được thêm vào .gitignore)
+// API_KEY = sk_live_AbC123XyZ789
+
+// Info.plist (đọc giá trị từ xcconfig - không commit secret)
+// <key>APIKey</key>
+// <string>$(API_KEY)</string>
+
+struct APIConfig {
+    // Đọc từ Info.plist (value đến từ xcconfig không commit)
+    static var apiKey: String {
+        Bundle.main.infoDictionary?["APIKey"] as? String ?? ""
+    }
+}
+
+// Secrets nhạy cảm hơn (user token, refresh token) - lưu Keychain
+class TokenManager {
+    func saveAccessToken(_ token: String) throws {
+        try KeychainManager.save(key: "access_token", value: token)
+    }
+
+    func retrieveAccessToken() -> String? {
+        return try? KeychainManager.load(key: "access_token")
+    }
+}
+```
+
+**Kiểm tra trước khi commit:**
+
+```bash
+# Dùng git-secrets hoặc truffleHog để scan
+git secrets --scan
+```
+
+**Tools:** `git-secrets`, `truffleHog`, `.gitignore` cho `.xcconfig`, SwiftLint custom rule
+

package/skill-assets/sunlint-code-quality/rules/swift/C042-boolean-naming.md

@@ -0,0 +1,60 @@
+---
+title: Biến Boolean phải bắt đầu bằng is, has, hoặc should
+impact: LOW
+impactDescription: Tiền tố is/has/should làm rõ biến là kiểu Boolean, tránh nhầm lẫn với biến trạng thái khác và cải thiện tính đọc của code.
+tags: swift, ios, naming, boolean, code-quality, readability
+---
+
+## Biến Boolean phải bắt đầu bằng is, has, hoặc should
+
+Property/biến kiểu `Bool` phải có tên bắt đầu bằng `is`, `has`, `should`, `can`, `will` hoặc `allow`. Điều này là convention của Swift API Design Guidelines.
+
+**Incorrect (tên Boolean không rõ):**
+
+```swift
+class UserSession {
+    var login: Bool = false          // isLoggedIn?
+    var premium: Bool = false        // isPremium?
+    var notification: Bool = true    // hasNotification? isNotificationEnabled?
+    var error: Bool = false          // hasError?
+    var loaded: Bool = false         // isLoaded?
+}
+
+struct FeatureFlags {
+    var darkMode: Bool = false       // isDarkModeEnabled?
+    var biometric: Bool = false      // isBiometricEnabled?
+    var analytics: Bool = true       // shouldTrackAnalytics?
+}
+```
+
+**Correct (tên Boolean rõ ràng):**
+
+```swift
+class UserSession {
+    var isLoggedIn: Bool = false
+    var isPremiumUser: Bool = false
+    var hasUnreadNotifications: Bool = true
+    var hasError: Bool = false
+    var isDataLoaded: Bool = false
+}
+
+struct FeatureFlags {
+    var isDarkModeEnabled: Bool = false
+    var isBiometricEnabled: Bool = false
+    var shouldTrackAnalytics: Bool = true
+    var canAccessPremiumContent: Bool = false
+    var willShowOnboarding: Bool = true
+}
+
+// SwiftUI @State
+struct ContentView: View {
+    @State private var isShowingAlert = false
+    @State private var isLoading = false
+    @State private var hasCompletedOnboarding = false
+
+    var body: some View { ... }
+}
+```
+
+**Tools:** SwiftLint (`identifier_name`), Code Review
+

package/skill-assets/sunlint-code-quality/rules/swift/C052-controller-parsing.md

@@ -0,0 +1,67 @@
+---
+title: Không để logic parsing/mapping trong ViewController
+impact: HIGH
+impactDescription: Logic phân tích dữ liệu trong ViewController làm phình to class, khó test và vi phạm Single Responsibility Principle.
+tags: swift, ios, mvc, mvvm, viewcontroller, parsing, architecture
+---
+
+## Không để logic parsing/mapping trong ViewController
+
+ViewController chỉ nên lo presentation: bind data lên UI, xử lý user interaction. Logic parse JSON, map model sang ViewModel, validate, hay transform dữ liệu phải nằm trong tầng riêng (ViewModel, Mapper, UseCase).
+
+**Incorrect (parsing/mapping trong ViewController):**
+
+```swift
+class OrderListViewController: UIViewController {
+
+    // !! Logic mapping trong VC
+    func configureCell(_ cell: OrderCell, with orderData: [String: Any]) {
+        let id = orderData["id"] as? String ?? ""
+        let status = orderData["status"] as? String ?? "unknown"
+        let amount = orderData["total_amount"] as? Double ?? 0.0
+        let dateString = orderData["created_at"] as? String ?? ""
+
+        // Date parsing trực tiếp trong VC
+        let formatter = ISO8601DateFormatter()
+        let date = formatter.date(from: dateString) ?? Date()
+        let displayDate = DateFormatter.medium.string(from: date)
+
+        cell.orderIdLabel.text = "#\(id)"
+        cell.statusLabel.text = status.capitalized
+        cell.amountLabel.text = "$\(String(format: "%.2f", amount))"
+        cell.dateLabel.text = displayDate
+    }
+}
+```
+
+**Correct (VC chỉ bind, ViewModel lo mapping):**
+
+```swift
+// OrderViewModel - lo mapping và formatting
+struct OrderViewModel {
+    let displayId: String
+    let statusText: String
+    let formattedAmount: String
+    let displayDate: String
+
+    init(order: Order) {
+        self.displayId = "#\(order.id)"
+        self.statusText = order.status.localizedTitle
+        self.formattedAmount = NumberFormatter.currency.string(from: NSNumber(value: order.totalAmount)) ?? ""
+        self.displayDate = DateFormatter.medium.string(from: order.createdAt)
+    }
+}
+
+// ViewController - chỉ bind data lên UI
+class OrderListViewController: UIViewController {
+    func configureCell(_ cell: OrderCell, with viewModel: OrderViewModel) {
+        cell.orderIdLabel.text = viewModel.displayId
+        cell.statusLabel.text = viewModel.statusText
+        cell.amountLabel.text = viewModel.formattedAmount
+        cell.dateLabel.text = viewModel.displayDate
+    }
+}
+```
+
+**Tools:** Code Review, Unit Tests (ViewModel test không cần UIKit)
+

package/skill-assets/sunlint-code-quality/rules/swift/C060-superclass-logic.md

@@ -0,0 +1,95 @@
+---
+title: Không đặt quá nhiều logic trong superclass
+impact: MEDIUM
+impactDescription: Superclass phình to tạo coupling cao giữa subclasses, khó bảo trì và dễ vô tình break subclass khi thay đổi base class.
+tags: swift, ios, inheritance, superclass, composition, architecture
+---
+
+## Không đặt quá nhiều logic trong superclass
+
+Thay vì nhồi logic vào `BaseViewController` hay `BaseViewModel`, hãy dùng **composition** qua protocol extension hoặc delegate. Superclass chỉ nên chứa logic thực sự chung cho mọi subclass.
+
+**Incorrect (BaseViewController quá nặng):**
+
+```swift
+class BaseViewController: UIViewController {
+    // Networking
+    func makeAPICall<T>(url: URL, completion: @escaping (Result<T, Error>) -> Void) { ... }
+
+    // Analytics
+    func trackScreenView(name: String) { ... }
+    func trackEvent(_ event: String, parameters: [String: Any]) { ... }
+
+    // Loading
+    func showLoading() { ... }
+    func hideLoading() { ... }
+
+    // Alert
+    func showAlert(title: String, message: String) { ... }
+    func showErrorAlert(_ error: Error) { ... }
+
+    // Navigation
+    func pushViewController(_ vc: UIViewController, animated: Bool) { ... }
+
+    // Keyboard
+    func setupKeyboardDismissal() { ... }
+    var keyboardHeight: CGFloat { ... }
+
+    // Tất cả ViewController đều kế thừa hết dù không cần!
+}
+```
+
+**Correct (composition qua protocol + extension):**
+
+```swift
+// Tách thành protocol có thể opt-in
+protocol LoadingDisplayable: UIViewController {
+    func showLoading()
+    func hideLoading()
+}
+
+extension LoadingDisplayable {
+    func showLoading() {
+        LoadingOverlay.show(in: view)
+    }
+    func hideLoading() {
+        LoadingOverlay.hide(from: view)
+    }
+}
+
+protocol ErrorAlertDisplayable: UIViewController {
+    func showErrorAlert(_ error: Error)
+}
+extension ErrorAlertDisplayable {
+    func showErrorAlert(_ error: Error) {
+        let alert = UIAlertController(title: "Lỗi", message: error.localizedDescription, preferredStyle: .alert)
+        alert.addAction(UIAlertAction(title: "OK", style: .default))
+        present(alert, animated: true)
+    }
+}
+
+// BaseViewController chỉ giữ thứ thực sự dùng ở MỌI VC
+class BaseViewController: UIViewController {
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        setupNavigationBar()
+    }
+    private func setupNavigationBar() { /* common nav bar style */ }
+}
+
+// Từng VC chỉ opt-in vào tính năng cần
+class OrderListViewController: BaseViewController, LoadingDisplayable, ErrorAlertDisplayable {
+    func loadOrders() async {
+        showLoading()
+        defer { hideLoading() }
+        do {
+            orders = try await orderService.fetchOrders()
+        } catch {
+            showErrorAlert(error)
+        }
+    }
+}
+```
+
+**Tools:** Code Review, SwiftLint (`type_body_length`)
+

package/skill-assets/sunlint-code-quality/rules/swift/C067-no-hardcoded-config.md

@@ -0,0 +1,80 @@
+---
+title: Không hardcode cấu hình trong code - dùng xcconfig hoặc environment
+impact: MEDIUM
+impactDescription: Config hardcode làm khó switch giữa môi trường development/staging/production và dễ gây lỗi khi deploy.
+tags: swift, ios, configuration, environment, xcconfig, code-quality
+---
+
+## Không hardcode cấu hình trong code - dùng xcconfig hoặc environment
+
+URL của API, timeout, feature flags, và các thông số khác biệt giữa môi trường không được hardcode. Dùng `.xcconfig` file theo scheme, đọc qua `Info.plist`, hoặc dùng build setting `$(VAR_NAME)`.
+
+**Incorrect (config hardcode):**
+
+```swift
+class APIClient {
+    // !! Hardcode URL - phải sửa code khi switch môi trường
+    private let baseURL = "https://api.example.com/v2"
+    private let timeout: TimeInterval = 30
+
+    init() {
+        // !! Hardcode môi trường
+        #if DEBUG
+        let url = "https://dev-api.example.com/v2"
+        #else
+        let url = "https://api.example.com/v2"
+        #endif
+    }
+}
+
+struct Config {
+    static let maxRetries = 3      // magic number
+    static let sessionTimeout = 1800  // 30 phút? hardcode
+}
+```
+
+**Correct (đọc từ xcconfig / Info.plist theo scheme):**
+
+```swift
+// Development.xcconfig
+// API_BASE_URL = https://dev-api.example.com/v2
+// REQUEST_TIMEOUT = 30
+// MAX_RETRIES = 3
+
+// Production.xcconfig
+// API_BASE_URL = https://api.example.com/v2
+// REQUEST_TIMEOUT = 15
+// MAX_RETRIES = 2
+
+// Info.plist
+// <key>APIBaseURL</key><string>$(API_BASE_URL)</string>
+// <key>RequestTimeout</key><string>$(REQUEST_TIMEOUT)</string>
+
+struct AppConfiguration {
+    static var apiBaseURL: URL {
+        guard let urlString = Bundle.main.infoDictionary?["APIBaseURL"] as? String,
+              let url = URL(string: urlString) else {
+            fatalError("APIBaseURL configuration missing")
+        }
+        return url
+    }
+
+    static var requestTimeout: TimeInterval {
+        let value = Bundle.main.infoDictionary?["RequestTimeout"] as? String
+        return Double(value ?? "30") ?? 30
+    }
+
+    static var maxRetries: Int {
+        let value = Bundle.main.infoDictionary?["MaxRetries"] as? String
+        return Int(value ?? "3") ?? 3
+    }
+}
+
+class APIClient {
+    private let baseURL = AppConfiguration.apiBaseURL
+    private let timeout = AppConfiguration.requestTimeout
+}
+```
+
+**Tools:** Xcode Build Schemes + xcconfig, `Configuration.swift` helper
+

package/skill-assets/sunlint-code-quality/rules/swift/S003-sql-injection.md

@@ -0,0 +1,65 @@
+---
+title: Tránh SQL Injection khi dùng SQLite, FMDB hoặc CoreData NSPredicate
+impact: CRITICAL
+impactDescription: Ghép chuỗi trực tiếp vào câu lệnh SQL hoặc NSPredicate format string cho phép attacker đọc, xóa hoặc sửa toàn bộ database của app.
+tags: swift, ios, sql-injection, sqlite, fmdb, coredata, nspredicate, security
+---
+
+## Tránh SQL Injection khi dùng SQLite, FMDB hoặc CoreData NSPredicate
+
+Trong iOS, SQL injection xảy ra khi ghép chuỗi trực tiếp vào câu lệnh SQLite/FMDB, hoặc dùng `NSPredicate(format:)` với giá trị người dùng chưa được escape. Phải dùng parameterized query hoặc `NSPredicate(format:argumentArray:)`.
+
+**Incorrect (ghép chuỗi trực tiếp):**
+
+```swift
+import FMDB
+
+// !! Ghép chuỗi tên đăng nhập trực tiếp vào SQL
+func findUser(username: String, db: FMDatabase) -> [String: Any]? {
+    let query = "SELECT * FROM users WHERE username = '\(username)'"  // SQL Injection!
+    let result = db.executeQuery(query, withArgumentsIn: [])
+    return nil
+}
+
+// !! NSPredicate với format string không an toàn
+func fetchMessages(senderName: String, context: NSManagedObjectContext) -> [Message] {
+    let predicate = NSPredicate(format: "sender == '\(senderName)'")  // Injection!
+    let request = Message.fetchRequest()
+    request.predicate = predicate
+    return (try? context.fetch(request)) ?? []
+}
+```
+
+**Correct (parameterized query):**
+
+```swift
+import FMDB
+
+// SAFE: Dùng parameterized query với ?
+func findUser(username: String, db: FMDatabase) -> FMResultSet? {
+    let query = "SELECT * FROM users WHERE username = ?"
+    return db.executeQuery(query, withArgumentsIn: [username])
+}
+
+// SAFE: NSPredicate với argumentArray
+func fetchMessages(senderName: String, context: NSManagedObjectContext) -> [Message] {
+    let predicate = NSPredicate(format: "sender == %@", argumentArray: [senderName])
+    let request = Message.fetchRequest()
+    request.predicate = predicate
+    return (try? context.fetch(request)) ?? []
+}
+
+// SAFE: SQLite3 với bound parameters
+func insertNote(title: String, body: String, db: OpaquePointer) {
+    var stmt: OpaquePointer?
+    let sql = "INSERT INTO notes (title, body) VALUES (?, ?)"
+    if sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK {
+        sqlite3_bind_text(stmt, 1, (title as NSString).utf8String, -1, nil)
+        sqlite3_bind_text(stmt, 2, (body as NSString).utf8String, -1, nil)
+        sqlite3_step(stmt)
+    }
+    sqlite3_finalize(stmt)
+}
+```
+
+**Tools:** SwiftLint custom rule, OWASP MASVS-CODE-4, Instruments (SQLite profiler)

package/skill-assets/sunlint-code-quality/rules/swift/S004-no-log-credentials.md

@@ -0,0 +1,67 @@
+---
+title: Không log thông tin nhạy cảm (token, password, PII)
+impact: HIGH
+impactDescription: Log trong iOS có thể đọc được qua Console.app, thiết bị bị jailbreak, hoặc crash logs gửi lên server. Credentials trong log đồng nghĩa với data breach.
+tags: swift, ios, logging, security, credentials, privacy, pii
+---
+
+## Không log thông tin nhạy cảm (token, password, PII)
+
+`NSLog`, `print()`, và `os_log` đều có thể bị capture bởi tool như Console.app hoặc bởi attacker khi thiết bị bị jailbreak. Không bao giờ log: password, access token, refresh token, thẻ tín dụng, số CMND/CCCD, hay thông tin cá nhân nhạy cảm.
+
+**Incorrect (log thông tin nhạy cảm):**
+
+```swift
+func login(email: String, password: String) async {
+    print("Attempting login with email: \(email), password: \(password)")  // !! password trong log
+
+    do {
+        let response = try await authService.login(email: email, password: password)
+        // !! Token trong log
+        NSLog("Login success. accessToken: %@, refreshToken: %@", response.accessToken, response.refreshToken)
+
+        UserDefaults.standard.set(response.accessToken, forKey: "access_token")
+    } catch {
+        // !! Email trong log
+        logger.error("Login failed for email: \(email), error: \(error)")
+    }
+}
+
+func processPayment(cardNumber: String, cvv: String) {
+    logger.info("Processing card: \(cardNumber), CVV: \(cvv)")  // !! PCI DSS violation
+}
+```
+
+**Correct (log không chứa thông tin nhạy cảm):**
+
+```swift
+import OSLog
+
+private let logger = Logger(subsystem: "com.app.auth", category: "Authentication")
+
+func login(email: String, password: String) async {
+    // Log action không log credentials
+    logger.info("Login attempt initiated")
+
+    do {
+        let response = try await authService.login(email: email, password: password)
+        // Chỉ log metadata - không log token value
+        logger.info("Login succeeded. userId=\(response.userId, privacy: .public), tokenExpiry=\(response.expiresIn)")
+
+        // Lưu token vào Keychain, không log
+        try tokenManager.saveAccessToken(response.accessToken)
+    } catch {
+        // Log loại lỗi, không log email
+        logger.warning("Login failed: \(error.localizedDescription, privacy: .public)")
+    }
+}
+
+func processPayment(cardNumber: String, cvv: String) {
+    // Chỉ log metadata về payment, không log card data
+    let maskedCard = String(cardNumber.suffix(4))
+    logger.info("Processing payment for card ending in \(maskedCard, privacy: .public)")
+}
+```
+
+**Tools:** Code Review, `os.Logger` privacy API, MobSF static analysis
+