Tidepool sync 2026-05-11

Cartfile.resolved

@@ -1,2 +1,2 @@
 github "tidepool-org/LoopKit" "899f958b50dd22014d97c4730e44266ad8135805"
-github "tidepool-org/TidepoolKit" "2a1858cf1040d8b01b6f7357551536417ad55b04"
+github "tidepool-org/TidepoolKit" "4f4747ff647d836c5a27cc1b9c275e5717901e83"

TidepoolService.xcodeproj/xcshareddata/xcschemes/Shared.xcscheme

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "1430"
+   LastUpgradeVersion = "1640"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"

TidepoolServiceKit/DeviceLogUploader.swift

@@ -0,0 +1,134 @@
+//
+//  DeviceLogUploader.swift
+//  TidepoolServiceKit
+//
+//  Created by Pete Schwamb on 5/28/24.
+//  Copyright © 2024 LoopKit Authors. All rights reserved.
+//
+
+import Foundation
+import LoopAlgorithm
+import LoopKit
+import os.log
+import TidepoolKit
+
+/// Periodically uploads device logs in hourly chunks to backend
+actor DeviceLogUploader {
+    private let log = OSLog(category: "DeviceLogUploader")
+
+    private let api: TAPI
+
+    private var delegate: RemoteDataServiceDelegate?
+
+    private var logChunkDuration = TimeInterval(hours: 1)
+
+    private let backfillLimitInterval = TimeInterval(days: 2)
+
+
+    func setDelegate(_ delegate: RemoteDataServiceDelegate?) {
+        self.delegate = delegate
+    }
+
+    init(api: TAPI) {
+        self.api = api
+
+        Task {
+            await main()
+        }
+    }
+
+    func main() async {
+        var nextLogStart: Date?
+
+        // Start upload loop
+        while true {
+            if nextLogStart == nil {
+                do {
+                    nextLogStart = try await getMostRecentUploadEndTime()
+                } catch {
+                    log.error("Unable to fetch device log metadata: %{public}@", String(describing: error))
+                }
+            }
+
+            if nextLogStart != nil {
+                let nextLogEnd = nextLogStart!.addingTimeInterval(logChunkDuration)
+                let timeUntilNextUpload = nextLogEnd.timeIntervalSinceNow
+                if timeUntilNextUpload > 0 {
+                    log.debug("Waiting %{public}@s until next upload", String(timeUntilNextUpload))
+                    try? await Task.sleep(nanoseconds: timeUntilNextUpload.nanoseconds)
+                }
+                do {
+                    try await upload(from: nextLogStart!, to: nextLogEnd)
+                    nextLogStart = nextLogEnd
+                } catch {
+                    log.error("Upload failed: %{public}@", String(describing: error))
+                    // Upload failed, retry in 5 minutes.
+                    try? await Task.sleep(nanoseconds: TimeInterval(minutes: 5).nanoseconds)
+                }
+            } else {
+                // Haven't been able to talk to backend to find any previous log uploads. Retry in 15 minutes.
+                try? await Task.sleep(nanoseconds: TimeInterval(minutes: 15).nanoseconds)
+            }
+        }
+    }
+
+    func getMostRecentUploadEndTime() async throws -> Date {
+        var uploadMetadata = try await api.listDeviceLogs(start: Date().addingTimeInterval(-backfillLimitInterval), end: Date())
+        uploadMetadata.sort { a, b in
+            return a.endAtTime < b.endAtTime
+        }
+        if let lastEnd = uploadMetadata.last?.endAtTime {
+            return lastEnd
+        } else {
+            // No previous uploads found in last two days
+            return Date().addingTimeInterval(-backfillLimitInterval).dateFlooredToTimeInterval(logChunkDuration)
+        }
+    }
+
+    func upload(from start: Date, to end: Date) async throws {
+        if let logs = try await delegate?.fetchDeviceLogs(startDate: start, endDate: end) {
+            if logs.count > 0 {
+                let data = logs.map({
+                    entry in
+                    TDeviceLogEntry(
+                        type: entry.type.tidepoolType,
+                        managerIdentifier: entry.managerIdentifier,
+                        deviceIdentifier: entry.deviceIdentifier ?? "unknown",
+                        timestamp: entry.timestamp,
+                        message: entry.message
+                    )
+                })
+                let metatdata = try await api.uploadDeviceLogs(logs: data, start: start, end: end)
+                log.debug("Uploaded %d entries from %{public}@ to %{public}@", logs.count, String(describing: start), String(describing: end))
+                log.debug("metadata: %{public}@", String(describing: metatdata))
+            } else {
+                log.debug("No device log entries from %{public}@ to %{public}@", String(describing: start), String(describing: end))
+            }
+        }
+    }
+}
+
+extension TimeInterval {
+    var nanoseconds: UInt64 {
+        return UInt64(self * 1e+9)
+    }
+}
+
+extension DeviceLogEntryType {
+    var tidepoolType: TDeviceLogEntry.TDeviceLogEntryType {
+        switch self {
+        case .send:
+            return .send
+        case .receive:
+            return .receive
+        case .error:
+            return .error
+        case .delegate:
+            return .delegate
+        case .delegateResponse:
+            return .delegateResponse
+        case .connection:
+            return .connection
+        }
+    }
+}

TidepoolServiceKit/Extensions/DoseEntry.swift

@@ -6,6 +6,7 @@
 //  Copyright © 2022 LoopKit Authors. All rights reserved.
 //
 
+import LoopAlgorithm
 import LoopKit
 import TidepoolKit
 
@@ -82,8 +83,8 @@ extension DoseEntry: IdentifiableDatum {
         payload["deliveredUnits"] = datumBasalDeliveredUnits
 
         var datum = TAutomatedBasalDatum(time: datumTime,
-                                         duration: !isMutable ? datumDuration : 0,
-                                         expectedDuration: !isMutable && datumDuration < basalDatumExpectedDuration ? basalDatumExpectedDuration : nil,
+                                         duration: datumDuration,
+                                         expectedDuration: nil,
                                          rate: datumScheduledBasalRate,
                                          scheduleName: StoredSettings.activeScheduleNameDefault,
                                          insulinFormulation: datumInsulinFormulation)
@@ -96,11 +97,9 @@ extension DoseEntry: IdentifiableDatum {
     }
 
     private func dataForBolus(for userId: String, hostIdentifier: String, hostVersion: String) -> [TDatum] {
-        // TODO: revert to using .insulin datum type once fully supported in Tidepool frontend
-//        if manuallyEntered {
-//            return dataForBolusManuallyEntered(for: userId, hostIdentifier: hostIdentifier, hostVersion: hostVersion)
-//        } else 
-        if automatic != true {
+        if manuallyEntered {
+            return dataForBolusManuallyEntered(for: userId, hostIdentifier: hostIdentifier, hostVersion: hostVersion)
+        } else if automatic != true {
             return dataForBolusManual(for: userId, hostIdentifier: hostIdentifier, hostVersion: hostVersion)
         }  else {
             return dataForBolusAutomatic(for: userId, hostIdentifier: hostIdentifier, hostVersion: hostVersion)
@@ -209,8 +208,8 @@ extension DoseEntry: IdentifiableDatum {
         payload["deliveredUnits"] = deliveredUnits
 
         var datum = TAutomatedBasalDatum(time: datumTime,
-                                         duration: !isMutable ? datumDuration : 0,
-                                         expectedDuration: !isMutable && datumDuration < basalDatumExpectedDuration ? basalDatumExpectedDuration : nil,
+                                         duration: datumDuration,
+                                         expectedDuration: datumDuration < basalDatumExpectedDuration ? basalDatumExpectedDuration : nil,
                                          rate: datumRate,
                                          scheduleName: StoredSettings.activeScheduleNameDefault,
                                          insulinFormulation: datumInsulinFormulation)
@@ -347,3 +346,194 @@ extension TNormalBolusDatum: TypedDatum {
 extension TInsulinDatum: TypedDatum {
     static var resolvedType: String { TDatum.DatumType.insulin.rawValue }
 }
+
+extension DoseEntry {
+
+    /// Annotates a dose with the context of a history of scheduled basal rates
+    ///
+    /// If the dose crosses a schedule boundary, it will be split into multiple doses so each dose has a
+    /// single scheduled basal rate.
+    ///
+    /// - Parameter basalHistory: The history of basal schedule values to apply. Only schedule values overlapping the dose should be included.
+    /// - Returns: An array of annotated doses
+    fileprivate func annotated(with basalHistory: [AbsoluteScheduleValue<Double>]) -> [DoseEntry] {
+
+        guard type == .tempBasal || type == .suspend, !basalHistory.isEmpty else {
+            return [self]
+        }
+
+        if type == .suspend {
+            guard value == 0 else {
+                preconditionFailure("suspend with non-zero delivery")
+            }
+        } else {
+            guard unit != .units else {
+                preconditionFailure("temp basal without rate unsupported")
+            }
+        }
+
+        if isMutable {
+            var newDose = self
+            let basal = basalHistory.first!
+            newDose.scheduledBasalRate = LoopQuantity(unit: .internationalUnitsPerHour, doubleValue: basal.value)
+            return [newDose]
+        }
+
+        var doses: [DoseEntry] = []
+
+        for (index, basalItem) in basalHistory.enumerated() {
+            let startDate: Date
+            let endDate: Date
+
+            if index == 0 {
+                startDate = self.startDate
+            } else {
+                startDate = basalItem.startDate
+            }
+
+            if index == basalHistory.count - 1 {
+                endDate = self.endDate
+            } else {
+                endDate = basalHistory[index + 1].startDate
+            }
+
+            let segmentStartDate = max(startDate, self.startDate)
+            let segmentEndDate = max(startDate, min(endDate, self.endDate))
+            let segmentDuration = segmentEndDate.timeIntervalSince(segmentStartDate)
+            let segmentPortion = (segmentDuration / duration)
+
+            var annotatedDose = self
+            annotatedDose.startDate = segmentStartDate
+            annotatedDose.endDate = segmentEndDate
+            annotatedDose.scheduledBasalRate = LoopQuantity(unit: .internationalUnitsPerHour, doubleValue: basalItem.value)
+
+            if let deliveredUnits {
+                annotatedDose.deliveredUnits = deliveredUnits * segmentPortion
+            }
+
+            doses.append(annotatedDose)
+        }
+
+        if doses.count > 1 {
+            for (index, dose) in doses.enumerated() {
+                if let originalIdentifier = dose.syncIdentifier, index>0 {
+                    doses[index].syncIdentifier = originalIdentifier + "\(index+1)/\(doses.count)"
+                }
+            }
+        }
+
+        return doses
+    }
+
+}
+
+
+extension Collection where Element == DoseEntry {
+
+    /// Annotates a sequence of dose entries with the configured basal history
+    ///
+    /// Doses which cross time boundaries in the basal rate schedule are split into multiple entries.
+    ///
+    /// - Parameter basalHistory: A history of basal rates covering the timespan of these doses.
+    /// - Returns: An array of annotated dose entries
+    public func annotated(with basalHistory: [AbsoluteScheduleValue<Double>]) -> [DoseEntry] {
+        var annotatedDoses: [DoseEntry] = []
+
+        for dose in self {
+            let basalItems = basalHistory.filterDateRange(dose.startDate, dose.endDate)
+            annotatedDoses += dose.annotated(with: basalItems)
+        }
+
+        return annotatedDoses
+    }
+
+
+    /// Assigns an automation status to any dose where automation is not already specified
+    ///
+    /// - Parameters:
+    ///   - automationHistory: A history of automation periods.
+    /// - Returns: An array of doses, with the automation flag set based on automation history. Doses will be split if the automation state changes mid-dose.
+
+    public func overlayAutomationHistory(
+        _ automationHistory: [AbsoluteScheduleValue<Bool>]
+    ) -> [DoseEntry] {
+
+        guard count > 0 else {
+            return []
+        }
+
+        var newEntries = [DoseEntry]()
+
+        var automation = automationHistory
+
+        // Assume automation if doses start before automationHistory
+        if let firstAutomation = automation.first, firstAutomation.startDate > first!.startDate {
+            automation.insert(AbsoluteScheduleValue(startDate: first!.startDate, endDate: firstAutomation.startDate, value: true), at: 0)
+        }
+
+        // Overlay automation periods
+        func annotateDoseWithAutomation(dose: DoseEntry) {
+
+            var addedCount = 0
+            for period in automation {
+                if period.endDate > dose.startDate && period.startDate < dose.endDate {
+                    var newDose = dose
+
+                    if dose.isMutable {
+                        newDose.automatic = period.value
+                        newEntries.append(newDose)
+                        return
+                    }
+
+                    newDose.startDate = Swift.max(period.startDate, dose.startDate)
+                    newDose.endDate = Swift.min(period.endDate, dose.endDate)
+                    if let delivered = dose.deliveredUnits {
+                        if dose.duration == 0 || delivered == 0 {
+                            newDose.deliveredUnits = dose.deliveredUnits
+                        } else {
+                            newDose.deliveredUnits = newDose.duration / dose.duration * delivered
+                        }
+                    }
+                    newDose.automatic = period.value
+                    if addedCount > 0 {
+                        newDose.syncIdentifier = "\(dose.syncIdentifierAsString)\(addedCount+1)"
+                    }
+                    newEntries.append(newDose)
+                    addedCount += 1
+                }
+            }
+            if addedCount == 0 {
+                // automation history did not cover dose; mark automatic as default
+                var newDose = dose
+                newDose.automatic = true
+                newEntries.append(newDose)
+            }
+        }
+
+        for dose in self {
+            switch dose.type {
+            case .tempBasal, .basal, .suspend:
+                if dose.automatic == nil {
+                    annotateDoseWithAutomation(dose: dose)
+                } else {
+                    newEntries.append(dose)
+                }
+            default:
+                newEntries.append(dose)
+                break
+            }
+        }
+        return newEntries
+    }
+
+}
+
+extension DoseEntry {
+    var simpleDesc: String {
+        let seconds = Int(duration)
+        let automatic = automatic?.description ?? "na"
+        return "\(startDate) (\(seconds)s) - \(type) - isMutable:\(isMutable) automatic:\(automatic) value:\(value) delivered:\(String(describing: deliveredUnits)) scheduled:\(String(describing: scheduledBasalRate)) syncId:\(String(describing: syncIdentifier))"
+    }
+}
+
+