internal/middleware: move stats to its own package

Make a package internal/middleware/stats for middleware.Stats and
middleware.ElapsedStat. This is part of removing the dependency from
internal/frontend on internal/middleware.

For golang/go#61399

Change-Id: I44afbfc9b9e28e1caabab8fe700376ec026c863d
Reviewed-on: https://go-review.googlesource.com/c/pkgsite/+/514521
TryBot-Result: Gopher Robot <gobot@golang.org>
Run-TryBot: Michael Matloob <matloob@golang.org>
Reviewed-by: Jamal Carvalho <jamal@golang.org>
kokoro-CI: kokoro <noreply+kokoro@google.com>

7 files changed, 34 insertions, 34 deletions

diff --git a/internal/postgres/details.go b/internal/postgres/details.go
index 0e67d426..871dc0ee 100644
--- a/internal/postgres/details.go
+++ b/internal/postgres/details.go
@@ -15,14 +15,14 @@ import (
 	"golang.org/x/pkgsite/internal"
 	"golang.org/x/pkgsite/internal/database"
 	"golang.org/x/pkgsite/internal/derrors"
-	"golang.org/x/pkgsite/internal/middleware"
+	"golang.org/x/pkgsite/internal/middleware/stats"
 )
 
 // GetNestedModules returns the latest major version of all nested modules
 // given a modulePath path prefix with or without major version.
 func (db *DB) GetNestedModules(ctx context.Context, modulePath string) (_ []*internal.ModuleInfo, err error) {
 	defer derrors.WrapStack(&err, "GetNestedModules(ctx, %v)", modulePath)
-	defer middleware.ElapsedStat(ctx, "GetNestedModules")()
+	defer stats.Elapsed(ctx, "GetNestedModules")()
 
 	query := `
 		SELECT DISTINCT ON (series_path)
@@ -78,7 +78,7 @@ func (db *DB) GetNestedModules(ctx context.Context, modulePath string) (_ []*int
 // Instead of supporting pagination, this query runs with a limit.
 func (db *DB) GetImportedBy(ctx context.Context, pkgPath, modulePath string, limit int) (paths []string, err error) {
 	defer derrors.WrapStack(&err, "GetImportedBy(ctx, %q, %q)", pkgPath, modulePath)
-	defer middleware.ElapsedStat(ctx, "GetImportedBy")()
+	defer stats.Elapsed(ctx, "GetImportedBy")()
 
 	if pkgPath == "" {
 		return nil, fmt.Errorf("pkgPath cannot be empty: %w", derrors.InvalidArgument)
@@ -102,7 +102,7 @@ func (db *DB) GetImportedBy(ctx context.Context, pkgPath, modulePath string, lim
 // GetImportedByCount returns the number of packages that import pkgPath.
 func (db *DB) GetImportedByCount(ctx context.Context, pkgPath, modulePath string) (_ int, err error) {
 	defer derrors.WrapStack(&err, "GetImportedByCount(ctx, %q, %q)", pkgPath, modulePath)
-	defer middleware.ElapsedStat(ctx, "GetImportedByCount")()
+	defer stats.Elapsed(ctx, "GetImportedByCount")()
 
 	if pkgPath == "" {
 		return 0, fmt.Errorf("pkgPath cannot be empty: %w", derrors.InvalidArgument)
diff --git a/internal/postgres/licenses.go b/internal/postgres/licenses.go
index a7282207..865b3fc5 100644
--- a/internal/postgres/licenses.go
+++ b/internal/postgres/licenses.go
@@ -17,13 +17,13 @@ import (
 	"github.com/lib/pq"
 	"golang.org/x/pkgsite/internal/derrors"
 	"golang.org/x/pkgsite/internal/licenses"
-	"golang.org/x/pkgsite/internal/middleware"
+	"golang.org/x/pkgsite/internal/middleware/stats"
 	"golang.org/x/pkgsite/internal/stdlib"
 )
 
 func (db *DB) getLicenses(ctx context.Context, fullPath, modulePath string, unitID int) (_ []*licenses.License, err error) {
 	defer derrors.WrapStack(&err, "getLicenses(ctx, %d)", unitID)
-	defer middleware.ElapsedStat(ctx, "getLicenses")()
+	defer stats.Elapsed(ctx, "getLicenses")()
 
 	query := `
 		SELECT
diff --git a/internal/postgres/package_symbol.go b/internal/postgres/package_symbol.go
index 5e16204b..aaa28267 100644
--- a/internal/postgres/package_symbol.go
+++ b/internal/postgres/package_symbol.go
@@ -13,14 +13,14 @@ import (
 	"golang.org/x/pkgsite/internal"
 	"golang.org/x/pkgsite/internal/database"
 	"golang.org/x/pkgsite/internal/derrors"
-	"golang.org/x/pkgsite/internal/middleware"
+	"golang.org/x/pkgsite/internal/middleware/stats"
 )
 
 // getPackageSymbols returns all of the symbols for a given package path and module path.
 func getPackageSymbols(ctx context.Context, ddb *database.DB, packagePath, modulePath string,
 ) (_ *internal.SymbolHistory, err error) {
 	defer derrors.Wrap(&err, "getPackageSymbols(ctx, ddb, %q, %q)", packagePath, modulePath)
-	defer middleware.ElapsedStat(ctx, "getPackageSymbols")()
+	defer stats.Elapsed(ctx, "getPackageSymbols")()
 
 	query := packageSymbolQueryJoin(
 		squirrel.Select(
diff --git a/internal/postgres/symbol_history.go b/internal/postgres/symbol_history.go
index 8bb51cd3..36daa992 100644
--- a/internal/postgres/symbol_history.go
+++ b/internal/postgres/symbol_history.go
@@ -13,7 +13,7 @@ import (
 	"golang.org/x/pkgsite/internal"
 	"golang.org/x/pkgsite/internal/database"
 	"golang.org/x/pkgsite/internal/derrors"
-	"golang.org/x/pkgsite/internal/middleware"
+	"golang.org/x/pkgsite/internal/middleware/stats"
 	"golang.org/x/pkgsite/internal/symbol"
 )
 
@@ -22,7 +22,7 @@ import (
 func (db *DB) GetSymbolHistory(ctx context.Context, packagePath, modulePath string,
 ) (_ *internal.SymbolHistory, err error) {
 	defer derrors.Wrap(&err, "GetSymbolHistory(ctx, %q, %q)", packagePath, modulePath)
-	defer middleware.ElapsedStat(ctx, "GetSymbolHistory")()
+	defer stats.Elapsed(ctx, "GetSymbolHistory")()
 
 	return GetSymbolHistoryFromTable(ctx, db.db, packagePath, modulePath)
 }
@@ -71,7 +71,7 @@ func GetSymbolHistoryFromTable(ctx context.Context, ddb *database.DB,
 func GetSymbolHistoryWithPackageSymbols(ctx context.Context, ddb *database.DB,
 	packagePath, modulePath string) (_ *internal.SymbolHistory, err error) {
 	defer derrors.WrapStack(&err, "GetSymbolHistoryWithPackageSymbols(ctx, ddb, %q, %q)", packagePath, modulePath)
-	defer middleware.ElapsedStat(ctx, "GetSymbolHistoryWithPackageSymbols")()
+	defer stats.Elapsed(ctx, "GetSymbolHistoryWithPackageSymbols")()
 	sh, err := getPackageSymbols(ctx, ddb, packagePath, modulePath)
 	if err != nil {
 		return nil, err
@@ -86,7 +86,7 @@ func GetSymbolHistoryWithPackageSymbols(ctx context.Context, ddb *database.DB,
 func GetSymbolHistoryForBuildContext(ctx context.Context, ddb *database.DB, pathID int, modulePath string,
 	bc internal.BuildContext) (_ map[string]string, err error) {
 	defer derrors.WrapStack(&err, "GetSymbolHistoryForBuildContext(ctx, ddb, %d, %q)", pathID, modulePath)
-	defer middleware.ElapsedStat(ctx, "GetSymbolHistoryForBuildContext")()
+	defer stats.Elapsed(ctx, "GetSymbolHistoryForBuildContext")()
 
 	if bc == internal.BuildContextAll {
 		bc = internal.BuildContextLinux
diff --git a/internal/postgres/symbolsearch.go b/internal/postgres/symbolsearch.go
index a89118ae..e50cc115 100644
--- a/internal/postgres/symbolsearch.go
+++ b/internal/postgres/symbolsearch.go
@@ -15,7 +15,7 @@ import (
 	"github.com/lib/pq"
 	"golang.org/x/pkgsite/internal/database"
 	"golang.org/x/pkgsite/internal/derrors"
-	"golang.org/x/pkgsite/internal/middleware"
+	"golang.org/x/pkgsite/internal/middleware/stats"
 	"golang.org/x/pkgsite/internal/postgres/search"
 	"golang.org/x/sync/errgroup"
 )
@@ -23,7 +23,7 @@ import (
 func upsertSymbolSearchDocuments(ctx context.Context, tx *database.DB,
 	modulePath, v string) (err error) {
 	defer derrors.Wrap(&err, "upsertSymbolSearchDocuments(ctx, ddb, %q, %q)", modulePath, v)
-	defer middleware.ElapsedStat(ctx, "upsertSymbolSearchDocuments")()
+	defer stats.Elapsed(ctx, "upsertSymbolSearchDocuments")()
 
 	// If a user is looking for the symbol "DB.Begin", from package
 	// database/sql, we want them to be able to find this by searching for
@@ -97,7 +97,7 @@ func upsertSymbolSearchDocuments(ctx context.Context, tx *database.DB,
 // TODO(https://golang.org/issue/44142): factor out common code between
 // symbolSearch and deepSearch.
 func (db *DB) symbolSearch(ctx context.Context, q string, limit int, opts SearchOptions) searchResponse {
-	defer middleware.ElapsedStat(ctx, "symbolSearch")()
+	defer stats.Elapsed(ctx, "symbolSearch")()
 
 	var (
 		results []*SearchResult
@@ -156,7 +156,7 @@ func runSymbolSearchMultiWord(ctx context.Context, ddb *database.DB, q string, l
 	symbolFilter string) (_ []*SearchResult, err error) {
 	defer derrors.Wrap(&err, "runSymbolSearchMultiWord(ctx, ddb, query, %q, %d, %q)",
 		q, limit, symbolFilter)
-	defer middleware.ElapsedStat(ctx, "runSymbolSearchMultiWord")()
+	defer stats.Elapsed(ctx, "runSymbolSearchMultiWord")()
 
 	symbolToPathTokens := multiwordSearchCombinations(q, symbolFilter)
 	if len(symbolToPathTokens) == 0 {
@@ -259,7 +259,7 @@ func multiwordSearchCombinations(q, symbolFilter string) map[string]string {
 // when using an OR in the WHERE clause.
 func runSymbolSearchOneDot(ctx context.Context, ddb *database.DB, q string, limit int) (_ []*SearchResult, err error) {
 	defer derrors.Wrap(&err, "runSymbolSearchOneDot(ctx, ddb, %q, %d)", q, limit)
-	defer middleware.ElapsedStat(ctx, "runSymbolSearchOneDot")()
+	defer stats.Elapsed(ctx, "runSymbolSearchOneDot")()
 
 	group, searchCtx := errgroup.WithContext(ctx)
 	resultsArray := make([][]*SearchResult, 2)
@@ -318,7 +318,7 @@ func splitPackageAndSymbolNames(q string) (pkgName string, symbolName string, er
 func runSymbolSearch(ctx context.Context, ddb *database.DB,
 	st search.SearchType, q string, limit int, args ...any) (results []*SearchResult, err error) {
 	defer derrors.Wrap(&err, "runSymbolSearch(ctx, ddb, %q, %q, %d, %v)", st, q, limit, args)
-	defer middleware.ElapsedStat(ctx, fmt.Sprintf("%s-runSymbolSearch", st))()
+	defer stats.Elapsed(ctx, fmt.Sprintf("%s-runSymbolSearch", st))()
 
 	collect := func(rows *sql.Rows) error {
 		var r SearchResult
diff --git a/internal/postgres/unit.go b/internal/postgres/unit.go
index e9613589..38793528 100644
--- a/internal/postgres/unit.go
+++ b/internal/postgres/unit.go
@@ -16,7 +16,7 @@ import (
 	"golang.org/x/pkgsite/internal"
 	"golang.org/x/pkgsite/internal/database"
 	"golang.org/x/pkgsite/internal/derrors"
-	"golang.org/x/pkgsite/internal/middleware"
+	"golang.org/x/pkgsite/internal/middleware/stats"
 	"golang.org/x/pkgsite/internal/stdlib"
 	"golang.org/x/pkgsite/internal/version"
 )
@@ -39,7 +39,7 @@ import (
 //	   we do have: again first by module path length, then by version.
 func (db *DB) GetUnitMeta(ctx context.Context, fullPath, requestedModulePath, requestedVersion string) (_ *internal.UnitMeta, err error) {
 	defer derrors.WrapStack(&err, "DB.GetUnitMeta(ctx, %q, %q, %q)", fullPath, requestedModulePath, requestedVersion)
-	defer middleware.ElapsedStat(ctx, "DB.GetUnitMeta")()
+	defer stats.Elapsed(ctx, "DB.GetUnitMeta")()
 
 	modulePath := requestedModulePath
 	v := requestedVersion
@@ -55,7 +55,7 @@ func (db *DB) GetUnitMeta(ctx context.Context, fullPath, requestedModulePath, re
 
 func (db *DB) getUnitMetaWithKnownVersion(ctx context.Context, fullPath, modulePath, version string, lmv *internal.LatestModuleVersions) (_ *internal.UnitMeta, err error) {
 	defer derrors.WrapStack(&err, "getUnitMetaWithKnownVersion")
-	defer middleware.ElapsedStat(ctx, "getUnitMetaWithKnownVersion")()
+	defer stats.Elapsed(ctx, "getUnitMetaWithKnownVersion")()
 
 	query := squirrel.Select(
 		"m.module_path",
@@ -146,7 +146,7 @@ func (db *DB) getLatestUnitVersion(ctx context.Context, fullPath, requestedModul
 	modulePath, latestVersion string, lmv *internal.LatestModuleVersions, err error) {
 
 	defer derrors.WrapStack(&err, "getLatestUnitVersion(%q, %q)", fullPath, requestedModulePath)
-	defer middleware.ElapsedStat(ctx, "getLatestUnitVersion")()
+	defer stats.Elapsed(ctx, "getLatestUnitVersion")()
 
 	modPaths := []string{requestedModulePath}
 	// If we don't know the module path, try each possible module path from longest to shortest.
@@ -259,7 +259,7 @@ func (db *DB) GetUnit(ctx context.Context, um *internal.UnitMeta, fields interna
 		return u, nil
 	}
 
-	defer middleware.ElapsedStat(ctx, "GetUnit")()
+	defer stats.Elapsed(ctx, "GetUnit")()
 	unitID, err := db.getUnitID(ctx, um.Path, um.ModulePath, um.Version)
 	if err != nil {
 		return nil, err
@@ -292,7 +292,7 @@ func (db *DB) GetUnit(ctx context.Context, um *internal.UnitMeta, fields interna
 
 func (db *DB) getUnitID(ctx context.Context, fullPath, modulePath, resolvedVersion string) (_ int, err error) {
 	defer derrors.WrapStack(&err, "getUnitID(ctx, %q, %q, %q)", fullPath, modulePath, resolvedVersion)
-	defer middleware.ElapsedStat(ctx, "getUnitID")()
+	defer stats.Elapsed(ctx, "getUnitID")()
 	var unitID int
 	query := `
 		SELECT u.id
@@ -317,7 +317,7 @@ func (db *DB) getUnitID(ctx context.Context, fullPath, modulePath, resolvedVersi
 // getImports returns the imports corresponding to unitID.
 func (db *DB) getImports(ctx context.Context, unitID int) (_ []string, err error) {
 	defer derrors.WrapStack(&err, "getImports(ctx, %d)", unitID)
-	defer middleware.ElapsedStat(ctx, "getImports")()
+	defer stats.Elapsed(ctx, "getImports")()
 	query := `
 		SELECT p.path
 		FROM paths p INNER JOIN imports i ON p.id = i.to_path_id
@@ -333,7 +333,7 @@ func (db *DB) getPackagesInUnit(ctx context.Context, fullPath string, moduleID i
 
 func getPackagesInUnit(ctx context.Context, db *database.DB, fullPath, modulePath, resolvedVersion string, moduleID int, bypassLicenseCheck bool) (_ []*internal.PackageMeta, err error) {
 	defer derrors.WrapStack(&err, "getPackagesInUnit(ctx, %q, %q, %q, %d)", fullPath, modulePath, resolvedVersion, moduleID)
-	defer middleware.ElapsedStat(ctx, "getPackagesInUnit")()
+	defer stats.Elapsed(ctx, "getPackagesInUnit")()
 
 	queryBuilder := squirrel.Select(
 		"p.path",
@@ -427,7 +427,7 @@ func getPackagesInUnit(ctx context.Context, db *database.DB, fullPath, modulePat
 
 func (db *DB) getUnitWithAllFields(ctx context.Context, um *internal.UnitMeta, bc internal.BuildContext) (_ *internal.Unit, err error) {
 	defer derrors.WrapStack(&err, "getUnitWithAllFields(ctx, %q, %q, %q)", um.Path, um.ModulePath, um.Version)
-	defer middleware.ElapsedStat(ctx, "getUnitWithAllFields")()
+	defer stats.Elapsed(ctx, "getUnitWithAllFields")()
 
 	// Get build contexts and unit ID.
 	var pathID, unitID, moduleID int
@@ -509,7 +509,7 @@ func (db *DB) getUnitWithAllFields(ctx context.Context, um *internal.UnitMeta, b
 		goarch = bcMatched.GOARCH
 	}
 	doc := &internal.Documentation{GOOS: bcMatched.GOOS, GOARCH: bcMatched.GOARCH}
-	end := middleware.ElapsedStat(ctx, "getUnitWithAllFields-readme-and-imports")
+	end := stats.Elapsed(ctx, "getUnitWithAllFields-readme-and-imports")
 	err = db.db.QueryRow(ctx, query, pathID, unitID, goos, goarch).Scan(
 		database.NullIsEmpty(&r.Filepath),
 		database.NullIsEmpty(&r.Contents),
diff --git a/internal/postgres/version.go b/internal/postgres/version.go
index ae116e73..00415314 100644
--- a/internal/postgres/version.go
+++ b/internal/postgres/version.go
@@ -18,7 +18,7 @@ import (
 	"golang.org/x/pkgsite/internal/database"
 	"golang.org/x/pkgsite/internal/derrors"
 	"golang.org/x/pkgsite/internal/log"
-	"golang.org/x/pkgsite/internal/middleware"
+	"golang.org/x/pkgsite/internal/middleware/stats"
 	"golang.org/x/pkgsite/internal/version"
 	"golang.org/x/sync/errgroup"
 )
@@ -28,7 +28,7 @@ import (
 // recent from a list of pseudo-versions sorted in descending semver order.
 func (db *DB) GetVersionsForPath(ctx context.Context, path string) (_ []*internal.ModuleInfo, err error) {
 	defer derrors.WrapStack(&err, "GetVersionsForPath(ctx, %q)", path)
-	defer middleware.ElapsedStat(ctx, "GetVersionsForPath")()
+	defer stats.Elapsed(ctx, "GetVersionsForPath")()
 
 	versions, err := getPathVersions(ctx, db, path, version.TypeRelease, version.TypePrerelease)
 	if err != nil {
@@ -163,7 +163,7 @@ func populateLatestInfos(ctx context.Context, db *DB, mis []*internal.ModuleInfo
 // That can save a redundant call to GetUnitMeta here.
 func (db *DB) GetLatestInfo(ctx context.Context, unitPath, modulePath string, latestUnitMeta *internal.UnitMeta) (latest internal.LatestInfo, err error) {
 	defer derrors.WrapStack(&err, "DB.GetLatestInfo(ctx, %q, %q)", unitPath, modulePath)
-	defer middleware.ElapsedStat(ctx, "DB.GetLatestInfo")()
+	defer stats.Elapsed(ctx, "DB.GetLatestInfo")()
 
 	group, gctx := errgroup.WithContext(ctx)
 
@@ -208,7 +208,7 @@ func (db *DB) GetLatestInfo(ctx context.Context, unitPath, modulePath string, la
 // it returns empty strings.
 func (db *DB) getLatestMajorVersion(ctx context.Context, fullPath, modulePath string) (modPath, pkgPath string, err error) {
 	defer derrors.WrapStack(&err, "DB.getLatestMajorVersion2(%q)", modulePath)
-	defer middleware.ElapsedStat(ctx, "DB.getLatestMajorVersion")()
+	defer stats.Elapsed(ctx, "DB.getLatestMajorVersion")()
 
 	// Collect all the non-deprecated module paths for the series that have at
 	// least one good version, along with that good version. A good version
@@ -286,7 +286,7 @@ func (db *DB) getLatestMajorVersion(ctx context.Context, fullPath, modulePath st
 // unitExistsAtLatest reports whether unitPath exists at the latest version of modulePath.
 func (db *DB) unitExistsAtLatest(ctx context.Context, unitPath, modulePath string) (unitExists bool, err error) {
 	defer derrors.WrapStack(&err, "DB.unitExistsAtLatest(ctx, %q, %q)", unitPath, modulePath)
-	defer middleware.ElapsedStat(ctx, "DB.unitExistsAtLatest")()
+	defer stats.Elapsed(ctx, "DB.unitExistsAtLatest")()
 
 	// Find the latest version of the module path in the modules table.
 	var latestGoodVersion string
@@ -336,7 +336,7 @@ func (db *DB) unitExistsAtLatest(ctx context.Context, unitPath, modulePath strin
 
 func (db *DB) getMultiLatestModuleVersions(ctx context.Context, modulePaths []string) (lmvs []*internal.LatestModuleVersions, err error) {
 	defer derrors.WrapStack(&err, "getMultiLatestModuleVersions(%v)", modulePaths)
-	defer middleware.ElapsedStat(ctx, "getMultiLatestModuleVersions")()
+	defer stats.Elapsed(ctx, "getMultiLatestModuleVersions")()
 
 	collect := func(rows *sql.Rows) error {
 		var (