mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-17 23:52:24 +00:00
A history backfill carried one access token through walks that outlive it. After an hour every request answered 401, which classifies as a revoked grant, so the account was parked at error_reauth with a refresh token that was still valid, and every later run skipped it until a manual reconnect. Running beside the hourly sync, the backfill also pushed the account over Google's per-minute quota, and each 429 failed its whole collection. - Walks take a token source that renews the access token before it expires and once more when Google refuses it mid-walk. - A 429 is waited out (Retry-After, RetryInfo, else a doubling backoff) and the request repeated; it is never a reauth. - error_reauth only short-circuits a run when the token endpoint refused the grant (needsReauth). A connection parked by a data request's 401 refreshes on its next run and clears itself when that run completes. - One run per account at a time: syncs, the backfill and the sleep repair share an advisory lock. The hourly poll skips a held account, a manual sync answers 409 sync_in_progress, the backfill waits a bounded time. - A backfill attempt records each collection it finishes cleanly (backfill_progress) and the next attempt resumes with the rest. - The incremental watermark is stamped with the cycle's start, not its end. Overlapping sleep segments that share a stage and an end share the natural key (type, measuredAt, source, sleepStage). A re-score that moved one row onto a sibling's slot threw P2002 and failed the sync on every run. - A batch keeps one reading per natural key, chosen the same way each time (longer segment, then smaller externalId). - A move that still collides is settled by reconcileExternalMeasurement, which retires the stale row, instead of failing the sync. - Updates run before inserts, and the key-format rescue no longer re-keys a row this batch is moving. - The sleep replace-by-window protects every session's fresh rows, so two overlapping sessions no longer tombstone and resurrect each other hourly. Refs #1194, #1195
154 lines
5.3 KiB
TypeScript
154 lines
5.3 KiB
TypeScript
/**
|
|
* Google Health exercise-session sync (v1.27.0).
|
|
*
|
|
* Reads exercise sessions from the `activity_and_fitness.readonly` Restricted
|
|
* bundle and upserts each into the `Workout` table as `source = GOOGLE_HEALTH`,
|
|
* keyed on `(userId, source, externalId)` so a re-fetch overwrites in place.
|
|
* Insert and update share one payload object, so a full sync repairs rows an
|
|
* older build wrote — including the raw activity type, which earlier releases
|
|
* discarded.
|
|
*
|
|
* A Google Health run and the same run via Apple Health (or WHOOP) stay distinct
|
|
* `Workout` rows (different `source`); the read-time `pickCanonicalWorkoutRows`
|
|
* picker collapses the cross-source twin at read time per the user's source
|
|
* ladder. There is no ingest-time collapse for a server-owned source pair.
|
|
*
|
|
* A per-data-class 403 soft-skips the resource — the activity/fitness bundle is
|
|
* granted independently in the Google consent flow.
|
|
*/
|
|
import {
|
|
GOOGLE_HEALTH_ACTIVITY_PAGE_SIZE,
|
|
GOOGLE_HEALTH_DATA_TYPES,
|
|
fetchDataPoints,
|
|
mapWorkout,
|
|
type GoogleHealthMappedWorkout,
|
|
} from "./client";
|
|
import {
|
|
getValidToken,
|
|
googleHealthTokenSource,
|
|
handleCollectionFetchError,
|
|
noteHardFailure,
|
|
runGoogleHealthCollection,
|
|
type GoogleHealthResourceSyncOptions,
|
|
} from "./sync-core";
|
|
import { prisma } from "@/lib/db";
|
|
import { emitInsertedWorkoutArrival } from "@/lib/arrivals/workout-emit";
|
|
import { invalidateUserMeasurements } from "@/lib/cache/invalidate";
|
|
import { annotate, getEvent } from "@/lib/logging/context";
|
|
import { resolveUserTimezone } from "@/lib/tz/resolver";
|
|
|
|
export async function syncUserWorkout(
|
|
userId: string,
|
|
opts: GoogleHealthResourceSyncOptions = {},
|
|
): Promise<number> {
|
|
return runGoogleHealthCollection("fetchExercise", () =>
|
|
syncExerciseSessions(userId, opts),
|
|
);
|
|
}
|
|
|
|
async function syncExerciseSessions(
|
|
userId: string,
|
|
opts: GoogleHealthResourceSyncOptions,
|
|
): Promise<number> {
|
|
const tokenInfo = await getValidToken(userId);
|
|
if (!tokenInfo) return 0;
|
|
|
|
// Session start/end can arrive offset-less; anchor them against the user's
|
|
// stored zone rather than the process zone. The zone also shapes the
|
|
// incremental filter: exercise sessions filter on
|
|
// `exercise.interval.civil_start_time` with an offset-less civil bound, which
|
|
// must be the watermark's wall clock in the USER'S zone.
|
|
const tz = await resolveUserTimezone(userId);
|
|
|
|
// Cycle-wide watermark snapshotted once by `syncUserGoogleHealth`; undefined
|
|
// on a full/backfill run.
|
|
const start = opts.start;
|
|
|
|
let points: Record<string, unknown>[];
|
|
try {
|
|
points = await fetchDataPoints(
|
|
GOOGLE_HEALTH_DATA_TYPES.exercise,
|
|
googleHealthTokenSource(userId, tokenInfo),
|
|
"fetchExercise",
|
|
{ start, pageSize: GOOGLE_HEALTH_ACTIVITY_PAGE_SIZE, tz },
|
|
);
|
|
} catch (err) {
|
|
return handleCollectionFetchError("fetchExercise", userId, err);
|
|
}
|
|
|
|
let imported = 0;
|
|
for (const point of points) {
|
|
const w: GoogleHealthMappedWorkout | null = mapWorkout(point, tz);
|
|
if (!w) continue; // no usable time span — not a workout
|
|
|
|
const data = {
|
|
sportType: w.sportType,
|
|
startedAt: w.startedAt,
|
|
endedAt: w.endedAt,
|
|
durationSec: w.durationSec,
|
|
totalEnergyKcal: w.totalEnergyKcal,
|
|
totalDistanceM: w.totalDistanceM,
|
|
avgHeartRate: w.avgHeartRate,
|
|
maxHeartRate: w.maxHeartRate,
|
|
minHeartRate: w.minHeartRate,
|
|
// Raw pre-mapping label, kept for provenance once
|
|
// `mapGoogleHealthSportType()` has resolved `sportType` to a canonical
|
|
// bucket — every unmapped `exerciseType` collapses to `"other"`, so
|
|
// without this the activity Google reported is gone after ingest. Never
|
|
// read back as the canonical `sportType`. Absent (rather than null) when
|
|
// the session carried no type, so a re-sync never clears metadata a
|
|
// previous run wrote.
|
|
...(w.sportTypeRaw
|
|
? { metadata: { googleExerciseType: w.sportTypeRaw } }
|
|
: {}),
|
|
};
|
|
try {
|
|
const [inserted] = await prisma.workout.createManyAndReturn({
|
|
data: {
|
|
userId,
|
|
source: "GOOGLE_HEALTH",
|
|
externalId: w.externalId,
|
|
...data,
|
|
},
|
|
skipDuplicates: true,
|
|
select: { id: true, startedAt: true },
|
|
});
|
|
if (inserted) {
|
|
void emitInsertedWorkoutArrival(
|
|
userId,
|
|
inserted,
|
|
"google-health",
|
|
).catch(() => {});
|
|
} else {
|
|
await prisma.workout.update({
|
|
where: {
|
|
userId_source_externalId: {
|
|
userId,
|
|
source: "GOOGLE_HEALTH",
|
|
externalId: w.externalId,
|
|
},
|
|
},
|
|
data,
|
|
});
|
|
}
|
|
imported++;
|
|
} catch (err) {
|
|
getEvent()?.addWarning(`google-health: failed to upsert workout: ${err}`);
|
|
// A fetched-but-unwritten session is gone once it leaves the overlap
|
|
// window — fail the cycle's verdict so the watermark holds and the next
|
|
// tick re-fetches it. No rethrow: sibling sessions keep upserting.
|
|
noteHardFailure("workout:upsert");
|
|
}
|
|
}
|
|
|
|
if (imported > 0) {
|
|
await invalidateUserMeasurements(userId);
|
|
}
|
|
|
|
// `markSynced` is owned by the orchestrator (`syncUserGoogleHealth`).
|
|
annotate({
|
|
action: { name: "googleHealth.workout.sync", details: { imported } },
|
|
});
|
|
return imported;
|
|
}
|