+### Differential abundance
+
+In a study's analysis workspace, select two conditions (runs or pooled-run
+subgroups), a results table and a shared taxonomic rank. The first condition
+is the reference. Counts are aggregated by taxon after applicable
+`analysis.exclude_categories` filters. This workspace does not pass sample
+read-count bounds to the differential-abundance request, so those bounds do
+not exclude samples from this analysis.
+
+All `analysis.differential` options below (`method`, `offset`,
+`min_prevalence` and `replacement_delta`) are resolved at study scope.
+Set them in the study configuration; group and run overrides are not used
+by this endpoint, including when called from a group Analysis workspace.
+
+`analysis.differential.method` chooses the method:
+
+- `nb_glm` (default): a negative-binomial GLM per taxon using `MASS::glm.nb`,
+ with a library-size offset. The effect is log2 fold change; positive values
+ indicate greater abundance in the second condition. `offset` selects `tss`
+ (default) or `rle` scaling.
+- `clr_welch`: Welch's t-test on centred log-ratios after multiplicative zero
+ replacement with `zCompositions::cmultRepl`. The effect is a CLR difference,
+ not a fold change. `replacement_delta` controls the replacement fraction
+ (default 0.65); `offset` is not used.
+
+For either method, `min_prevalence` (default 0) filters taxa by the fraction of
+samples with nonzero counts. Benjamini–Hochberg adjustment includes only taxa
+that produced a p-value. Failed or filtered taxa have no substitute p-value;
+inspect their status and note in the results table. Invalid input or an
+unavailable required R package produces an explicit error.
+
+Implementation and reference tests: `src/analysis/differential.jl`,
+`src/server/routes/analysis.jl`, and `test/unit/test_differential.jl`.
+
### Figures and report
The Figures tab lays analysis charts out on a page (A4, letter or a journal
@@ -403,6 +438,32 @@ top level, run this once to keep completed taxonomy work current:
julia --project=. -e 'include("scripts/migrate_r_threads.jl"); MigrateRThreads.run_migration("projects")'
```
+### Profiling stage memory (`occupancy_probe:` in `pipeline.yml`)
+
+A diagnostic for sizing a machine, off by default and not offered in the config
+editor. Add it to a run's or study's `pipeline.yml` by hand:
+
+```yaml
+occupancy_probe:
+ enabled: true
+ interval_ms: 10 # sampling interval in milliseconds (at least 1)
+```
+
+Each stage then records an `occupancy` entry in the run's `attestation.yml`:
+
+- `child_peak_rss_kib`: the largest total resident memory of the stage's tool
+ processes (vsearch, swarm, cd-hit and so on) at any one sample. Tools run
+ concurrently can approach the sum of their individual peaks.
+- under `tasks`, each task's `peak_rss_kib` (largest sampled resident memory)
+ and `hwm_kib` (the kernel's high-water mark), with `samples: 0` for a process
+ too short-lived to be sampled.
+- `julia_allocated_bytes`, the Julia allocation over the stage. It is
+ process-wide, so it includes other runs' pipelines when several run at once.
+
+Linux only, since it reads `/proc`. For stages run on a remote server, the
+figures describe the local ssh client, not the work. With the probe off, the
+records are unchanged.
+
### Configuring DADA2 (`dada2:` in `pipeline.yml`)
```yaml
@@ -644,6 +705,30 @@ bash start.sh
Open `http://localhost:8080`. The backend serves the frontend.
+### Split deployment (frontend and API on different origins)
+
+To serve the frontend from a different address than the API, set `apiBase` in
+`frontend/public/config.json` to the API's address, and list the frontend's
+address when starting the server:
+
+```bash
+JULIA_METAMANIFOLD_ALLOWED_ORIGINS=https://frontend.example bash start.sh
+```
+
+The server accepts browser requests from its own origin (`http://localhost:+ + {label}…{seconds >= 2 && ` ${seconds}s`} + {seconds >= 10 && ' (large studies can take a minute or more)'} +
+ ) +} diff --git a/frontend/src/components/DifferentialPanel.tsx b/frontend/src/components/DifferentialPanel.tsx index ff15b507..6f4070d5 100644 --- a/frontend/src/components/DifferentialPanel.tsx +++ b/frontend/src/components/DifferentialPanel.tsx @@ -1,16 +1,17 @@ // SPDX-License-Identifier: AGPL-3.0-only // SPDX-FileCopyrightText: 2026 Jonathan D.A. Jewell (hyperpolymath)PERMANOVA Results
{permanova.text}
- {(permanova.terms?.length
- ? permanova.terms
- : permanova.p_value != null
- ? [{ term: 'model', r2: permanova.r2 ?? NaN, f_statistic: permanova.f_statistic, p_value: permanova.p_value }]
- : []
- ).map(t => (
+ {(permanova.terms ?? []).map(t => (
- {t.term}: R² = {t.r2.toFixed(3)} · F = {t.f_statistic?.toFixed(2) ?? 'n/a'} · p = {t.p_value?.toFixed(4) ?? 'n/a'} + {t.term}: R² = {t.r2.toFixed(3)} · F = {t.f_statistic?.toFixed(2) ?? 'n/a'} ·{' '} + {t.untestable_reason ? `p not reported: ${t.untestable_reason}` : `p = ${t.p_value?.toFixed(4) ?? 'n/a'}`}
))} {(permanova.terms?.length ?? 0) > 1 && (Terms are tested in order, each after the ones above it.
)} + {permanova.permutations != null && permanova.min_p_value != null && ( ++ {permanova.permutations} permutations; the smallest attainable p is {permanova.min_p_value.toFixed(4)}. +
+ )} {permanova.blocked && (Permutations restricted within individuals.
)} diff --git a/frontend/src/components/PipelineStages.test.ts b/frontend/src/components/PipelineStages.test.ts new file mode 100644 index 00000000..dd950da3 --- /dev/null +++ b/frontend/src/components/PipelineStages.test.ts @@ -0,0 +1,10 @@ +// SPDX-License-Identifier: AGPL-3.0-only +// SPDX-FileCopyrightText: 2026 Jonathan D.A. Jewell (hyperpolymath)
@@ -111,6 +133,9 @@ export function VennPanel({ study, runs, option }: {
{ranksReady && ranks.length === 0 && (
No taxonomy rank shared by the selected runs.
)}
+ {ranksError && (
+ Could not read the taxonomy ranks: {ranksError}
+ )}
+
{upsetjsSets && (mode === 'euler'
- ?
)
diff --git a/frontend/src/components/annotationShared.test.ts b/frontend/src/components/annotationShared.test.ts
new file mode 100644
index 00000000..276564a2
--- /dev/null
+++ b/frontend/src/components/annotationShared.test.ts
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Jonathan D.A. Jewell (hyperpolymath) Groups
- )}
- {studyDetail.groups?.map((g: string) => (
- Groups
+ )}
+ {studyDetail.groups?.map((g: string) => (
+ Runs
+ )}
+ {studyDetail.runs?.map((r: string) => (
Runs
+
)}
- {studyDetail.runs?.map((r: string) => (
-
- {COPYRIGHT} · AGPL-3.0 ·{' '}
- Source and Documentation
+
diff --git a/frontend/src/styles/app.css b/frontend/src/styles/app.css
index d74dc233..03f58daa 100644
--- a/frontend/src/styles/app.css
+++ b/frontend/src/styles/app.css
@@ -93,6 +93,7 @@ a:hover { text-decoration: underline; }
opacity: .6;
}
.sidebar-legal a { color: inherit; text-decoration: underline; }
+.sidebar-legal-links { white-space: nowrap; margin-top: 2px; }
.sidebar-sub-label {
font-size: .6rem;
@@ -294,6 +295,18 @@ a:hover { text-decoration: underline; }
padding: 20px 0;
}
+.computing-note { display: flex; align-items: center; gap: 8px; padding: 8px 0; }
+.computing-spinner {
+ width: 12px;
+ height: 12px;
+ border: 2px solid currentColor;
+ border-right-color: transparent;
+ border-radius: 50%;
+ animation: computing-spin .8s linear infinite;
+}
+@keyframes computing-spin { to { transform: rotate(360deg); } }
+@media (prefers-reduced-motion: reduce) { .computing-spinner { animation: none; } }
+
.error-msg {
color: #c92a2a;
font-size: .9rem;
diff --git a/frontend/src/views/TreeView.tsx b/frontend/src/views/TreeView.tsx
index c0778282..9d7d3aa2 100644
--- a/frontend/src/views/TreeView.tsx
+++ b/frontend/src/views/TreeView.tsx
@@ -72,7 +72,12 @@ function TreeLoader({ source, file }: { source: TreeSource; file: string }) {
const { data, loading, error } = useApi(fetcher)
if (loading) return {COPYRIGHT}
+
+ AGPL-3.0 ·{' '}
+ Source and Documentation
+
{error ?? 'Tree not found'}
+ if (error || !data) return ( + <> +{error ?? 'Tree not found'}
+ + ) return$(r.reason)" + "$test_label $(_significance_stars(r.omnibus))
$(_format_p_value(r.omnibus))" +end + +"""R side of `_alpha_significance`, run under the R lock once vegan is loaded.""" function _alpha_significance_r(values::Vector{Float64}, labels::Vector{String}, sample_ids::Vector{String}; @@ -932,7 +998,8 @@ function _alpha_significance_r(values::Vector{Float64}, [values[i] for i in eachindex(labels) if labels[i] == label], ) for label in groups_u) common_ids = reduce(intersect, [Set(keys(m)) for m in Base.values(paired_maps)]) - isempty(common_ids) && return nothing, DataFrame(group1=String[], group2=String[], p=Float64[]) + isempty(common_ids) && return _not_computed(:no_paired_samples, + "the groups share no sample IDs, so no paired test could be performed") common = sort(collect(common_ids)) RCall.globalEnv[:paired_groups] = groups_u @@ -1004,18 +1071,45 @@ function _alpha_significance_r(values::Vector{Float64}, pairwise_df = DataFrame(RCall.rcopy(RCall.reval("pairwise_df"))) RCall.reval("rm(values, groups, do_pairwise, groups_f, overall_p, pairwise_df); gc()") end - overall_p = ismissing(p_value) ? nothing : Float64(p_value) - overall_p, pairwise_df + # R returns `NA_real_` from its own `tryCatch` when the statistic cannot be + # computed at all (a degenerate group, say). That is a failed test, not a + # non-significant one, so it keeps whatever pairwise rows did come back but + # never claims an omnibus result. + if ismissing(p_value) + return _not_computed(:test_failed, + "the omnibus statistic could not be computed for these groups"; + pairwise=pairwise_df) + end + _computed(Float64(p_value), pairwise_df) end end +""" +Draw significance brackets for each pairwise result on one panel, or a single +"not run" notice when `significance` holds no computed result. +""" function _add_pairwise_annotations!(layout::Dict{String,Any}, xaxis_key::String, yaxis_ref::String, yaxis_layout_key::String, group_labels::Vector{String}, values_by_label::Dict{String, Vector{Float64}}, - pairwise_df::DataFrame) + significance::AlphaSignificance) + # Drawing no brackets is how "no pair reached significance" looks, so a test + # that never ran must say so instead of borrowing that appearance. + if !was_computed(significance) + annotations = get!(layout, "annotations", Any[]) + push!(annotations, Dict{String,Any}( + "xref" => "$xaxis_key domain", "yref" => "$yaxis_ref domain", + "x" => 0.5, "y" => 1.0, + "xanchor" => "center", "yanchor" => "bottom", + "text" => "Pairwise tests not run - $(significance.reason)", + "showarrow" => false, + "font" => Dict("size" => 10, "color" => "#b45309"), + )) + return + end + pairwise_df = significance.pairwise nrow(pairwise_df) == 0 && return all_vals = reduce(vcat, values(values_by_label); init=Float64[]) @@ -1087,7 +1181,7 @@ function alpha_boxplot(groups::AbstractVector{<:Tuple{String, Vector{String}, Ab ] traces = Any[] panel_annotations = Dict{Int, Vector{Dict{String,Any}}}() - panel_pairwise = Dict{Int, DataFrame}() + panel_pairwise = Dict{Int, AlphaSignificance}() for (pi, (yax, xax, _, _, _, panel_idx)) in enumerate(panels) panel_labels = String[] panel_values = Float64[] @@ -1139,9 +1233,9 @@ function alpha_boxplot(groups::AbstractVector{<:Tuple{String, Vector{String}, Ab if length(unique(panel_labels)) >= 2 && significance_test == "kruskal_wallis" need_pairwise = pairwise_brackets paired = paired_samples && _has_sample_pairs(panel_labels, panel_sample_ids) - p_value, pairwise_df = _alpha_significance(panel_values, panel_labels, panel_sample_ids; - pairwise=need_pairwise, - paired_samples=paired) + significance = _alpha_significance(panel_values, panel_labels, panel_sample_ids; + pairwise=need_pairwise, + paired_samples=paired) if annotate_significance anns = get!(panel_annotations, panel_idx, Dict{String,Any}[]) # Anchor to this panel's axis domain so the label remaps with its @@ -1150,12 +1244,13 @@ function alpha_boxplot(groups::AbstractVector{<:Tuple{String, Vector{String}, Ab "xref" => "$xax domain", "yref" => "$yax domain", "x" => 0.98, "y" => 0.98, "xanchor" => "right", "yanchor" => "top", - "text" => "$(paired ? (length(unique(panel_labels)) == 2 ? "Paired Wilcoxon" : "Friedman") : "KW") $(_significance_stars(p_value))
$(_format_p_value(p_value))", + "text" => _significance_caption(significance, + paired ? (length(unique(panel_labels)) == 2 ? "Paired Wilcoxon" : "Friedman") : "KW"), "showarrow" => false, "align" => "right", )) end - pairwise_brackets && (panel_pairwise[panel_idx] = pairwise_df) + pairwise_brackets && (panel_pairwise[panel_idx] = significance) end end layout = Dict{String,Any}( @@ -1287,6 +1382,37 @@ end r_available() = _ensure_r() +""" + nmds_warnings(mat, stress) -> Vector{String} + +Reasons an NMDS of the samples-by-features `mat` does not show meaningful +distances. Two samples that share no feature have a Bray-Curtis dissimilarity +of 1, the largest there is, so when the samples fall into groups that share +none, the distances between groups carry no information and the ordination +places those groups arbitrarily (`vegan::distconnected` finds the same groups). +Stress near zero is reported otherwise, usually a sign of too little data. +""" +function nmds_warnings(mat::AbstractMatrix{<:Real}, stress::Real) + n = size(mat, 1) + parent = collect(1:n) + root(i) = parent[i] == i ? i : (parent[i] = root(parent[i])) + for j in axes(mat, 2) + present = findall(>(0), view(mat, :, j)) + for i in present[2:end] + parent[root(i)] = root(present[1]) + end + end + groups = length(unique(root(i) for i in 1:n)) + if groups > 1 + return ["NMDS: the samples fall into $groups groups that share no taxa, so the " * + "distances between those groups are arbitrary. Ordinate each group separately."] + elseif isfinite(stress) && stress < 1e-3 + return ["NMDS: stress is near zero ($(round(stress; sigdigits=2))), which usually " * + "means too few samples or taxa for a meaningful ordination."] + end + String[] +end + """ run_nmds(mat; seed=123, transform="none") -> (coords::Matrix{Float64}, stress::Float64) @@ -1328,14 +1454,38 @@ function run_nmds(mat::Matrix{Float64}; seed::Integer=123, transform::String="no end end +""" + _varies_within_any_block(values, blocks) -> Bool + +Whether `values` takes at least two distinct values among the samples of some +block in `blocks` (one label per sample). +""" +function _varies_within_any_block(values::AbstractVector, blocks::AbstractVector) + first_seen = Dict{eltype(blocks),eltype(values)}() + for (v, b) in zip(values, blocks) + isequal(get!(first_seen, b, v), v) || return true + end + false +end + """ run_permanova(mat, metadata; seed=123, transform="none", blocks=nothing) -> Union{NamedTuple, Nothing} -PERMANOVA via vegan::adonis2 with 999 permutations. +PERMANOVA via vegan::adonis2 with up to 999 permutations. `metadata` is a DataFrame with one row per sample and covariate columns. +Each covariate is tested as its own term (`by = "terms"`), sequentially in +column order, so each row is conditioned on the terms before it. The top-level +`term`, `r2`, `f_statistic` and `p_value` are those of the first term. `blocks`, one label per sample (e.g. the individual a sample came from), restricts permutations to within blocks. It is ignored when no label repeats, -since singleton blocks admit no permutation at all. +since singleton blocks admit no permutation at all. A term that is constant +within every block cannot be tested by within-block permutation (each sample +never leaves its block, so the permutations never exchange that term's labels +and the p-value does not test it), so its p-value is withheld and +`untestable_reason` says why. +`permutations` is the number of permutations actually performed, which is fewer +than 999 when the blocks admit fewer, and `min_p_value` the smallest p-value +that number can produce. `transform` is applied before `vegdist`; see [`run_nmds`](@ref). """ function run_permanova(mat::Matrix{Float64}, metadata::DataFrame; seed::Integer=123, @@ -1348,6 +1498,10 @@ function run_permanova(mat::Matrix{Float64}, metadata::DataFrame; seed::Integer= formula_rhs = join(covariates, " + ") mat = transform_counts(mat; method=transform) blocked = !isnothing(blocks) && length(blocks) == size(mat, 1) && !allunique(blocks) + # Within-block permutation never exchanges the labels of a term that is + # constant inside every block, so its p-value does not test that term. + untestable = blocked ? [c for c in covariates if !_varies_within_any_block(metadata[!, c], blocks)] : + String[] with_r_lock(; timeout=R_WAIT_SECONDS[]) do meta_r = copy(metadata) @@ -1357,6 +1511,7 @@ function run_permanova(mat::Matrix{Float64}, metadata::DataFrame; seed::Integer= RCall.globalEnv[:seed] = Int(seed) RCall.globalEnv[:perm_blocks] = blocked ? String.(blocks) : String[] RCall.globalEnv[:disp_cols] = String.(covariates) + RCall.globalEnv[:perm_untestable] = String.(untestable) RCall.reval(""" set.seed(seed, kind = "Mersenne-Twister", normal.kind = "Inversion", sample.kind = "Rejection") dist_mat <- vegdist(mat, method = "bray") @@ -1368,12 +1523,25 @@ function run_permanova(mat::Matrix{Float64}, metadata::DataFrame; seed::Integer= 999 } perm_err <- NULL + perm_n <- NA_integer_ perm_res <- tryCatch( - adonis2(form, data = meta_r, permutations = perm_ctrl, parallel = 1), - error = function(e) { perm_err <<- conditionMessage(e); NULL } - ) + # vegan 2.7 defaults to by = NULL, one test of the whole model. + adonis2(form, data = meta_r, permutations = perm_ctrl, by = "terms", parallel = 1), + error = function(e) { perm_err <<- conditionMessage(e); NULL }) if (!is.null(perm_res)) { - perm_text <- paste(capture.output(print(perm_res)), collapse = "\\n") + # permute enumerates every permutation instead of drawing 999 when + # the blocks admit fewer, which small blocks make likely; the + # control adonis2 used records how many it ran. + perm_n <- attr(perm_res, "control")[["nperm"]] + # Within-block permutation never exchanges such a term's labels + # between blocks, so its p-value does not test that term. + untestable_rows <- which(rownames(perm_res) %in% perm_untestable) + perm_res[untestable_rows, "Pr(>F)"] <- NA + perm_text <- paste(c(capture.output(print(perm_res)), + if (length(untestable_rows) > 0) + paste0("Pr(>F) withheld for ", paste(rownames(perm_res)[untestable_rows], collapse = ", "), + ": constant within every permutation block, so within-block permutation does not test it.")), + collapse = "\\n") perm_r2 <- perm_res\$R2[1] perm_f <- perm_res\$F[1] perm_p <- perm_res[["Pr(>F)"]][1] @@ -1411,6 +1579,7 @@ function run_permanova(mat::Matrix{Float64}, metadata::DataFrame; seed::Integer= r2 = RCall.rcopy(RCall.reval("perm_r2")) f_stat = RCall.rcopy(RCall.reval("perm_f")) p_val = RCall.rcopy(RCall.reval("perm_p")) + n_perm = RCall.rcopy(RCall.reval("perm_n")) # adonis2 tests terms sequentially, so each row is conditioned on the terms above it. term_names = String.(vcat(RCall.rcopy(RCall.reval("perm_terms")))) term_r2 = vcat(RCall.rcopy(RCall.reval("perm_terms_r2"))) @@ -1425,20 +1594,32 @@ function run_permanova(mat::Matrix{Float64}, metadata::DataFrame; seed::Integer= (; groups = [(; group = groups[k], mean = vcat(d[:mean])[k], median = vcat(d[:median])[k]) for k in eachindex(groups)], f_statistic = d[:f], df = [Int(d[:df1]), Int(d[:df2])], p_value = d[:p], text = String(d[:text])) end - RCall.reval("rm(mat, meta_r, formula_rhs, seed, perm_blocks, disp_cols, perm_ctrl, dist_mat, form, perm_res, perm_err, perm_text, perm_r2, perm_f, perm_p, perm_terms, perm_terms_r2, perm_terms_f, perm_terms_p, disp, disp_err); gc()") + RCall.reval("rm(mat, meta_r, formula_rhs, seed, perm_blocks, disp_cols, perm_untestable, perm_ctrl, dist_mat, form, perm_res, perm_err, perm_n, perm_text, perm_r2, perm_f, perm_p, perm_terms, perm_terms_r2, perm_terms_f, perm_terms_p, disp, disp_err); if (exists(\"untestable_rows\")) rm(untestable_rows); gc()") ismissing(txt) && return nothing # When R's adonis2 threw, txt is the error message and r2/f/p are missing. # Return a named tuple with :message so the route can distinguish and surface it. ismissing(r2) && return (; message=string(txt)) + reason(t) = t in untestable ? + "'$t' is constant within every permutation block, and permutations are restricted " * + "within blocks, so its labels are never exchanged and the p-value would not test it; " * + "a between-block term needs whole blocks permuted" : + nothing + withheld(t, p) = (t in untestable || ismissing(p)) ? nothing : p + terms = [(; term=term_names[k], + r2=term_r2[k], + f_statistic=ismissing(term_f[k]) ? nothing : term_f[k], + p_value=withheld(term_names[k], term_p[k]), + untestable_reason=reason(term_names[k])) for k in eachindex(term_names)] (; text=txt, + term=term_names[1], r2=r2, f_statistic=ismissing(f_stat) ? nothing : f_stat, - p_value=ismissing(p_val) ? nothing : p_val, - terms=[(; term=term_names[k], - r2=term_r2[k], - f_statistic=ismissing(term_f[k]) ? nothing : term_f[k], - p_value=ismissing(term_p[k]) ? nothing : term_p[k]) for k in eachindex(term_names)], + p_value=withheld(term_names[1], p_val), + untestable_reason=reason(term_names[1]), + terms, + permutations=Int(n_perm), + min_p_value=1 / (Int(n_perm) + 1), blocked, dispersion) end diff --git a/src/analysis/differential.jl b/src/analysis/differential.jl index 5fad6b45..9d21d0f3 100644 --- a/src/analysis/differential.jl +++ b/src/analysis/differential.jl @@ -2,24 +2,42 @@ # SPDX-FileCopyrightText: 2026 Jonathan D.A. Jewell (hyperpolymath)
p underflowed to 0" : "") for r in sel] push!(traces, Dict{String,Any}( "type" => "scatter", "mode" => "markers", "name" => name, - "x" => [r["log2_fold_change"] for r in sel], "y" => y, + "x" => [r[effect["key"]] for r in sel], "y" => y, "text" => text, "hoverinfo" => "text+x+y", "marker" => Dict("color" => colour, "size" => 8), )) end layout = Dict{String,Any}( "title" => Dict("text" => "Differential abundance: $con vs $ref"), - "xaxis" => Dict("title" => "log2 fold change ($con / $ref)", "zeroline" => true), + "xaxis" => Dict("title" => "$(effect["label"]) ($con vs $ref)", "zeroline" => true), "yaxis" => Dict("title" => "-log10 p"), ) Dict("data" => traces, "layout" => layout) diff --git a/src/core/duckdb_store.jl b/src/core/duckdb_store.jl index bb4461a2..bc02d59d 100644 --- a/src/core/duckdb_store.jl +++ b/src/core/duckdb_store.jl @@ -184,6 +184,10 @@ function load_results_db(merge_dir::String; if !isnothing(tagging) _apply_tagging!(con, tagging) end + # Write the WAL into the file now. Closing checkpoints only when no + # other handle is still open, and a database renamed with its data + # still in the WAL arrives empty: the WAL keeps its .building name. + DBInterface.execute(con, "FORCE CHECKPOINT") ok = true finally DBInterface.close!(con) @@ -191,6 +195,9 @@ function load_results_db(merge_dir::String; if ok rm(db_path * ".wal"; force=true) mv(tmp_path, db_path; force=true) + # Should the checkpoint not have emptied it, the WAL travels with + # its database, where the next open replays it. + isfile(tmp_path * ".wal") && mv(tmp_path * ".wal", db_path * ".wal"; force=true) else rm(tmp_path; force=true) rm(tmp_path * ".wal"; force=true) diff --git a/src/core/log.jl b/src/core/log.jl index 1e9c4359..4aeda74c 100644 --- a/src/core/log.jl +++ b/src/core/log.jl @@ -177,22 +177,33 @@ export pipeline_log, log_written, reset_tool_logs, log_command const _TOOL_SECTION_CLOSE = "--- End of tool logs ---" # Drop any tool-log section a previous finalise_log left behind, keeping every - # timestamped narrative line before it. Without this the section is appended - # afresh on each re-run, and a run directory that has been re-run k times carries - # k copies of every tool log (fastqc.log for a 300-sample run is not small). - # The narrative IS a ledger and must accrete; the tool-log dump is a snapshot of - # the current files and must not. + # timestamped narrative line before and after it. Without this the section is + # appended afresh on each re-run, and a run directory that has been re-run k + # times carries k copies of every tool log (fastqc.log for a 300-sample run is + # not small). The narrative IS a ledger and must accrete; the tool-log dump is a + # snapshot of the current files and must not. A re-run's narrative lands after + # the previous section, so only the section itself, open marker to close + # marker, is removed; a section never closed (finalise_log interrupted) runs + # to the end of the file. function _strip_tool_section!(dir::String) path = joinpath(dir, "pipeline.log") isfile(path) || return nothing lines = readlines(path) - cut = findfirst(l -> endswith(l, _TOOL_SECTION_OPEN), lines) - isnothing(cut) && return nothing - open(path, "w") do io - for l in lines[1:cut-1] - println(io, l) + any(l -> endswith(l, _TOOL_SECTION_OPEN), lines) || return nothing + kept = String[] + inside = false + for l in lines + if inside + endswith(l, _TOOL_SECTION_CLOSE) && (inside = false) + elseif endswith(l, _TOOL_SECTION_OPEN) + inside = true + else + push!(kept, l) end end + open(path, "w") do io + foreach(l -> println(io, l), kept) + end nothing end diff --git a/src/core/memory_probe.jl b/src/core/memory_probe.jl new file mode 100644 index 00000000..6406c37a --- /dev/null +++ b/src/core/memory_probe.jl @@ -0,0 +1,343 @@ +# SPDX-License-Identifier: AGPL-3.0-only +# SPDX-FileCopyrightText: 2026 Jonathan D.A. Jewell (hyperpolymath)