Tracker module extracted

Author: MartinCardozo-SDK

Sources/PeriodicRecorderWorker/Atomic.swift

@@ -0,0 +1,51 @@
+//
+//  Atomic.swift
+//  PeriodicRecorderWorker
+//
+//  Created by Javier L. Avrudsky on 13/08/2020.
+//  Copyright © 2020 Split. All rights reserved.
+//
+
+import Foundation
+
+/// Thread-safe wrapper for any value type
+public final class Atomic<T>: @unchecked Sendable {
+    private var currentValue: T
+    private var lock = NSLock()
+
+    public init(_ value: T) {
+        self.currentValue = value
+    }
+
+    public var value: T {
+        lock.lock()
+        defer { lock.unlock() }
+        return self.currentValue
+    }
+
+    public func mutate(_ transformation: (inout T) -> Void) {
+        lock.lock()
+        transformation(&self.currentValue)
+        lock.unlock()
+    }
+
+    public func mutate(_ transformation: (T, inout T) -> Void) {
+        lock.lock()
+        transformation(currentValue, &self.currentValue)
+        lock.unlock()
+    }
+
+    public func getAndSet(_ newValue: T) -> T {
+        lock.lock()
+        defer { lock.unlock() }
+        let oldValue = self.currentValue
+        self.currentValue = newValue
+        return oldValue
+    }
+
+    public func set(_ newValue: T) {
+        lock.lock()
+        self.currentValue = newValue
+        lock.unlock()
+    }
+}

Sources/Tracker/README.md

@@ -0,0 +1,100 @@
+# Tracker
+
+A module that provides event tracking functionality with validation and logging.
+
+## Overview
+
+This module contains:
+- `Tracker` - Protocol and implementation for tracking events
+- `TrackerEvent` - Event data model
+- `TrackerEventValidator` - Protocol for event validation
+- `TrackerPropertyValidator` - Protocol for property validation
+- `TrackerLogger` - Protocol for logging
+
+## Usage
+
+```swift
+import Tracker
+
+// Create validator implementations
+class MyEventValidator: TrackerEventValidator {
+    func validate(key: String?, trafficTypeName: String?, eventTypeId: String?,
+                  value: Double?, properties: [String: Any]?,
+                  isSdkReady: Bool) -> TrackerValidationError? {
+        // Your validation logic
+        return nil
+    }
+}
+
+class MyPropertyValidator: TrackerPropertyValidator {
+    func validate(properties: [String: Any]?,
+                  initialSizeInBytes: Int,
+                  validationTag: String) -> TrackerPropertyResult {
+        return TrackerPropertyResult.valid(properties: properties, sizeInBytes: 0)
+    }
+}
+
+class MyLogger: TrackerLogger {
+    func log(errorInfo: TrackerValidationError, tag: String) { }
+    func e(message: String, tag: String) { }
+    func v(_ message: String) { }
+}
+
+// Create the tracker with closures for event push and telemetry
+let tracker = DefaultTracker(
+    defaultTrafficType: "user",
+    initialEventSizeInBytes: 1024,
+    eventValidator: MyEventValidator(),
+    propertyValidator: MyPropertyValidator(),
+    logger: MyLogger(),
+    onEventPush: { event in
+        // Handle the event (e.g., send to server)
+        print("Event pushed: \(event.eventType)")
+    },
+    onTrackLatency: { latency in
+        // Record telemetry
+        print("Track latency: \(latency)ms")
+    }
+)
+
+// Track an event
+let success = tracker.track(
+    eventType: "purchase",
+    trafficType: nil, // Uses defaultTrafficType
+    value: 99.99,
+    properties: ["item": "widget"],
+    matchingKey: "user123",
+    isSdkReady: true
+)
+```
+
+## Components
+
+### Tracker
+
+Protocol defining the tracking interface:
+- `isTrackingEnabled` - Enable/disable tracking
+- `track(...)` - Track an event
+
+### TrackerEvent
+
+Data model for events:
+- `trafficType` - Traffic type name
+- `eventType` - Event type identifier
+- `key` - Matching key
+- `value` - Optional numeric value
+- `timestamp` - Event timestamp
+- `properties` - Optional properties dictionary
+- `sizeInBytes` - Size of the event
+
+### TrackerEventValidator
+
+Protocol for validating events before tracking.
+
+### TrackerPropertyValidator
+
+Protocol for validating event properties.
+
+### TrackerLogger
+
+Protocol for logging validation errors and messages.

Sources/Tracker/Tests/TrackerTest.swift

@@ -0,0 +1,177 @@
+//  TrackerTests
+//  Copyright © 2022 Split. All rights reserved.
+
+import XCTest
+@testable import Tracker
+
+class TrackerTest: XCTestCase {
+
+    var tracker: Tracker!
+    var eventValidator: TrackerEventValidatorStub!
+    var propertyValidator: TrackerPropertyValidatorStub!
+    var logger: TrackerLoggerStub!
+    var pushedEvents: [TrackerEvent] = []
+    var recordedLatencies: [Int64] = []
+
+    override func setUp() {
+        eventValidator = TrackerEventValidatorStub()
+        propertyValidator = TrackerPropertyValidatorStub()
+        logger = TrackerLoggerStub()
+        pushedEvents = []
+        recordedLatencies = []
+
+        tracker = DefaultTracker(
+            defaultTrafficType: "user",
+            initialEventSizeInBytes: 1024,
+            eventValidator: eventValidator,
+            propertyValidator: propertyValidator,
+            logger: logger,
+            onEventPush: { [weak self] event in
+                self?.pushedEvents.append(event)
+            },
+            onTrackLatency: { [weak self] latency in
+                self?.recordedLatencies.append(latency)
+            }
+        )
+    }
+
+    func testTrackEnabled() {
+        tracker.isTrackingEnabled = true
+        propertyValidator.result = TrackerPropertyResult.valid(properties: nil, sizeInBytes: 100)
+
+        let result = tracker.track(
+            eventType: "test_event",
+            trafficType: "test_tt",
+            value: nil,
+            properties: nil,
+            matchingKey: "key1",
+            isSdkReady: true
+        )
+
+        XCTAssertTrue(result)
+        XCTAssertEqual(pushedEvents.count, 1)
+        XCTAssertEqual(recordedLatencies.count, 1)
+    }
+
+    func testTrackDisabled() {
+        tracker.isTrackingEnabled = false
+
+        let result = tracker.track(
+            eventType: "test_event",
+            trafficType: "test_tt",
+            value: nil,
+            properties: nil,
+            matchingKey: "key1",
+            isSdkReady: true
+        )
+
+        XCTAssertFalse(result)
+        XCTAssertEqual(pushedEvents.count, 0)
+        XCTAssertEqual(recordedLatencies.count, 0)
+    }
+
+    func testTrackWithValidationError() {
+        tracker.isTrackingEnabled = true
+        eventValidator.validationError = TrackerValidationError(isError: true, message: "Invalid key")
+
+        let result = tracker.track(
+            eventType: "test_event",
+            trafficType: "test_tt",
+            value: nil,
+            properties: nil,
+            matchingKey: "key1",
+            isSdkReady: true
+        )
+
+        XCTAssertFalse(result)
+        XCTAssertEqual(pushedEvents.count, 0)
+    }
+
+    func testTrackWithPropertyValidationError() {
+        tracker.isTrackingEnabled = true
+        propertyValidator.result = TrackerPropertyResult.invalid(message: "Properties too large", sizeInBytes: 50000)
+
+        let result = tracker.track(
+            eventType: "test_event",
+            trafficType: "test_tt",
+            value: nil,
+            properties: ["key": "value"],
+            matchingKey: "key1",
+            isSdkReady: true
+        )
+
+        XCTAssertFalse(result)
+        XCTAssertEqual(pushedEvents.count, 0)
+    }
+
+    func testTrackUsesDefaultTrafficType() {
+        tracker.isTrackingEnabled = true
+        propertyValidator.result = TrackerPropertyResult.valid(properties: nil, sizeInBytes: 100)
+
+        let result = tracker.track(
+            eventType: "test_event",
+            trafficType: nil,
+            value: nil,
+            properties: nil,
+            matchingKey: "key1",
+            isSdkReady: true
+        )
+
+        XCTAssertTrue(result)
+        XCTAssertEqual(pushedEvents.count, 1)
+        XCTAssertEqual(pushedEvents.first?.trafficType, "user")
+    }
+
+    func testTrackWithValue() {
+        tracker.isTrackingEnabled = true
+        propertyValidator.result = TrackerPropertyResult.valid(properties: nil, sizeInBytes: 100)
+
+        let result = tracker.track(
+            eventType: "purchase",
+            trafficType: "user",
+            value: 99.99,
+            properties: nil,
+            matchingKey: "key1",
+            isSdkReady: true
+        )
+
+        XCTAssertTrue(result)
+        XCTAssertEqual(pushedEvents.first?.value, 99.99)
+    }
+}
+
+// MARK: - Test Stubs
+
+final class TrackerEventValidatorStub: TrackerEventValidator, @unchecked Sendable {
+    var validationError: TrackerValidationError?
+
+    func validate(key: String?, trafficTypeName: String?, eventTypeId: String?, value: Double?, properties: [String: Any]?, isSdkReady: Bool) -> TrackerValidationError? {
+        validationError
+    }
+}
+
+final class TrackerPropertyValidatorStub: TrackerPropertyValidator, @unchecked Sendable {
+    var result = TrackerPropertyResult.valid(properties: nil, sizeInBytes: 0)
+
+    func validate(properties: [String: Any]?, initialSizeInBytes: Int, validationTag: String) -> TrackerPropertyResult {
+        result
+    }
+}
+
+final class TrackerLoggerStub: TrackerLogger, @unchecked Sendable {
+    var loggedErrors: [TrackerValidationError] = []
+    var errorMessages: [String] = []
+    var verboseMessages: [String] = []
+
+    func log(errorInfo: TrackerValidationError, tag: String) {
+        loggedErrors.append(errorInfo)
+    }
+
+    func e(message: String, tag: String) {
+        errorMessages.append(message)
+    }
+
+    func v(_ message: String) {
+        verboseMessages.append(message)
+    }
+}