Slide 1
Slide 1 text
5000
支
iOSDC Japan
2 02
5
202 5
.
0 9
.
21
10
:
3
0
Track C
@dsxsxsxs
© LINE Digital Frontier Corporation
Slide 2
Slide 2 text
自己
人 日
LINE Digital Frontier
VTuber
🏍💨
@dsxsxsxs
Slide 3
Slide 3 text
日 行
Swift
6
.
1
.
0
行
Firebase Remote Config
Slide 4
Slide 4 text
Source Repository: https://github.com/dsxsxsxs/Tracker
Slide 5
Slide 5 text
行
Slide 6
Slide 6 text
No content
Slide 7
Slide 7 text
No content
Slide 8
Slide 8 text
SDK
Slide 9
Slide 9 text
No content
Slide 10
Slide 10 text
No content
Slide 11
Slide 11 text
行
面
Screen Impression Tap etc
…
UX
⾒
方
Slide 12
Slide 12 text
行
行 行
行
Slide 13
Slide 13 text
力
Slide 14
Slide 14 text
Tracker
Concurrent
非
Queueing, Priority: Utility
gzip, deflate
Exponential Backoff
[String: Sendable]
Swift Package
swift-tools-version:
6
.
1
.
0
Slide 15
Slide 15 text
Swift
6
Sendable ⾒
actor
Sendable ⾒ ⾒
@unchecked Sendable
@unchecked Sendable @MainActor
Slide 16
Slide 16 text
Digest Loop
一
while dataStore.haveData() {
let dataToSend = dataStore.getData(count: chunkCount)
do {
try await networkClient.send(data: dataToSend)
dataStore.deleteData(ids: dataToSend.map(\.id))
} catch {
stopDigesting()
break
}
}
Slide 17
Slide 17 text
No content
Slide 18
Slide 18 text
Entity(Domain Object)
TrackingData
Use Case(Interactor, Controller)
TrackingDispatcher
Data Layer
TrackingSQLiteDataStore, TrackingNetworkClient
Public Interface
Tracker
Slide 19
Slide 19 text
Clean
Slide 20
Slide 20 text
Clean
Slide 21
Slide 21 text
Clean
Slide 22
Slide 22 text
public struct TrackingData: Sendable {
let id: Int
let data: Data
}
Entity - TrackingData
Slide 23
Slide 23 text
Use Case
Slide 24
Slide 24 text
public protocol TrackingDispatcherProtocol: Sendable {
func sendLogs(name: String, payloads: [[String: Sendable]])
}
public protocol TrackingDataStoreProtocol: Sendable {
func save(data: [Data]) throws -> [TrackingData]
func getData(count: Int) throws -> [TrackingData]
func deleteData(ids: [Int]) throws
}
public protocol TrackingNetworkClientProtocol: Sendable {
func send(data: [TrackingData]) async throws
}
Use Case All Sendable!!!!!
Slide 25
Slide 25 text
Data Layer
TrackingSQLiteDataStore
TrackingNetworkClient
Public Interface
Tracker
Slide 26
Slide 26 text
DataStore
Slide 27
Slide 27 text
DataStore
SQLite
(String )
private let tableName = "Tracking"
private let primaryKey = "id"
private let dataKey = "rawData"
CREATE TABLE IF NOT EXISTS \(tableName) (
\(primaryKey) INTEGER PRIMARY KEY AUTOINCREMENT,
\(dataKey) BLOB
);
Slide 28
Slide 28 text
DataStore - SQLite
iOS
Slide 29
Slide 29 text
DataStore - Sendable
import SQLite3
public final class TrackingSQLiteDataStore: TrackingDataStoreProtocol {
private var db: OpaquePointer?
public func save(data: [Data]) throws -> [TrackingData] {
public func selectLogs(limit: Int) throws -> [TrackingData] {
public func deleteLogs(ids: [Int]) throws {
}
Stored property 'db' of 'Sendable'-conforming class 'TrackingSQLiteDataStore' has
non-sendable type 'OpaquePointer?'
OpaquePointerSendableͰͳ͍
OSAllcatedUnfairLockͰϥοϓͯ͠μϝ
SE
03
31
- Remove Sendable conformance from unsafe pointer types
Slide 30
Slide 30 text
DataStore
final class DatabasePointer: @unchecked Sendable {
private let lock = NSRecursiveLock()
private var _pointer: OpaquePointer?
var pointer: OpaquePointer? {
get {
defer { lock.unlock() }
lock.lock()
return _pointer
}
set {
defer { lock.unlock() }
lock.lock()
_pointer = newValue
}
}
}
Workaround
😅
Slide 31
Slide 31 text
DataStore
public final class TrackingSQLiteDataStore: TrackingDataStoreProtocol {
private let databasePointer = DatabasePointer()
private var db: OpaquePointer? {
get { databasePointer.pointer }
set { databasePointer.pointer = newValue }
}
public func save(data: [Data]) throws -> [TrackingData] {}
public func getData(count: Int) throws -> [TrackingData] {}
public func deleteData(ids: [Int]) throws {}
}
Slide 32
Slide 32 text
DataStore - Test
private let sut = TrackingSQLiteDataStore()
@Suite(.serialized)
final class TrackingDataStoreTests {
func save10Logs() throws {
// sutʹLogΛ10݅อଘ....
}
func delete10Logs() throws {
// sutʹLogΛ10݅আ....
}
}
Swift Testing Concurrent
Slide 33
Slide 33 text
NetworkClient
Slide 34
Slide 34 text
NetworkClient
Networking
入
5KB body
protocol TrackingNetworkClientNetworking: Sendable {
func execute(request: URLRequest) async throws -> (Data, URLResponse)
}
private let minimumDeflateSize: Int32 = 5120
Slide 35
Slide 35 text
NetworkClient
public final class TrackingNetworkClient: TrackingNetworkClientProtocol {
let networking: TrackingNetworkClientNetworking
let suspend: @Sendable (Int) async throws -> Void
let maxRetryCount: Int
public func send(data: [TrackingData]) async throws {}
}
Networking retry
入
5KB body
Slide 36
Slide 36 text
NetworkClient - Send - Compression
public func send(data: [TrackingData]) async throws {
var request = URLRequest(url: urlComponents.url!)
// URLRequestΛઃఆ....
let rawData: Data = try data.asData()
if rawData.count > minimumDeflateSize, let deflated = try? rawData.deflated() {
request.httpBody = deflated
request.setValue("deflate", forHTTPHeaderField: "Content-Encoding")
request.setValue("\(deflated.count)", forHTTPHeaderField: "Content-Length")
} else {
request.httpBody = rawData
request.setValue("\(rawData.count)", forHTTPHeaderField: "Content-Length")
}
Slide 37
Slide 37 text
NetworkClient - Send - Exponential Backoff
var retryAttempts = 0
repeat {
do {
if retryAttempts > 0 {
let delay = pow(2.0, Double(retryAttempts))
try await suspend(Int(delay))
}
try await networking.execute(request: request)
break
} catch {
self.holdError(error)
retryAttempts += 1
}
} while retryAttempts <= maxRetryCount
try throwErrorIfNeeded()
}
Slide 38
Slide 38 text
NetworkClient - Compression
import zlib
extension Data {
private static let chunk = 1 << 14 // 16384bytes
func deflated() throws -> Data {
var stream = z_stream()
var status: Int32
// লུ
var data = Data(capacity: Self.chunk)
// লུ
data.count = Int(stream.total_out)
return data
}
}
zlib
用
Gzip, deflate
Compression Framework
Slide 39
Slide 39 text
final class TrackingNetworkClientTests: @unchecked Sendable {
var suspendSeconds: [Int] = []
private var networking: ImmediateNetworking!
private var sut: TrackingNetworkClient!
init() {
self.networking = ImmediateNetworking(statusCode: 200)
sut = TrackingNetworkClient(
maxRetryCount: 3,
suspend: {
self.suspendSeconds.append($0)
},
networking: networking
)
}
NetworkClient - Test
Slide 40
Slide 40 text
NetworkClient - Test
@Test
func failHTTP400ThenRetry3Times() async throws {
// লུ
await #expect {
try await self.sut.send(data: oneData)
} throws: { error in
let nsError = error as NSError
return nsError.code == 400
}
#expect(networking.receivedRequests.count == 4)
#expect(suspendSeconds == [2, 4, 8])
}
Slide 41
Slide 41 text
Dispatcher
Slide 42
Slide 42 text
Dispatcher
actor TrackingDispatcher: TrackingDispatcherProtocol {
private let dataStore: TrackingDataStoreProtocol
private let networkClient: TrackingNetworkClientProtocol
private let errorHandler: TrackingErrorHandler
private(set) var digestingTask: Task?
var isDigesting: Bool {
digestingTask != nil
}
}
Slide 43
Slide 43 text
Dispatcher
actor TrackingDispatcher: TrackingDispatcherProtocol {
private let dataStore: TrackingDataStoreProtocol
private let networkClient: TrackingNetworkClientProtocol
private let errorHandler: TrackingErrorHandler
private let executor: LogSerialExecutor
private(set) var digestingTask: Task?
let unownedExecutor: UnownedSerialExecutor
var isDigesting: Bool {
digestingTask != nil
}
public init(dataStore: TrackingDataStoreProtocol, networkClient: TrackingNetworkClientProtocol,
errorHandler: @escaping TrackingErrorHandler) {
self.dataStore = dataStore
self.networkClient = networkClient
self.errorHandler = errorHandler
executor = LogSerialExecutor()
self.unownedExecutor = executor.asUnownedSerialExecutor()
}
Slide 44
Slide 44 text
Dispatcher - Executer
private final class LogSerialExecutor: SerialExecutor {
private let serialQueue = DispatchQueue(label: "Executor", qos: .utility)
nonisolated func enqueue(_ job: UnownedJob) {
serialQueue.async {
job.runSynchronously(on: self.asUnownedSerialExecutor())
}
}
func asUnownedSerialExecutor() -> UnownedSerialExecutor {
UnownedSerialExecutor(ordinary: self)
}
Actor ⾒
止
Slide 45
Slide 45 text
await Task.yield()
Dispatcher - Digest Loop
func startDigesting() {
if self.isDigesting { return }
digestingTask = Task(priority: .utility) { [weak self] in
guard let self else { return }
var shouldContinue = true
while shouldContinue {
shouldContinue = await self.digestDataStore()
sleep k }
await self.stopDigesting()
}
}
Slide 46
Slide 46 text
Dispatcher
private func digestDataStore() async -> Bool {
guard isDigesting else { return false }
if Task.isCancelled { return false }
do {
let dataToSend = try dataStore.getData(count: 50)
if dataToSend.isEmpty || Task.isCancelled {
return false
}
try await networkClient.send(data: dataToSend)
let ids = dataToSend.map { $0.id }
try dataStore.deleteData(ids: ids)
return true
} catch {
errorHandler(error)
return false
}
}
re-entry
actor
Slide 47
Slide 47 text
Dispatcher func saveAndStartDigesting(data: [Data]) {
do {
_ = try dataStore.save(data: data)
startDigesting()
} catch {
errorHandler(error)
}
}
private func stopDigesting() {
digestingTask?.cancel()
digestingTask = nil
}
Digest Loop
Digest Loop Clean up
Slide 48
Slide 48 text
Dispatcher
nonisolated func sendLogs(name: String, payloads: [[String: Sendable]]) {
if payloads.isEmpty { return }
guard let encoded = try? Self.makeLogs(name: name, payloads: payloads) else {
return
}
Task.detached(priority: .utility) {
await self.saveAndStartDigesting(data: encoded)
}
}
protocol ⾒
Loop
Slide 49
Slide 49 text
Dispatcher - Test
final class TrackingDispatcherTests: @unchecked Sendable {
private let dataStore = MockDataStore()
private let networkClient = MockNetworkClient()
private var sut: TrackingDispatcher!
init() throws {
sut = .init(
dataStore: dataStore,
networkClient: networkClient,
errorHandler: { _ in }
)
}
Slide 50
Slide 50 text
Dispatcher - Test
@Test
func digestLoopStopWhenEmpty() async throws {
let data70 = Array(repeating: Data(), count: 70)
_ = try dataStore.save(data: data70)
dataStore.operations = []
await sut.saveAndStartDigesting(data: [Data()])
await sut.digestingTask?.value
#expect(dataStore.operations == [
.insert,
.select, .delete,
.select, .delete,
.select
])
#expect(networkClient.sentDataList.count == 2)
#expect(networkClient.sentDataList.flatMap { $0 }.count == 71)
}
70
入
1
入
Loop
expect:
71
2
Slide 51
Slide 51 text
Dispatcher - Test
func testConcurrentDigestCalls() async throws {
// sutʹLogΛ10݅อଘ͓ͯ͘͠....
await withTaskGroup(of: Void.self) { group in
group.addTask {
await self.sut.saveAndStartDigesting(data: [Data()])
await self.sut.digestingTask?.value
}
group.addTask {
await self.sut.startDigesting()
}
group.addTask {
await self.sut.startDigesting()
}
}
#expect(networkClient.sentDataList.flatMap { $0 }.count == 71)
}
expect:
71
Slide 52
Slide 52 text
Tracker
Slide 53
Slide 53 text
Tracker
public final class Tracker: Sendable {
let dispatcher: TrackingDispatcherProtocol
let dataStore: TrackingDataStoreProtocol,
let networkClient: TrackingNetworkClientProtocol
public func sendLogs(name: String, payloads: [[String: Sendable]]) {
dispatcher.sendLogs(name: name, payloads: payloads)
}
}
Slide 54
Slide 54 text
Tracker
方
let tracker = Tracker(
dataStore: try TrackingSQLiteDataStore(),
networkClient: try TrackingNetworkClient(
maxRetryCount: 3,
suspend: { try await Task.sleep(for: .seconds($0)) },
networking: TrackingNetworkClient.DefaultNetworking()
)
)
tracker.sendLogs(name: "some_log_name", payloads: [
["item_id": "12345", "event": "app_start"],
["item_id": "67890", "event": "app_end"]
])
Task.sleep
URLSession
Slide 55
Slide 55 text
Test Coverage
Slide 56
Slide 56 text
No content
Slide 57
Slide 57 text
行
Slide 58
Slide 58 text
Dual Send Adapter
protocol OldLogger {
func logEvents(name: String, parameters: [[String: Any]])
}
struct DualSendTracker: Sendable {
let oldLogger: OldLogger
let tracker: Tracker
func sendLogs(name: String, parameters: [[String: Sendable]]) {
oldLogger.logEvents(name: name, parameters: parameters)
tracker.sendLogs(name: name, payloads: parameters)
}
}
Slide 59
Slide 59 text
😭
Slide 60
Slide 60 text
Call ⾒
大 入
Slide 61
Slide 61 text
func sendLogs(name: String, parameters: [[String: Sendable]]) {
oldLogger.logEvents(name: name, parameters: parameters)
tracker.sendLogs(name: name, payloads: editedParameters)
}
大 入
var editedParameters: [[String: Sendable]] = parameters
for (index, parameter) in editedParameters.enumerated() {
if let someValue = parameter["some_key"] {
editedParameters[index]["some_key"] = nil
editedParameters[index]["some_new_key"] = someValue
}
if let someValue = parameter["some_key"] {
editedParameters[index]["some_key"] = nil
editedParameters[index]["some_new_key"] = someValue
}
if let someValue = parameter["some_key"] {
editedParameters[index]["some_key"] = nil
editedParameters[index]["some_new_key"] = someValue
}
if let someValue = parameter["some_key"] {
editedParameters[index]["some_key"] = nil
editedParameters[index]["some_new_key"] = someValue
}
if let someValue = parameter["some_key"] {
editedParameters[index]["some_key"] = nil
editedParameters[index]["some_new_key"] = someValue
}
if let someValue = parameter["some_key"] {
editedParameters[index]["some_key"] = nil
editedParameters[index]["some_new_key"] = someValue
}
if let someValue = parameter["some_key"] {
editedParameters[index]["some_key"] = nil
editedParameters[index]["some_new_key"] = someValue
}
if let someValue = parameter["some_key"] {
editedParameters[index]["some_key"] = nil
editedParameters[index]["some_new_key"] = someValue
}
if let someValue = parameter["some_key"] {
editedParameters[index]["some_key"] = nil
// ͦͷଞॾʑϚοϐϯά
}
Slide 62
Slide 62 text
Call
Call
生
Call
大
Slide 63
Slide 63 text
-
見
Slide 64
Slide 64 text
struct OldTapEventLog {
let name: String
let parameter: [String: Sendable]
func send() {
oldLogger.logEvents(
name: name,
parameters: [parameter]
)
}
}
立
面
extension Tracker {
struct TapEvent {
let name: String
let payload: [String: Sendable]
func send() {
tracker.sendLog(
name: name,
payload: payload
)
}
}
}
Slide 65
Slide 65 text
struct OldTapEventLog {
let name: String
let parameter: [String: Sendable]
func send() {
oldLogger.logEvents(
name: name,
parameters: [parameter]
)
}
func sendToNewTracker() -> Self {
let tapEvent = Tracker.TapEvent(name: name, payload: parameter)
tapEvent.send()
return self
}
}
Slide 66
Slide 66 text
Call
let tapEvent = OldTapEventLog(
name: "home.like_button.tap",
parameter: [
"item_id": "12345"
])
tapEvent.sendToNewTracker().send()
Slide 67
Slide 67 text
Call
let logName = "home.like_button.tap"
let itemID = “12345"
let oldTapEvent = OldTapEventLog(
name: logName,
parameter: [
"item_id": itemID
]
)
oldTapEvent.send()
let tapEvent = Tracker.TapEvent(
name: logName,
payload: [
"new_item_id": itemID
]
)
tapEvent.send()
"item_id" "new_item_id"
Slide 68
Slide 68 text
大
人生 見
payload
Slide 69
Slide 69 text
No content
Slide 70
Slide 70 text
行
見
小 止血
Hot Fix
小
Slide 71
Slide 71 text
行
Slide 72
Slide 72 text
行 方
二 止
Slide 73
Slide 73 text
Firebase Remote Config
shouldSendLogToOldLogger: true
default: false
shouldSendLogToNewTracker: false
default: true
行
Config
struct RemoteConfig {
let shouldSendLogToOldLogger: Bool
let shouldSendLogToNewTracker: Bool
}
Slide 74
Slide 74 text
2024 10
月
true 100%
v
2 4
.
1 1
.
1 0
false
Slide 75
Slide 75 text
2025 1
月
false 100%
v
2 5
.
0 4
.
1 0
5
⾒
5
%
5
%
月
25
%
0
~
5
%
月
50
%
50
%
月
75
%
75
%
GW
10 0
%
10 0
%
Slide 76
Slide 76 text
Hot Fix
++
心
++
Clean up
Slide 77
Slide 77 text
No content
Slide 78
Slide 78 text
🏁
Slide 79
Slide 79 text
1
Digest Loop
Clean SOLID
Swift
6
自
Slide 80
Slide 80 text
2
行 見
Slide 81
Slide 81 text
3
Firebase Remote Config
true false
false true
Config
Free
⾒
Slide 82
Slide 82 text
CPU
用 用
⾒
Disk InMemory Data Store
Reachability
Slide 83
Slide 83 text
References
Source Repository: https://github.com/dsxsxsxs/Tracker
zlib doc: https://zlib.net/manual.html
Compression Framework: https://developer.apple.com/documentation/
Accelerate/compressing-and-decompressing-data-with-buffer-compression
Slide 84
Slide 84 text
https://connpass.com/event/
3 6
98 2
6
/
10
月
17
日
(
金
) 19:00 @
木
11F
Slide 85
Slide 85 text
LINE
支
Slide 86
Slide 86 text
End Of doc.