feat(speedtest): add result URL support for LibreSpeed

README.md

@@ -761,6 +761,7 @@ NETRONOME__IPERF_PING_TIMEOUT=10             # Ping timeout (seconds)
 
 # LibreSpeed settings
 NETRONOME__LIBRESPEED_TIMEOUT=60             # LibreSpeed timeout (seconds)
+NETRONOME__LIBRESPEED_SHARE_RESULTS=false    # Submit results to librespeed.org for a shareable link (sends telemetry)
 ```
 
 ### Pagination

config/config.toml

@@ -36,6 +36,8 @@ timeout = 10
 
 [speedtest.librespeed]
 timeout = 60
+# Submit results to librespeed.org for a shareable link (sends telemetry)
+share_results = false
 
 [geoip]
 country_database_path = "./GeoLite2-Country.mmdb"

internal/config/config.go

@@ -99,8 +99,9 @@ type IperfConfig struct {
 }
 
 type LibrespeedConfig struct {
-	ServersPath string `toml:"-"`
-	Timeout     int    `toml:"timeout" env:"LIBRESPEED_TIMEOUT"`
+	ServersPath  string `toml:"-"`
+	Timeout      int    `toml:"timeout" env:"LIBRESPEED_TIMEOUT"`
+	ShareResults bool   `toml:"share_results" env:"LIBRESPEED_SHARE_RESULTS"`
 }
 
 type PingConfig struct {
@@ -540,6 +541,11 @@ func (c *Config) loadSpeedTestFromEnv() {
 			c.SpeedTest.Librespeed.Timeout = val
 		}
 	}
+	if v := getEnv("LIBRESPEED_SHARE_RESULTS"); v != "" {
+		if val, err := strconv.ParseBool(v); err == nil {
+			c.SpeedTest.Librespeed.ShareResults = val
+		}
+	}
 }
 
 func (c *Config) loadPaginationFromEnv() {
@@ -827,6 +833,12 @@ func (c *Config) WriteToml(w io.Writer) error {
 	if _, err := fmt.Fprintf(w, "timeout = %d\n", cfg.SpeedTest.Librespeed.Timeout); err != nil {
 		return err
 	}
+	if _, err := fmt.Fprintf(w, "# Submit results to librespeed.org for a shareable link (sends telemetry)\n"); err != nil {
+		return err
+	}
+	if _, err := fmt.Fprintf(w, "share_results = %v\n", cfg.SpeedTest.Librespeed.ShareResults); err != nil {
+		return err
+	}
 	if _, err := fmt.Fprintln(w, ""); err != nil {
 		return err
 	}

internal/database/migrations/migrations_test.go

@@ -0,0 +1,43 @@
+// Copyright (c) 2024-2026, s0up and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package migrations
+
+import (
+	"path"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// TestNoDuplicateMigrationVersions guards against two migration files sharing a
+// numeric version prefix. The migrator (pkg/migrator) applies migrations by
+// position relative to the count already applied, so a duplicate version makes
+// the sorted order ambiguous and silently skips a migration on upgrade (the new
+// file gets ordered before an already-applied one and is never run).
+//
+// The version is parsed from the file basename here rather than via the
+// production getMigrationVersion, which does not strip the directory prefix.
+func TestNoDuplicateMigrationVersions(t *testing.T) {
+	for _, dbType := range []DatabaseType{SQLite, Postgres} {
+		files, err := GetMigrationFiles(dbType)
+		if err != nil {
+			t.Fatalf("%s: failed to get migration files: %v", dbType, err)
+		}
+
+		seen := make(map[int]string, len(files))
+		for _, file := range files {
+			base := path.Base(file)
+			prefix, _, _ := strings.Cut(base, "_")
+			version, err := strconv.Atoi(prefix)
+			if err != nil {
+				t.Errorf("%s: migration %q has no numeric version prefix", dbType, file)
+				continue
+			}
+			if prev, ok := seen[version]; ok {
+				t.Errorf("%s: duplicate migration version %d: %q and %q", dbType, version, prev, file)
+			}
+			seen[version] = file
+		}
+	}
+}

internal/database/migrations/postgres/022_add_result_url_postgres.sql

@@ -0,0 +1,2 @@
+-- Add result URL column for shareable speed test links (e.g. LibreSpeed share URLs)
+ALTER TABLE speed_tests ADD COLUMN result_url TEXT;

internal/database/migrations/sqlite/022_add_result_url.sql

@@ -0,0 +1,2 @@
+-- Add result URL column for shareable speed test links (e.g. LibreSpeed share URLs)
+ALTER TABLE speed_tests ADD COLUMN result_url TEXT;

internal/database/speedtest.go

@@ -23,6 +23,7 @@ func (s *service) SaveSpeedTest(ctx context.Context, result types.SpeedTestResul
 		"latency":        result.Latency,
 		"jitter":         result.Jitter,
 		"is_scheduled":   result.IsScheduled,
+		"result_url":     result.ResultURL,
 	}
 
 	// Use provided created_at if available, otherwise default to current UTC time
@@ -120,6 +121,7 @@ func (s *service) GetSpeedTests(ctx context.Context, timeRange string, page, lim
 		"latency",
 		"jitter",
 		"is_scheduled",
+		"result_url",
 		"created_at",
 	).
 		OrderBy("created_at DESC").
@@ -146,6 +148,7 @@ func (s *service) GetSpeedTests(ctx context.Context, timeRange string, page, lim
 			&result.Latency,
 			&result.Jitter,
 			&result.IsScheduled,
+			&result.ResultURL,
 			&result.CreatedAt,
 		)
 		if err != nil {

internal/database/speedtest_integration_test.go

@@ -249,6 +249,54 @@ func TestSpeedTest_ScheduledVsManual(t *testing.T) {
 	})
 }
 
+func TestSpeedTest_ResultURLRoundTrip(t *testing.T) {
+	RunTestWithBothDatabases(t, func(t *testing.T, td *TestDatabase) {
+		ctx := context.Background()
+
+		resultURL := "https://librespeed.org/results/?id=abc123"
+
+		withURL := types.SpeedTestResult{
+			ServerName:    "Shared Server",
+			ServerID:      "librespeed-shared",
+			TestType:      "librespeed",
+			DownloadSpeed: 100.0,
+			UploadSpeed:   50.0,
+			ResultURL:     &resultURL,
+		}
+		savedWithURL, err := td.Service.SaveSpeedTest(ctx, withURL)
+		require.NoError(t, err)
+
+		withoutURL := types.SpeedTestResult{
+			ServerName:    "Unshared Server",
+			ServerID:      "librespeed-unshared",
+			TestType:      "librespeed",
+			DownloadSpeed: 100.0,
+			UploadSpeed:   50.0,
+			// ResultURL left nil
+		}
+		savedWithoutURL, err := td.Service.SaveSpeedTest(ctx, withoutURL)
+		require.NoError(t, err)
+
+		results, err := td.Service.GetSpeedTests(ctx, "all", 1, 10)
+		require.NoError(t, err)
+
+		var foundWithURL, foundWithoutURL bool
+		for _, test := range results.Data {
+			switch test.ID {
+			case savedWithURL.ID:
+				foundWithURL = true
+				require.NotNil(t, test.ResultURL, "result_url should round-trip as a non-nil pointer")
+				assert.Equal(t, resultURL, *test.ResultURL)
+			case savedWithoutURL.ID:
+				foundWithoutURL = true
+				assert.Nil(t, test.ResultURL, "absent result_url should read back as nil")
+			}
+		}
+		assert.True(t, foundWithURL, "should find the test saved with a result URL")
+		assert.True(t, foundWithoutURL, "should find the test saved without a result URL")
+	})
+}
+
 func TestSpeedTest_NullableFields(t *testing.T) {
 	RunTestWithBothDatabases(t, func(t *testing.T, td *TestDatabase) {
 		ctx := context.Background()

internal/speedtest/librespeed.go

@@ -4,11 +4,13 @@
 package speedtest
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"os"
 	"os/exec"
 	"strconv"
@@ -119,17 +121,26 @@ func (r *LibrespeedRunner) RunTest(ctx context.Context, opts *types.TestOptions)
 
 	cmd := exec.CommandContext(ctx, "librespeed-cli", args...)
 
-	output, err := cmd.CombinedOutput()
-	if err != nil {
-		log.Error().Err(err).Str("output", string(output)).Msg("librespeed-cli failed")
-		return nil, fmt.Errorf("librespeed-cli failed: %v: %s", err, string(output))
+	// Capture stdout and stderr separately: librespeed-cli writes the JSON
+	// report to stdout, while progress/UI lines and telemetry errors (emitted
+	// when --share is used) go to stderr. Keeping them apart avoids stderr
+	// noise corrupting the JSON we parse.
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	if err := cmd.Run(); err != nil {
+		log.Error().Err(err).Str("stdout", stdout.String()).Str("stderr", stderr.String()).Msg("librespeed-cli failed")
+		return nil, fmt.Errorf("librespeed-cli failed: %v: %s", err, strings.TrimSpace(stderr.String()))
 	}
 
-	log.Debug().Str("output", string(output)).Msg("librespeed-cli output")
+	output := stdout.Bytes()
+
+	log.Debug().Str("stdout", stdout.String()).Str("stderr", stderr.String()).Msg("librespeed-cli output")
 
 	var librespeedResults []LibrespeedResult
-	if err := json.Unmarshal(output, &librespeedResults); err != nil {
-		log.Error().Err(err).Str("output", string(output)).Msg("failed to parse librespeed-cli output")
+	if err := json.Unmarshal(extractJSONArray(output), &librespeedResults); err != nil {
+		log.Error().Err(err).Str("stdout", stdout.String()).Msg("failed to parse librespeed-cli output")
 		return nil, fmt.Errorf("failed to parse librespeed-cli output: %w", err)
 	}
 
@@ -151,6 +162,7 @@ func (r *LibrespeedRunner) RunTest(ctx context.Context, opts *types.TestOptions)
 		UploadSpeed:   librespeedResult.Upload,
 		Latency:       fmt.Sprintf("%.2f", librespeedResult.Ping),
 		Jitter:        librespeedResult.Jitter,
+		ResultURL:     sanitizeResultURL(librespeedResult.Share),
 	}
 
 	// Final completion update
@@ -172,6 +184,10 @@ func (r *LibrespeedRunner) RunTest(ctx context.Context, opts *types.TestOptions)
 func (r *LibrespeedRunner) buildArgs(opts *types.TestOptions) []string {
 	args := []string{"--json"}
 
+	if r.config.ShareResults {
+		args = append(args, "--share")
+	}
+
 	if opts.IsPublicServer {
 		// Keep CLI server IDs in sync with our fetched public list.
 		args = append(args, "--server-json", librespeedPublicServersURL)
@@ -326,3 +342,31 @@ func parseCountryFromName(name string) string {
 	}
 	return "Unknown"
 }
+
+// extractJSONArray trims any leading non-JSON output (e.g. progress/log lines
+// librespeed-cli may print before the JSON report) so the result can be
+// unmarshalled. It returns b starting at the first '['; if there is no '[' or
+// it is already at the start, b is returned unchanged.
+func extractJSONArray(b []byte) []byte {
+	if idx := bytes.IndexByte(b, '['); idx > 0 {
+		return b[idx:]
+	}
+	return b
+}
+
+// sanitizeResultURL validates a share URL from librespeed-cli output.
+// Returns the normalized URL if valid (http/https with a host), empty string otherwise.
+func sanitizeResultURL(raw string) string {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return ""
+	}
+	u, err := url.Parse(raw)
+	if err != nil {
+		return ""
+	}
+	if (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" {
+		return ""
+	}
+	return u.String()
+}

internal/speedtest/librespeed_test.go

@@ -29,6 +29,82 @@ func TestBuildArgsUsesServerJSONForPublicServers(t *testing.T) {
 	}, args)
 }
 
+func TestBuildArgsShareFlag(t *testing.T) {
+	tests := []struct {
+		name         string
+		shareResults bool
+		wantShare    bool
+	}{
+		{"included when enabled", true, true},
+		{"excluded when disabled", false, false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			runner := NewLibrespeedRunner(config.LibrespeedConfig{
+				ServersPath:  "/tmp/local-servers.json",
+				ShareResults: tt.shareResults,
+			})
+
+			args := runner.buildArgs(&types.TestOptions{
+				IsPublicServer: true,
+				ServerIDs:      []string{"123"},
+			})
+
+			if tt.wantShare {
+				assert.Contains(t, args, "--share")
+			} else {
+				assert.NotContains(t, args, "--share")
+			}
+		})
+	}
+}
+
+func TestSanitizeResultURL(t *testing.T) {
+	tests := []struct {
+		name string
+		raw  string
+		want string
+	}{
+		{"valid https URL", "https://librespeed.org/results/?id=abc123", "https://librespeed.org/results/?id=abc123"},
+		{"valid http URL", "http://librespeed.org/results/?id=abc123", "http://librespeed.org/results/?id=abc123"},
+		{"uppercase scheme normalized", "HTTPS://librespeed.org/results/?id=abc123", "https://librespeed.org/results/?id=abc123"},
+		{"surrounding whitespace trimmed", "  https://librespeed.org/results/?id=abc123  ", "https://librespeed.org/results/?id=abc123"},
+		{"empty string", "", ""},
+		{"no scheme", "librespeed.org/results", ""},
+		{"javascript scheme", "javascript:alert(1)", ""},
+		{"ftp scheme", "ftp://example.com/file", ""},
+		{"no host", "https:///path", ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, sanitizeResultURL(tt.raw))
+		})
+	}
+}
+
+func TestExtractJSONArray(t *testing.T) {
+	tests := []struct {
+		name string
+		in   string
+		want string
+	}{
+		{"clean array", `[{"download":1}]`, `[{"download":1}]`},
+		{"array at offset zero unchanged", `[1,2,3]`, `[1,2,3]`},
+		{"leading log line", "Selected server: foo\n[{\"download\":1}]", `[{"download":1}]`},
+		{"multiple leading lines", "retrieving servers\nrunning test\n[{\"download\":1}]", `[{"download":1}]`},
+		{"no array present", "no json here", "no json here"},
+		{"empty", "", ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, string(extractJSONArray([]byte(tt.in))))
+		})
+	}
+}
+
 func TestBuildArgsUsesLocalJSONForCustomServers(t *testing.T) {
 	runner := NewLibrespeedRunner(config.LibrespeedConfig{
 		ServersPath: "/tmp/local-servers.json",

internal/speedtest/result_handler.go

@@ -57,6 +57,11 @@ func (h *DefaultResultHandler) SaveResult(ctx context.Context, result *Result, t
 		jitterPtr = &result.Jitter
 	}
 
+	var resultURL *string
+	if result.ResultURL != "" {
+		resultURL = &result.ResultURL
+	}
+
 	// Give the DB write up to 10s while still respecting upstream cancellations and values.
 	saveCtx, saveCancel := context.WithTimeout(ctx, 10*time.Second)
 	defer saveCancel()
@@ -73,6 +78,7 @@ func (h *DefaultResultHandler) SaveResult(ctx context.Context, result *Result, t
 		Latency:       result.Latency,
 		Jitter:        jitterPtr,
 		IsScheduled:   opts.IsScheduled,
+		ResultURL:     resultURL,
 		CreatedAt:     createdAt,
 	})
 	if err != nil {