replace github.com/ipfs/go-log with stdlib log/slog

automod/consumer/firehose.go

···
 		fc.Logger.Info("hepa scheduler configured", "scheduler", "autoscaling", "initial", scaleSettings.Concurrency, "max", scaleSettings.MaxConcurrency)
 	}
 
-	return events.HandleRepoStream(ctx, con, scheduler)
+	return events.HandleRepoStream(ctx, con, scheduler, fc.Logger)
 }
 
 // NOTE: for now, this function basically never errors, just logs and returns nil. Should think through error processing better.

bgs/admin.go

···
 		ctx := context.Background()
 		err := bgs.ResyncPDS(ctx, pds)
 		if err != nil {
-			log.Errorw("failed to resync PDS", "err", err, "pds", pds.Host)
+			log.Error("failed to resync PDS", "err", err, "pds", pds.Host)
 		}
 	}()
 

bgs/bgs.go

···
 	"encoding/json"
 	"errors"
 	"fmt"
+	"log/slog"
 	"net"
 	"net/http"
 	_ "net/http/pprof"
 	"net/url"
+	"reflect"
 	"strconv"
 	"strings"
 	"sync"
···
 	"github.com/gorilla/websocket"
 	"github.com/ipfs/go-cid"
 	ipld "github.com/ipfs/go-ipld-format"
-	logging "github.com/ipfs/go-log"
 	"github.com/labstack/echo/v4"
 	"github.com/labstack/echo/v4/middleware"
 	promclient "github.com/prometheus/client_golang/prometheus"
···
 	"gorm.io/gorm"
 )
 
-var log = logging.Logger("bgs")
 var tracer = otel.Tracer("bgs")
 
 // serverListenerBootTimeout is how long to wait for the requested server socket
···
 	// nextCrawlers gets forwarded POST /xrpc/com.atproto.sync.requestCrawl
 	nextCrawlers []*url.URL
 	httpClient   http.Client
+
+	log *slog.Logger
 }
 
 type PDSResync struct {
···
 		pdsResyncs: make(map[uint]*PDSResync),
 
 		userCache: uc,
+
+		log: slog.Default().With("system", "bgs"),
 	}
 
 	ix.CreateExternalUser = bgs.createExternalUser
···
 		act, err := bgs.Index.GetUserOrMissing(ctx, did)
 		if err != nil {
 			w.WriteHeader(500)
-			log.Errorf("failed to get user: %s", err)
+			bgs.log.Error("failed to get user", "err", err)
 			return
 		}
 
 		if err := bgs.Index.Crawler.Crawl(ctx, act); err != nil {
 			w.WriteHeader(500)
-			log.Errorf("failed to add user to crawler: %s", err)
+			bgs.log.Error("failed to add user to crawler", "err", err)
 			return
 		}
 	})
···
 			if err2 := ctx.JSON(err.Code, map[string]any{
 				"error": err.Message,
 			}); err2 != nil {
-				log.Errorf("Failed to write http error: %s", err2)
+				bgs.log.Error("Failed to write http error", "err", err2)
 			}
 		default:
 			sendHeader := true
···
 				sendHeader = false
 			}
 
-			log.Warnf("HANDLER ERROR: (%s) %s", ctx.Path(), err)
+			bgs.log.Warn("HANDLER ERROR: (%s) %s", ctx.Path(), err)
 
 			if strings.HasPrefix(ctx.Path(), "/admin/") {
 				ctx.JSON(500, map[string]any{
···
 
 func (bgs *BGS) HandleHealthCheck(c echo.Context) error {
 	if err := bgs.db.Exec("SELECT 1").Error; err != nil {
-		log.Errorf("healthcheck can't connect to database: %v", err)
+		bgs.log.Error("healthcheck can't connect to database", "err", err)
 		return c.JSON(500, HealthStatus{Status: "error", Message: "can't connect to database"})
 	} else {
 		return c.JSON(200, HealthStatus{Status: "ok"})
···
 
 	var m = &dto.Metric{}
 	if err := c.EventsSent.Write(m); err != nil {
-		log.Errorf("failed to get sent counter: %s", err)
+		bgs.log.Error("failed to get sent counter", "err", err)
 	}
 
-	log.Infow("consumer disconnected",
+	bgs.log.Info("consumer disconnected",
 		"consumer_id", id,
 		"remote_addr", c.RemoteAddr,
 		"user_agent", c.UserAgent,
···
 				}
 
 				if err := conn.WriteControl(websocket.PingMessage, []byte{}, time.Now().Add(5*time.Second)); err != nil {
-					log.Warnf("failed to ping client: %s", err)
+					bgs.log.Warn("failed to ping client: %s", err)
 					cancel()
 					return
 				}
···
 		for {
 			_, _, err := conn.ReadMessage()
 			if err != nil {
-				log.Warnf("failed to read message from client: %s", err)
+				bgs.log.Warn("failed to read message from client: %s", err)
 				cancel()
 				return
 			}
···
 	consumerID := bgs.registerConsumer(&consumer)
 	defer bgs.cleanupConsumer(consumerID)
 
-	logger := log.With(
+	logger := bgs.log.With(
 		"consumer_id", consumerID,
 		"remote_addr", consumer.RemoteAddr,
 		"user_agent", consumer.UserAgent,
 	)
 
-	logger.Infow("new consumer", "cursor", since)
+	logger.Info("new consumer", "cursor", since)
 
 	for {
 		select {
···
 
 			wc, err := conn.NextWriter(websocket.BinaryMessage)
 			if err != nil {
-				logger.Errorf("failed to get next writer: %s", err)
+				logger.Error("failed to get next writer", "err", err)
 				return err
 			}
 
···
 			}
 
 			if err := wc.Close(); err != nil {
-				logger.Warnf("failed to flush-close our event write: %s", err)
+				logger.Warn("failed to flush-close our event write", "err", err)
 				return nil
 			}
 
···
 	// defensive in case things change under the hood.
 	registry, ok := promclient.DefaultRegisterer.(*promclient.Registry)
 	if !ok {
-		log.Warnf("failed to export default prometheus registry; some metrics will be unavailable; unexpected type: %T", promclient.DefaultRegisterer)
+		slog.Warn("failed to export default prometheus registry; some metrics will be unavailable; unexpected type", "type", reflect.TypeOf(promclient.DefaultRegisterer))
 	}
 	exporter, err := prometheus.NewExporter(prometheus.Options{
 		Registry:  registry,
 		Namespace: "bigsky",
 	})
 	if err != nil {
-		log.Errorf("could not create the prometheus stats exporter: %v", err)
+		slog.Error("could not create the prometheus stats exporter", "err", err, "system", "bgs")
 	}
 
 	return exporter
···
 	case env.RepoCommit != nil:
 		repoCommitsReceivedCounter.WithLabelValues(host.Host).Add(1)
 		evt := env.RepoCommit
-		log.Debugw("bgs got repo append event", "seq", evt.Seq, "pdsHost", host.Host, "repo", evt.Repo)
+		bgs.log.Debug("bgs got repo append event", "seq", evt.Seq, "pdsHost", host.Host, "repo", evt.Repo)
 
 		s := time.Now()
 		u, err := bgs.lookupUserByDid(ctx, evt.Repo)
···
 
 		if u.GetTakenDown() || ustatus == events.AccountStatusTakendown {
 			span.SetAttributes(attribute.Bool("taken_down_by_relay_admin", u.GetTakenDown()))
-			log.Debugw("dropping commit event from taken down user", "did", evt.Repo, "seq", evt.Seq, "pdsHost", host.Host)
+			bgs.log.Debug("dropping commit event from taken down user", "did", evt.Repo, "seq", evt.Seq, "pdsHost", host.Host)
 			repoCommitsResultCounter.WithLabelValues(host.Host, "tdu").Inc()
 			return nil
 		}
 
 		if ustatus == events.AccountStatusSuspended {
-			log.Debugw("dropping commit event from suspended user", "did", evt.Repo, "seq", evt.Seq, "pdsHost", host.Host)
+			bgs.log.Debug("dropping commit event from suspended user", "did", evt.Repo, "seq", evt.Seq, "pdsHost", host.Host)
 			repoCommitsResultCounter.WithLabelValues(host.Host, "susu").Inc()
 			return nil
 		}
 
 		if ustatus == events.AccountStatusDeactivated {
-			log.Debugw("dropping commit event from deactivated user", "did", evt.Repo, "seq", evt.Seq, "pdsHost", host.Host)
+			bgs.log.Debug("dropping commit event from deactivated user", "did", evt.Repo, "seq", evt.Seq, "pdsHost", host.Host)
 			repoCommitsResultCounter.WithLabelValues(host.Host, "du").Inc()
 			return nil
 		}
···
 		}
 
 		if host.ID != u.PDS && u.PDS != 0 {
-			log.Warnw("received event for repo from different pds than expected", "repo", evt.Repo, "expPds", u.PDS, "gotPds", host.Host)
+			bgs.log.Warn("received event for repo from different pds than expected", "repo", evt.Repo, "expPds", u.PDS, "gotPds", host.Host)
 			// Flush any cached DID documents for this user
 			bgs.didr.FlushCacheFor(env.RepoCommit.Repo)
 
···
 			if errors.Is(err, carstore.ErrRepoBaseMismatch) || ipld.IsNotFound(err) {
 				ai, lerr := bgs.Index.LookupUser(ctx, u.ID)
 				if lerr != nil {
-					log.Warnw("failed handling event, no user", "err", err, "pdsHost", host.Host, "seq", evt.Seq, "repo", u.Did, "prev", stringLink(evt.Prev), "commit", evt.Commit.String())
+					log.Warn("failed handling event, no user", "err", err, "pdsHost", host.Host, "seq", evt.Seq, "repo", u.Did, "prev", stringLink(evt.Prev), "commit", evt.Commit.String())
 					repoCommitsResultCounter.WithLabelValues(host.Host, "nou4").Inc()
 					return fmt.Errorf("failed to look up user %s (%d) (err case: %s): %w", u.Did, u.ID, err, lerr)
 				}
 
 				span.SetAttributes(attribute.Bool("catchup_queue", true))
 
-				log.Infow("failed handling event, catchup", "err", err, "pdsHost", host.Host, "seq", evt.Seq, "repo", u.Did, "prev", stringLink(evt.Prev), "commit", evt.Commit.String())
+				log.Info("failed handling event, catchup", "err", err, "pdsHost", host.Host, "seq", evt.Seq, "repo", u.Did, "prev", stringLink(evt.Prev), "commit", evt.Commit.String())
 				repoCommitsResultCounter.WithLabelValues(host.Host, "catchup2").Inc()
 				return bgs.Index.Crawler.AddToCatchupQueue(ctx, host, ai, evt)
 			}
 
-			log.Warnw("failed handling event", "err", err, "pdsHost", host.Host, "seq", evt.Seq, "repo", u.Did, "prev", stringLink(evt.Prev), "commit", evt.Commit.String())
+			log.Warn("failed handling event", "err", err, "pdsHost", host.Host, "seq", evt.Seq, "repo", u.Did, "prev", stringLink(evt.Prev), "commit", evt.Commit.String())
 			repoCommitsResultCounter.WithLabelValues(host.Host, "err").Inc()
 			return fmt.Errorf("handle user event failed: %w", err)
 		}
···
 		repoCommitsResultCounter.WithLabelValues(host.Host, "ok").Inc()
 		return nil
 	case env.RepoHandle != nil:
-		log.Infow("bgs got repo handle event", "did", env.RepoHandle.Did, "handle", env.RepoHandle.Handle)
+		bgs.log.Info("bgs got repo handle event", "did", env.RepoHandle.Did, "handle", env.RepoHandle.Handle)
 		// Flush any cached DID documents for this user
 		bgs.didr.FlushCacheFor(env.RepoHandle.Did)
 
···
 		}
 
 		if act.Handle.String != env.RepoHandle.Handle {
-			log.Warnw("handle update did not update handle to asserted value", "did", env.RepoHandle.Did, "expected", env.RepoHandle.Handle, "actual", act.Handle)
+			bgs.log.Warn("handle update did not update handle to asserted value", "did", env.RepoHandle.Did, "expected", env.RepoHandle.Handle, "actual", act.Handle)
 		}
 
 		// TODO: Update the ReposHandle event type to include "verified" or something
···
 			},
 		})
 		if err != nil {
-			log.Errorw("failed to broadcast RepoHandle event", "error", err, "did", env.RepoHandle.Did, "handle", env.RepoHandle.Handle)
+			bgs.log.Error("failed to broadcast RepoHandle event", "error", err, "did", env.RepoHandle.Did, "handle", env.RepoHandle.Handle)
 			return fmt.Errorf("failed to broadcast RepoHandle event: %w", err)
 		}
 
 		return nil
 	case env.RepoIdentity != nil:
-		log.Infow("bgs got identity event", "did", env.RepoIdentity.Did)
+		bgs.log.Info("bgs got identity event", "did", env.RepoIdentity.Did)
 		// Flush any cached DID documents for this user
 		bgs.didr.FlushCacheFor(env.RepoIdentity.Did)
 
···
 			},
 		})
 		if err != nil {
-			log.Errorw("failed to broadcast Identity event", "error", err, "did", env.RepoIdentity.Did)
+			bgs.log.Error("failed to broadcast Identity event", "error", err, "did", env.RepoIdentity.Did)
 			return fmt.Errorf("failed to broadcast Identity event: %w", err)
 		}
 
···
 			span.SetAttributes(attribute.String("repo_status", *env.RepoAccount.Status))
 		}
 
-		log.Infow("bgs got account event", "did", env.RepoAccount.Did)
+		bgs.log.Info("bgs got account event", "did", env.RepoAccount.Did)
 		// Flush any cached DID documents for this user
 		bgs.didr.FlushCacheFor(env.RepoAccount.Did)
 
···
 		// Check if the PDS is still authoritative
 		// if not we don't want to be propagating this account event
 		if ai.PDS != host.ID {
-			log.Errorw("account event from non-authoritative pds",
+			bgs.log.Error("account event from non-authoritative pds",
 				"seq", env.RepoAccount.Seq,
 				"did", env.RepoAccount.Did,
 				"event_from", host.Host,
···
 			},
 		})
 		if err != nil {
-			log.Errorw("failed to broadcast Account event", "error", err, "did", env.RepoAccount.Did)
+			bgs.log.Error("failed to broadcast Account event", "error", err, "did", env.RepoAccount.Did)
 			return fmt.Errorf("failed to broadcast Account event: %w", err)
 		}
 
···
 	// delete data from carstore
 	if err := bgs.repoman.TakeDownRepo(ctx, u.ID); err != nil {
 		// don't let a failure here prevent us from propagating this event
-		log.Errorf("failed to delete user data from carstore: %s", err)
+		bgs.log.Error("failed to delete user data from carstore", "err", err)
 	}
 
 	return bgs.events.AddEvent(ctx, &events.XRPCStreamEvent{
···
 
 	externalUserCreationAttempts.Inc()
 
-	log.Debugf("create external user: %s", did)
+	s.log.Debug("create external user", "did", did)
 	doc, err := s.didr.GetDocument(ctx, did)
 	if err != nil {
 		return nil, fmt.Errorf("could not locate DID document for followed user (%s): %w", did, err)
···
 	// TODO: the PDS's DID should also be in the service, we could use that to look up?
 	var peering models.PDS
 	if err := s.db.Find(&peering, "host = ?", durl.Host).Error; err != nil {
-		log.Error("failed to find pds", durl.Host)
+		s.log.Error("failed to find pds", "host", durl.Host)
 		return nil, err
 	}
 
···
 	defer func() {
 		if !successfullyCreated {
 			if err := s.db.Model(&models.PDS{}).Where("id = ?", peering.ID).Update("repo_count", gorm.Expr("repo_count - 1")).Error; err != nil {
-				log.Errorf("failed to decrement repo count for pds: %s", err)
+				s.log.Error("failed to decrement repo count for pds", "err", err)
 			}
 		}
 	}()
···
 		return nil, err
 	}
 
-	log.Debugw("creating external user", "did", did, "handle", hurl.Host, "pds", peering.ID)
+	s.log.Debug("creating external user", "did", did, "handle", hurl.Host, "pds", peering.ID)
 
 	handle := hurl.Host
 
···
 
 	resdid, err := s.hr.ResolveHandleToDid(ctx, handle)
 	if err != nil {
-		log.Errorf("failed to resolve users claimed handle (%q) on pds: %s", handle, err)
+		s.log.Error("failed to resolve users claimed handle on pds", "handle", handle, "err", err)
 		validHandle = false
 	}
 
 	if resdid != did {
-		log.Errorf("claimed handle did not match servers response (%s != %s)", resdid, did)
+		s.log.Error("claimed handle did not match servers response", "resdid", resdid, "did", did)
 		validHandle = false
 	}
 
···
 
 	exu, err := s.Index.LookupUserByDid(ctx, did)
 	if err == nil {
-		log.Debugw("lost the race to create a new user", "did", did, "handle", handle, "existing_hand", exu.Handle)
+		s.log.Debug("lost the race to create a new user", "did", did, "handle", handle, "existing_hand", exu.Handle)
 		if exu.PDS != peering.ID {
 			// User is now on a different PDS, update
 			if err := s.db.Model(User{}).Where("id = ?", exu.Uid).Update("pds", peering.ID).Error; err != nil {
···
 		// delete data from carstore
 		if err := bgs.repoman.TakeDownRepo(ctx, u.ID); err != nil {
 			// don't let a failure here prevent us from propagating this event
-			log.Errorf("failed to delete user data from carstore: %s", err)
+			bgs.log.Error("failed to delete user data from carstore", "err", err)
 		}
 	}
 
···
 func (bgs *BGS) ResyncPDS(ctx context.Context, pds models.PDS) error {
 	ctx, span := tracer.Start(ctx, "ResyncPDS")
 	defer span.End()
-	log := log.With("pds", pds.Host, "source", "resync_pds")
+	log := bgs.log.With("pds", pds.Host, "source", "resync_pds")
 	resync, found := bgs.LoadOrStoreResync(pds)
 	if found {
 		return fmt.Errorf("resync already in progress")
···
 	for {
 		pages++
 		if pages%10 == 0 {
-			log.Warnw("fetching PDS page during resync", "pages", pages, "total_repos", len(repos))
+			log.Warn("fetching PDS page during resync", "pages", pages, "total_repos", len(repos))
 			resync.NumRepoPages = pages
 			resync.NumRepos = len(repos)
 			bgs.UpdateResync(resync)
 		}
 		if err := limiter.Wait(ctx); err != nil {
-			log.Errorw("failed to wait for rate limiter", "error", err)
+			log.Error("failed to wait for rate limiter", "error", err)
 			return fmt.Errorf("failed to wait for rate limiter: %w", err)
 		}
 		repoList, err := comatproto.SyncListRepos(ctx, &xrpcc, cursor, limit)
 		if err != nil {
-			log.Errorw("failed to list repos", "error", err)
+			log.Error("failed to list repos", "error", err)
 			return fmt.Errorf("failed to list repos: %w", err)
 		}
 
···
 
 	repolistDone := time.Now()
 
-	log.Warnw("listed all repos, checking roots", "num_repos", len(repos), "took", repolistDone.Sub(start))
+	log.Warn("listed all repos, checking roots", "num_repos", len(repos), "took", repolistDone.Sub(start))
 	resync = bgs.SetResyncStatus(pds.ID, "checking revs")
 
 	// run loop over repos with some concurrency
···
 	// Check repo revs against our local copy and enqueue crawls for any that are out of date
 	for i, r := range repos {
 		if err := sem.Acquire(ctx, 1); err != nil {
-			log.Errorw("failed to acquire semaphore", "error", err)
+			log.Error("failed to acquire semaphore", "error", err)
 			continue
 		}
 		go func(r comatproto.SyncListRepos_Repo) {
 			defer sem.Release(1)
-			log := log.With("did", r.Did, "remote_rev", r.Rev)
+			log := bgs.log.With("did", r.Did, "remote_rev", r.Rev)
 			// Fetches the user if we have it, otherwise automatically enqueues it for crawling
 			ai, err := bgs.Index.GetUserOrMissing(ctx, r.Did)
 			if err != nil {
-				log.Errorw("failed to get user while resyncing PDS, we can't recrawl it", "error", err)
+				log.Error("failed to get user while resyncing PDS, we can't recrawl it", "error", err)
 				return
 			}
 
 			rev, err := bgs.repoman.GetRepoRev(ctx, ai.Uid)
 			if err != nil {
-				log.Warnw("recrawling because we failed to get the local repo root", "err", err, "uid", ai.Uid)
+				log.Warn("recrawling because we failed to get the local repo root", "err", err, "uid", ai.Uid)
 				err := bgs.Index.Crawler.Crawl(ctx, ai)
 				if err != nil {
-					log.Errorw("failed to enqueue crawl for repo during resync", "error", err, "uid", ai.Uid, "did", ai.Did)
+					log.Error("failed to enqueue crawl for repo during resync", "error", err, "uid", ai.Uid, "did", ai.Did)
 				}
 				return
 			}
 
 			if rev == "" || rev < r.Rev {
-				log.Warnw("recrawling because the repo rev from the PDS is newer than our local repo rev", "local_rev", rev)
+				log.Warn("recrawling because the repo rev from the PDS is newer than our local repo rev", "local_rev", rev)
 				err := bgs.Index.Crawler.Crawl(ctx, ai)
 				if err != nil {
-					log.Errorw("failed to enqueue crawl for repo during resync", "error", err, "uid", ai.Uid, "did", ai.Did)
+					log.Error("failed to enqueue crawl for repo during resync", "error", err, "uid", ai.Uid, "did", ai.Did)
 				}
 				return
 			}
 		}(r)
 		if i%100 == 0 {
 			if i%10_000 == 0 {
-				log.Warnw("checked revs during resync", "num_repos_checked", i, "num_repos_to_crawl", -1, "took", time.Now().Sub(resync.StatusChangedAt))
+				log.Warn("checked revs during resync", "num_repos_checked", i, "num_repos_to_crawl", -1, "took", time.Now().Sub(resync.StatusChangedAt))
 			}
 			resync.NumReposChecked = i
 			bgs.UpdateResync(resync)
···
 	resync.NumReposChecked = len(repos)
 	bgs.UpdateResync(resync)
 
-	log.Warnw("enqueued all crawls, exiting resync", "took", time.Now().Sub(start), "num_repos_to_crawl", -1)
+	bgs.log.Warn("enqueued all crawls, exiting resync", "took", time.Now().Sub(start), "num_repos_to_crawl", -1)
 
 	return nil
 }

bgs/compactor.go

···
 	}
 	if c.requeueInterval > 0 {
 		go func() {
-			log.Infow("starting compactor requeue routine",
+			log.Info("starting compactor requeue routine",
 				"interval", c.requeueInterval,
 				"limit", c.requeueLimit,
 				"shardCount", c.requeueShardCount,
···
 					ctx := context.Background()
 					ctx, span := otel.Tracer("compactor").Start(ctx, "RequeueRoutine")
 					if err := c.EnqueueAllRepos(ctx, bgs, c.requeueLimit, c.requeueShardCount, c.requeueFast); err != nil {
-						log.Errorw("failed to enqueue all repos", "err", err)
+						log.Error("failed to enqueue all repos", "err", err)
 					}
 					span.End()
 				}
···
 				time.Sleep(time.Second * 5)
 				continue
 			}
-			log.Errorw("failed to compact repo",
+			log.Error("failed to compact repo",
 				"err", err,
 				"uid", state.latestUID,
 				"repo", state.latestDID,
···
 			// Pause for a bit to avoid spamming failed compactions
 			time.Sleep(time.Millisecond * 100)
 		} else {
-			log.Infow("compacted repo",
+			log.Info("compacted repo",
 				"uid", state.latestUID,
 				"repo", state.latestDID,
 				"status", state.status,
···
 func (c *Compactor) EnqueueRepo(ctx context.Context, user *User, fast bool) {
 	ctx, span := otel.Tracer("compactor").Start(ctx, "EnqueueRepo")
 	defer span.End()
-	log.Infow("enqueueing compaction for repo", "repo", user.Did, "uid", user.ID, "fast", fast)
+	log.Info("enqueueing compaction for repo", "repo", user.Did, "uid", user.ID, "fast", fast)
 	c.q.Append(user.ID, fast)
 }
 
···
 		c.q.Append(r.Usr, fast)
 	}
 
-	log.Infow("done enqueueing all repos", "repos_enqueued", len(repos))
+	log.Info("done enqueueing all repos", "repos_enqueued", len(repos))
 
 	return nil
 }

bgs/fedmgr.go

···
 	"context"
 	"errors"
 	"fmt"
+	"log/slog"
 	"math/rand"
 	"strings"
 	"sync"
···
 	pq "github.com/lib/pq"
 	"gorm.io/gorm"
 )
+
+var log = slog.Default().With("system", "bgs")
 
 type IndexCallback func(context.Context, *models.PDS, *events.XRPCStreamEvent) error
 
···
 				var errs []error
 				if errs = s.flushCursors(ctx); len(errs) > 0 {
 					for _, err := range errs {
-						log.Errorf("failed to flush cursors on shutdown: %s", err)
+						log.Error("failed to flush cursors on shutdown", "err", err)
 					}
 				}
 				log.Info("done flushing PDS cursors on shutdown")
···
 				defer span.End()
 				if errs := s.flushCursors(ctx); len(errs) > 0 {
 					for _, err := range errs {
-						log.Errorf("failed to flush cursors: %s", err)
+						log.Error("failed to flush cursors", "err", err)
 					}
 				}
 				log.Debug("done flushing PDS cursors")
···
 	errs := <-s.shutdownResult
 	if len(errs) > 0 {
 		for _, err := range errs {
-			log.Errorf("shutdown error: %s", err)
+			log.Error("shutdown error", "err", err)
 		}
 	}
 	log.Info("slurper shutdown complete")
···
 		url := fmt.Sprintf("%s://%s/xrpc/com.atproto.sync.subscribeRepos?cursor=%d", protocol, host.Host, cursor)
 		con, res, err := d.DialContext(ctx, url, nil)
 		if err != nil {
-			log.Warnw("dialing failed", "pdsHost", host.Host, "err", err, "backoff", backoff)
+			log.Warn("dialing failed", "pdsHost", host.Host, "err", err, "backoff", backoff)
 			time.Sleep(sleepForBackoff(backoff))
 			backoff++
 
 			if backoff > 15 {
-				log.Warnw("pds does not appear to be online, disabling for now", "pdsHost", host.Host)
+				log.Warn("pds does not appear to be online, disabling for now", "pdsHost", host.Host)
 				if err := s.db.Model(&models.PDS{}).Where("id = ?", host.ID).Update("registered", false).Error; err != nil {
-					log.Errorf("failed to unregister failing pds: %w", err)
+					log.Error("failed to unregister failing pds", "err", err)
 				}
 
 				return
···
 			continue
 		}
 
-		log.Info("event subscription response code: ", res.StatusCode)
+		log.Info("event subscription response", "code", res.StatusCode)
 
 		curCursor := cursor
 		if err := s.handleConnection(ctx, host, con, &cursor, sub); err != nil {
 			if errors.Is(err, ErrTimeoutShutdown) {
-				log.Infof("shutting down pds subscription to %s, no activity after %s", host.Host, EventsTimeout)
+				log.Info("shutting down pds subscription after timeout", "host", host.Host, "time", EventsTimeout)
 				return
 			}
-			log.Warnf("connection to %q failed: %s", host.Host, err)
+			log.Warn("connection to failed", "host", host.Host, "err", err)
 		}
 
 		if cursor > curCursor {
···
 
 	rsc := &events.RepoStreamCallbacks{
 		RepoCommit: func(evt *comatproto.SyncSubscribeRepos_Commit) error {
-			log.Debugw("got remote repo event", "pdsHost", host.Host, "repo", evt.Repo, "seq", evt.Seq)
+			log.Debug("got remote repo event", "pdsHost", host.Host, "repo", evt.Repo, "seq", evt.Seq)
 			if err := s.cb(context.TODO(), host, &events.XRPCStreamEvent{
 				RepoCommit: evt,
 			}); err != nil {
-				log.Errorf("failed handling event from %q (%d): %s", host.Host, evt.Seq, err)
+				log.Error("failed handling event", "host", host.Host, "seq", evt.Seq, "err", err)
 			}
 			*lastCursor = evt.Seq
 
···
 			return nil
 		},
 		RepoHandle: func(evt *comatproto.SyncSubscribeRepos_Handle) error {
-			log.Infow("got remote handle update event", "pdsHost", host.Host, "did", evt.Did, "handle", evt.Handle)
+			log.Info("got remote handle update event", "pdsHost", host.Host, "did", evt.Did, "handle", evt.Handle)
 			if err := s.cb(context.TODO(), host, &events.XRPCStreamEvent{
 				RepoHandle: evt,
 			}); err != nil {
-				log.Errorf("failed handling event from %q (%d): %s", host.Host, evt.Seq, err)
+				log.Error("failed handling event", "host", host.Host, "seq", evt.Seq, "err", err)
 			}
 			*lastCursor = evt.Seq
 
···
 			return nil
 		},
 		RepoMigrate: func(evt *comatproto.SyncSubscribeRepos_Migrate) error {
-			log.Infow("got remote repo migrate event", "pdsHost", host.Host, "did", evt.Did, "migrateTo", evt.MigrateTo)
+			log.Info("got remote repo migrate event", "pdsHost", host.Host, "did", evt.Did, "migrateTo", evt.MigrateTo)
 			if err := s.cb(context.TODO(), host, &events.XRPCStreamEvent{
 				RepoMigrate: evt,
 			}); err != nil {
-				log.Errorf("failed handling event from %q (%d): %s", host.Host, evt.Seq, err)
+				log.Error("failed handling event", "host", host.Host, "seq", evt.Seq, "err", err)
 			}
 			*lastCursor = evt.Seq
 
···
 			return nil
 		},
 		RepoTombstone: func(evt *comatproto.SyncSubscribeRepos_Tombstone) error {
-			log.Infow("got remote repo tombstone event", "pdsHost", host.Host, "did", evt.Did)
+			log.Info("got remote repo tombstone event", "pdsHost", host.Host, "did", evt.Did)
 			if err := s.cb(context.TODO(), host, &events.XRPCStreamEvent{
 				RepoTombstone: evt,
 			}); err != nil {
-				log.Errorf("failed handling event from %q (%d): %s", host.Host, evt.Seq, err)
+				log.Error("failed handling event", "host", host.Host, "seq", evt.Seq, "err", err)
 			}
 			*lastCursor = evt.Seq
 
···
 			return nil
 		},
 		RepoInfo: func(info *comatproto.SyncSubscribeRepos_Info) error {
-			log.Infow("info event", "name", info.Name, "message", info.Message, "pdsHost", host.Host)
+			log.Info("info event", "name", info.Name, "message", info.Message, "pdsHost", host.Host)
 			return nil
 		},
 		RepoIdentity: func(ident *comatproto.SyncSubscribeRepos_Identity) error {
-			log.Infow("identity event", "did", ident.Did)
+			log.Info("identity event", "did", ident.Did)
 			if err := s.cb(context.TODO(), host, &events.XRPCStreamEvent{
 				RepoIdentity: ident,
 			}); err != nil {
-				log.Errorf("failed handling event from %q (%d): %s", host.Host, ident.Seq, err)
+				log.Error("failed handling event", "host", host.Host, "seq", ident.Seq, "err", err)
 			}
 			*lastCursor = ident.Seq
 
···
 			return nil
 		},
 		RepoAccount: func(acct *comatproto.SyncSubscribeRepos_Account) error {
-			log.Infow("account event", "did", acct.Did, "status", acct.Status)
+			log.Info("account event", "did", acct.Did, "status", acct.Status)
 			if err := s.cb(context.TODO(), host, &events.XRPCStreamEvent{
 				RepoAccount: acct,
 			}); err != nil {
-				log.Errorf("failed handling event from %q (%d): %s", host.Host, acct.Seq, err)
+				log.Error("failed handling event", "host", host.Host, "seq", acct.Seq, "err", err)
 			}
 			*lastCursor = acct.Seq
 
···
 		con.RemoteAddr().String(),
 		instrumentedRSC.EventHandler,
 	)
-	return events.HandleRepoStream(ctx, con, pool)
+	return events.HandleRepoStream(ctx, con, pool, nil)
 }
 
 func (s *Slurper) updateCursor(sub *activeSub, curs int64) error {

bgs/handlers.go

···
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, echo.NewHTTPError(http.StatusNotFound, "user not found")
 		}
-		log.Errorw("failed to lookup user", "err", err, "did", did)
+		log.Error("failed to lookup user", "err", err, "did", did)
 		return nil, echo.NewHTTPError(http.StatusInternalServerError, "failed to lookup user")
 	}
 
···
 		if errors.Is(err, mst.ErrNotFound) {
 			return nil, echo.NewHTTPError(http.StatusNotFound, "record not found in repo")
 		}
-		log.Errorw("failed to get record from repo", "err", err, "did", did, "collection", collection, "rkey", rkey)
+		log.Error("failed to get record from repo", "err", err, "did", did, "collection", collection, "rkey", rkey)
 		return nil, echo.NewHTTPError(http.StatusInternalServerError, "failed to get record from repo")
 	}
 
···
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, echo.NewHTTPError(http.StatusNotFound, "user not found")
 		}
-		log.Errorw("failed to lookup user", "err", err, "did", did)
+		log.Error("failed to lookup user", "err", err, "did", did)
 		return nil, echo.NewHTTPError(http.StatusInternalServerError, "failed to lookup user")
 	}
 
···
 	// TODO: stream the response
 	buf := new(bytes.Buffer)
 	if err := s.repoman.ReadRepo(ctx, u.ID, since, buf); err != nil {
-		log.Errorw("failed to read repo into buffer", "err", err, "did", did)
+		log.Error("failed to read repo into buffer", "err", err, "did", did)
 		return nil, echo.NewHTTPError(http.StatusInternalServerError, "failed to read repo into buffer")
 	}
 
···
 		return echo.NewHTTPError(http.StatusUnauthorized, "domain is banned")
 	}
 
-	log.Warnf("TODO: better host validation for crawl requests")
+	log.Warn("TODO: better host validation for crawl requests")
 
 	clientHost := fmt.Sprintf("%s://%s", u.Scheme, host)
 
···
 	if len(s.nextCrawlers) != 0 {
 		blob, err := json.Marshal(body)
 		if err != nil {
-			log.Warnw("could not forward requestCrawl, json err", "err", err)
+			log.Warn("could not forward requestCrawl, json err", "err", err)
 		} else {
 			go func(bodyBlob []byte) {
 				for _, rpu := range s.nextCrawlers {
···
 						response.Body.Close()
 					}
 					if err != nil || response == nil {
-						log.Warnw("requestCrawl forward failed", "host", rpu, "err", err)
+						log.Warn("requestCrawl forward failed", "host", rpu, "err", err)
 					} else if response.StatusCode != http.StatusOK {
-						log.Warnw("requestCrawl forward failed", "host", rpu, "status", response.Status)
+						log.Warn("requestCrawl forward failed", "host", rpu, "status", response.Status)
 					} else {
-						log.Infow("requestCrawl forward successful", "host", rpu)
+						log.Info("requestCrawl forward successful", "host", rpu)
 					}
 				}
 			}(blob)
···
 		if err == gorm.ErrRecordNotFound {
 			return &comatprototypes.SyncListRepos_Output{}, nil
 		}
-		log.Errorw("failed to query users", "err", err)
+		log.Error("failed to query users", "err", err)
 		return nil, echo.NewHTTPError(http.StatusInternalServerError, "failed to query users")
 	}
 
···
 
 		root, err := s.repoman.GetRepoRoot(ctx, user.ID)
 		if err != nil {
-			log.Errorw("failed to get repo root", "err", err, "did", user.Did)
+			log.Error("failed to get repo root", "err", err, "did", user.Did)
 			return nil, echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("failed to get repo root for (%s): %v", user.Did, err.Error()))
 		}
 
···
 
 	root, err := s.repoman.GetRepoRoot(ctx, u.ID)
 	if err != nil {
-		log.Errorw("failed to get repo root", "err", err, "did", u.Did)
+		log.Error("failed to get repo root", "err", err, "did", u.Did)
 		return nil, echo.NewHTTPError(http.StatusInternalServerError, "failed to get repo root")
 	}
 
 	rev, err := s.repoman.GetRepoRev(ctx, u.ID)
 	if err != nil {
-		log.Errorw("failed to get repo rev", "err", err, "did", u.Did)
+		log.Error("failed to get repo rev", "err", err, "did", u.Did)
 		return nil, echo.NewHTTPError(http.StatusInternalServerError, "failed to get repo rev")
 	}
 

carstore/bs.go

···
 	"context"
 	"fmt"
 	"io"
+	"log/slog"
 	"os"
 	"path/filepath"
 	"sort"
···
 	cbor "github.com/ipfs/go-ipld-cbor"
 	ipld "github.com/ipfs/go-ipld-format"
 	"github.com/ipfs/go-libipfs/blocks"
-	logging "github.com/ipfs/go-log"
 	car "github.com/ipld/go-car"
 	carutil "github.com/ipld/go-car/util"
 	cbg "github.com/whyrusleeping/cbor-gen"
···
 var blockGetTotalCounterUsrskip = blockGetTotalCounter.WithLabelValues("true", "miss")
 var blockGetTotalCounterCached = blockGetTotalCounter.WithLabelValues("false", "hit")
 var blockGetTotalCounterNormal = blockGetTotalCounter.WithLabelValues("false", "miss")
-
-var log = logging.Logger("carstore")
 
 const MaxSliceLength = 2 << 20
 
···
 
 	lscLk          sync.Mutex
 	lastShardCache map[models.Uid]*CarShard
+
+	log *slog.Logger
 }
 
 func NewCarStore(meta *gorm.DB, roots []string) (CarStore, error) {
···
 		meta:           &CarStoreGormMeta{meta: meta},
 		rootDirs:       roots,
 		lastShardCache: make(map[models.Uid]*CarShard),
+		log:            slog.Default().With("system", "carstore"),
 	}, nil
 }
 
···
 				if !os.IsNotExist(err) {
 					return err
 				}
-				log.Warnw("shard file we tried to delete did not exist", "shard", sh.ID, "path", sh.Path)
+				cs.log.Warn("shard file we tried to delete did not exist", "shard", sh.ID, "path", sh.Path)
 			}
 		}
 
···
 	st, err := os.Stat(sh.Path)
 	if err != nil {
 		if os.IsNotExist(err) {
-			log.Warnw("missing shard, return size of zero", "path", sh.Path, "shard", sh.ID)
+			slog.Warn("missing shard, return size of zero", "path", sh.Path, "shard", sh.ID, "system", "carstore")
 			return 0, nil
 		}
 		return 0, fmt.Errorf("stat %q: %w", sh.Path, err)
···
 		// still around but we're doing that anyways since compaction isn't a
 		// perfect process
 
-		log.Debugw("repo has dirty dupes", "count", len(dupes), "uid", user, "staleRefs", len(staleRefs), "blockRefs", len(brefs))
+		cs.log.Debug("repo has dirty dupes", "count", len(dupes), "uid", user, "staleRefs", len(staleRefs), "blockRefs", len(brefs))
 
 		//return nil, fmt.Errorf("WIP: not currently handling this case")
 	}
···
 		}); err != nil {
 			// If we ever fail to iterate a shard file because its
 			// corrupted, just log an error and skip the shard
-			log.Errorw("iterating blocks in shard", "shard", s.ID, "err", err, "uid", user)
+			cs.log.Error("iterating blocks in shard", "shard", s.ID, "err", err, "uid", user)
 		}
 	}
 
···
 		_ = fi.Close()
 
 		if err2 := os.Remove(fi.Name()); err2 != nil {
-			log.Errorf("failed to remove shard file (%s) after failed db transaction: %w", fi.Name(), err2)
+			cs.log.Error("failed to remove shard file after failed db transaction", "path", fi.Name(), "err", err2)
 		}
 
 		return err

cmd/beemo/firehose_consumer.go

···
 	)
 	logger.Info("beemo firehose scheduler configured", "scheduler", "parallel", "workers", parallelism)
 
-	return events.HandleRepoStream(ctx, con, scheduler)
+	return events.HandleRepoStream(ctx, con, scheduler, logger)
 }
 
 // TODO: move this to a "ParsePath" helper in syntax package?

cmd/bigsky/main.go

···
 import (
 	"context"
 	"fmt"
+	"log/slog"
 	"net/http"
 	_ "net/http/pprof"
 	"net/url"
···
 	_ "go.uber.org/automaxprocs"
 
 	"github.com/carlmjohnson/versioninfo"
-	logging "github.com/ipfs/go-log"
 	"github.com/urfave/cli/v2"
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
···
 	"gorm.io/plugin/opentelemetry/tracing"
 )
 
-var log = logging.Logger("bigsky")
+var log = slog.Default().With("system", "bigsky")
 
 func init() {
 	// control log level using, eg, GOLOG_LOG_LEVEL=debug
···
 
 func main() {
 	if err := run(os.Args); err != nil {
-		log.Fatal(err)
+		slog.Error(err.Error())
+		os.Exit(1)
 	}
 }
 
···
 	// At a minimum, you need to set
 	// OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
 	if ep := cctx.String("otel-exporter-otlp-endpoint"); ep != "" {
-		log.Infow("setting up trace exporter", "endpoint", ep)
+		slog.Info("setting up trace exporter", "endpoint", ep)
 		ctx, cancel := context.WithCancel(context.Background())
 		defer cancel()
 
 		exp, err := otlptracehttp.New(ctx)
 		if err != nil {
-			log.Fatalw("failed to create trace exporter", "error", err)
+			slog.Error("failed to create trace exporter", "error", err)
+			os.Exit(1)
 		}
 		defer func() {
 			ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 			defer cancel()
 			if err := exp.Shutdown(ctx); err != nil {
-				log.Errorw("failed to shutdown trace exporter", "error", err)
+				slog.Error("failed to shutdown trace exporter", "error", err)
 			}
 		}()
 
···
 	signals := make(chan os.Signal, 1)
 	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
 
+	// TODO: set slog default from param/env
+
 	// start observability/tracing (OTEL and jaeger)
 	if err := setupOTEL(cctx); err != nil {
 		return err
···
 		return err
 	}
 
-	log.Infow("setting up main database")
+	slog.Info("setting up main database")
 	dburl := cctx.String("db-url")
 	db, err := cliutil.SetupDatabase(dburl, cctx.Int("max-metadb-connections"))
 	if err != nil {
 		return err
 	}
 
-	log.Infow("setting up carstore database")
+	slog.Info("setting up carstore database")
 	csdburl := cctx.String("carstore-db-url")
 	csdb, err := cliutil.SetupDatabase(csdburl, cctx.Int("max-carstore-connections"))
 	if err != nil {
···
 	var persister events.EventPersistence
 
 	if dpd := cctx.String("disk-persister-dir"); dpd != "" {
-		log.Infow("setting up disk persister")
+		slog.Info("setting up disk persister")
 
 		pOpts := events.DefaultDiskPersistOptions()
 		pOpts.Retention = cctx.Duration("event-playback-ttl")
···
 
 	repoman.SetEventHandler(func(ctx context.Context, evt *repomgr.RepoEvent) {
 		if err := ix.HandleRepoEvent(ctx, evt); err != nil {
-			log.Errorw("failed to handle repo event", "err", err)
+			slog.Error("failed to handle repo event", "err", err)
 		}
 	}, false)
 
···
 		}
 	}
 
-	log.Infow("constructing bgs")
+	slog.Info("constructing bgs")
 	bgsConfig := libbgs.DefaultBGSConfig()
 	bgsConfig.SSL = !cctx.Bool("crawl-insecure-ws")
 	bgsConfig.CompactInterval = cctx.Duration("compact-interval")
···
 			if err != nil {
 				return fmt.Errorf("failed to parse next-crawler url: %w", err)
 			}
-			log.Infow("configuring relay for requestCrawl", "host", nextCrawlerUrls[i])
+			slog.Info("configuring relay for requestCrawl", "host", nextCrawlerUrls[i])
 		}
 		bgsConfig.NextCrawlers = nextCrawlerUrls
 	}
···
 	// set up metrics endpoint
 	go func() {
 		if err := bgs.StartMetrics(cctx.String("metrics-listen")); err != nil {
-			log.Fatalf("failed to start metrics endpoint: %s", err)
+			log.Error("failed to start metrics endpoint", "err", err)
+			os.Exit(1)
 		}
 	}()
 
···
 		bgsErr <- err
 	}()
 
-	log.Infow("startup complete")
+	slog.Info("startup complete")
 	select {
 	case <-signals:
 		log.Info("received shutdown signal")
 		errs := bgs.Shutdown()
 		for err := range errs {
-			log.Errorw("error during BGS shutdown", "err", err)
+			slog.Error("error during BGS shutdown", "err", err)
 		}
 	case err := <-bgsErr:
 		if err != nil {
-			log.Errorw("error during BGS startup", "err", err)
+			slog.Error("error during BGS startup", "err", err)
 		}
 		log.Info("shutting down")
 		errs := bgs.Shutdown()
 		for err := range errs {
-			log.Errorw("error during BGS shutdown", "err", err)
+			slog.Error("error during BGS shutdown", "err", err)
 		}
 	}
 

cmd/goat/firehose.go

···
 		rsc.EventHandler,
 	)
 	slog.Info("starting firehose consumer", "relayHost", relayHost)
-	return events.HandleRepoStream(ctx, con, scheduler)
+	return events.HandleRepoStream(ctx, con, scheduler, nil)
 }
 
 // TODO: move this to a "ParsePath" helper in syntax package?

cmd/gosky/car.go

···
 		if topDir == "" {
 			topDir = did.String()
 		}
-		log.Infof("writing output to: %s", topDir)
+		log.Info("writing output", "topDir", topDir)
 
 		commitPath := topDir + "/_commit"
 		os.MkdirAll(filepath.Dir(commitPath), os.ModePerm)
···
 			if err != nil {
 				return err
 			}
-			log.Debugf("processing record: %s", k)
+			log.Debug("processing record", "rec", k)
 
 			// TODO: check if path is safe more carefully
 			recPath := topDir + "/" + k

cmd/gosky/debug.go

···
 		}
 
 		seqScheduler := sequential.NewScheduler("debug-inspect-event", rsc.EventHandler)
-		err = events.HandleRepoStream(ctx, con, seqScheduler)
+		err = events.HandleRepoStream(ctx, con, seqScheduler, nil)
 		if err != errFoundIt {
 			return err
 		}
···
 			},
 		}
 		seqScheduler := sequential.NewScheduler("debug-stream", rsc.EventHandler)
-		err = events.HandleRepoStream(ctx, con, seqScheduler)
+		err = events.HandleRepoStream(ctx, con, seqScheduler, nil)
 		if err != nil {
 			return err
 		}
···
 			go func(i int, url string) {
 				con, _, err := d.Dial(url, http.Header{})
 				if err != nil {
-					log.Fatalf("Dial failure on url%d: %s", i+1, err)
+					log.Error("Dial failure", "i", i, "url", url, "err", err)
+					os.Exit(1)
 				}
 
 				ctx := context.TODO()
···
 					},
 				}
 				seqScheduler := sequential.NewScheduler(fmt.Sprintf("debug-stream-%d", i+1), rsc.EventHandler)
-				if err := events.HandleRepoStream(ctx, con, seqScheduler); err != nil {
-					log.Fatalf("HandleRepoStream failure on url%d: %s", i+1, err)
+				if err := events.HandleRepoStream(ctx, con, seqScheduler, nil); err != nil {
+					log.Error("HandleRepoStream failure", "i", i, "url", url, "err", err)
+					os.Exit(1)
 				}
 			}(i, url)
 		}
···
 			logger := log.With("host", cctx.String("host-1"))
 			repo1bytes, err := comatproto.SyncGetRepo(ctx, &xrpc1, did.String(), "")
 			if err != nil {
-				logger.Fatalf("getting repo: %s", err)
+				logger.Error("getting repo", "err", err)
+				os.Exit(1)
 				return
 			}
 
 			rep1, err = repo.ReadRepoFromCar(ctx, bytes.NewReader(repo1bytes))
 			if err != nil {
-				logger.Fatalf("reading repo: %s", err)
+				logger.Error("reading repo", "err", err)
+				os.Exit(1)
 				return
 			}
 		}()
···
 			logger := log.With("host", cctx.String("host-2"))
 			repo2bytes, err := comatproto.SyncGetRepo(ctx, &xrpc2, did.String(), "")
 			if err != nil {
-				logger.Fatalf("getting repo: %s", err)
+				logger.Error("getting repo", "err", err)
+				os.Exit(1)
 				return
 			}
 
 			rep2, err = repo.ReadRepoFromCar(ctx, bytes.NewReader(repo2bytes))
 			if err != nil {
-				logger.Fatalf("reading repo: %s", err)
+				logger.Error("reading repo", "err", err)
+				os.Exit(1)
 				return
 			}
 		}()

cmd/gosky/main.go

···
 	"encoding/json"
 	"fmt"
 	"io"
+	"log/slog"
 	"net/http"
 	"os"
 	"os/signal"
···
 	_ "github.com/joho/godotenv/autoload"
 
 	"github.com/carlmjohnson/versioninfo"
-	logging "github.com/ipfs/go-log"
 	"github.com/polydawn/refmt/cbor"
 	rejson "github.com/polydawn/refmt/json"
 	"github.com/polydawn/refmt/shared"
 	cli "github.com/urfave/cli/v2"
 )
 
-var log = logging.Logger("gosky")
+var log = slog.Default().With("system", "gosky")
 
 func main() {
 	run(os.Args)
···
 			EnvVars: []string{"ATP_PLC_HOST"},
 		},
 	}
+
+	// TODO: slog.SetDefault from param/env
+
 	app.Commands = []*cli.Command{
 		accountCmd,
 		adminCmd,
···
 			},
 		}
 		seqScheduler := sequential.NewScheduler(con.RemoteAddr().String(), rsc.EventHandler)
-		return events.HandleRepoStream(ctx, con, seqScheduler)
+		return events.HandleRepoStream(ctx, con, seqScheduler, log)
 	},
 }
 

cmd/gosky/streamdiff.go

···
 				},
 			}
 			seqScheduler := sequential.NewScheduler("streamA", rsc.EventHandler)
-			err = events.HandleRepoStream(ctx, cona, seqScheduler)
+			err = events.HandleRepoStream(ctx, cona, seqScheduler, log)
 			if err != nil {
-				log.Errorf("stream A failed: %s", err)
+				log.Error("stream A failed", "err", err)
 			}
 		}()
 
···
 			}
 
 			seqScheduler := sequential.NewScheduler("streamB", rsc.EventHandler)
-			err = events.HandleRepoStream(ctx, conb, seqScheduler)
+			err = events.HandleRepoStream(ctx, conb, seqScheduler, log)
 			if err != nil {
-				log.Errorf("stream B failed: %s", err)
+				log.Error("stream B failed", "err", err)
 			}
 		}()
 

cmd/gosky/sync.go

···
 			xrpcc.Host = h
 		}
 
-		log.Infof("downloading from %s to: %s", xrpcc.Host, carPath)
+		log.Info("downloading", "from", xrpcc.Host, "to", carPath)
 		repoBytes, err := comatproto.SyncGetRepo(ctx, xrpcc, ident.DID.String(), "")
 		if err != nil {
 			return err

cmd/laputa/main.go

···
 	_ "go.uber.org/automaxprocs"
 
 	"github.com/carlmjohnson/versioninfo"
-	logging "github.com/ipfs/go-log"
 	"github.com/urfave/cli/v2"
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
···
 	semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
 	"gorm.io/plugin/opentelemetry/tracing"
 )
-
-var log = logging.Logger("laputa")
 
 func main() {
 	run(os.Args)

cmd/rainbow/main.go

···
 import (
 	"context"
 	"github.com/bluesky-social/indigo/events"
+	"log/slog"
 	_ "net/http/pprof"
 	"os"
 	"os/signal"
···
 	_ "go.uber.org/automaxprocs"
 
 	"github.com/carlmjohnson/versioninfo"
-	logging "github.com/ipfs/go-log"
 	"github.com/urfave/cli/v2"
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
···
 	semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
 )
 
-var log = logging.Logger("rainbow")
+var log = slog.Default().With("system", "rainbow")
 
 func init() {
 	// control log level using, eg, GOLOG_LOG_LEVEL=debug
-	logging.SetAllLoggers(logging.LevelDebug)
+	//logging.SetAllLoggers(logging.LevelDebug)
 }
 
 func main() {
···
 		},
 	}
 
+	// TODO: slog.SetDefault and set module `var log *slog.Logger` based on flags and env
+	
 	app.Action = Splitter
 	err := app.Run(os.Args)
 	if err != nil {
-		log.Fatal(err)
+		log.Error(err.Error())
+		os.Exit(1)
 	}
 }
 
···
 	// At a minimum, you need to set
 	// OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
 	if ep := os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT"); ep != "" {
-		log.Infow("setting up trace exporter", "endpoint", ep)
+		log.Info("setting up trace exporter", "endpoint", ep)
 		ctx, cancel := context.WithCancel(context.Background())
 		defer cancel()
 
 		exp, err := otlptracehttp.New(ctx)
 		if err != nil {
-			log.Fatalw("failed to create trace exporter", "error", err)
+			log.Error("failed to create trace exporter", "error", err)
+			os.Exit(1)
 		}
 		defer func() {
 			ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 			defer cancel()
 			if err := exp.Shutdown(ctx); err != nil {
-				log.Errorw("failed to shutdown trace exporter", "error", err)
+				log.Error("failed to shutdown trace exporter", "error", err)
 			}
 		}()
 
···
 	var spl *splitter.Splitter
 	var err error
 	if persistPath != "" {
-		log.Infof("building splitter with storage at: %s", persistPath)
+		log.Info("building splitter with storage at", "path", persistPath)
 		ppopts := events.PebblePersistOptions{
 			DbPath:          persistPath,
 			PersistDuration: time.Duration(float64(time.Hour) * cctx.Float64("persist-hours")),
···
 		spl, err = splitter.NewSplitter(conf)
 	}
 	if err != nil {
-		log.Fatalw("failed to create splitter", "path", persistPath, "error", err)
+		log.Error("failed to create splitter", "path", persistPath, "error", err)
+		os.Exit(1)
 		return err
 	}
 
 	// set up metrics endpoint
 	go func() {
 		if err := spl.StartMetrics(cctx.String("metrics-listen")); err != nil {
-			log.Fatalf("failed to start metrics endpoint: %s", err)
+			log.Error("failed to start metrics endpoint", "err", err)
+			os.Exit(1)
 		}
 	}()
 
···
 		runErr <- err
 	}()
 
-	log.Infow("startup complete")
+	log.Info("startup complete")
 	select {
 	case <-signals:
 		log.Info("received shutdown signal")
 		if err := spl.Shutdown(); err != nil {
-			log.Errorw("error during Splitter shutdown", "err", err)
+			log.Error("error during Splitter shutdown", "err", err)
 		}
 	case err := <-runErr:
 		if err != nil {
-			log.Errorw("error during Splitter startup", "err", err)
+			log.Error("error during Splitter startup", "err", err)
 		}
 		log.Info("shutting down")
 		if err := spl.Shutdown(); err != nil {
-			log.Errorw("error during Splitter shutdown", "err", err)
+			log.Error("error during Splitter shutdown", "err", err)
 		}
 	}
 

cmd/sonar/main.go

···
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		err = events.HandleRepoStream(ctx, c, pool)
+		err = events.HandleRepoStream(ctx, c, pool, logger)
 		logger.Info("HandleRepoStream returned unexpectedly", "err", err)
 		cancel()
 	}()

cmd/stress/main.go

···
 	_ "github.com/joho/godotenv/autoload"
 
 	"github.com/carlmjohnson/versioninfo"
-	logging "github.com/ipfs/go-log"
 	"github.com/ipld/go-car"
 	cli "github.com/urfave/cli/v2"
 )
-
-var log = logging.Logger("stress")
 
 func main() {
 	run(os.Args)

events/consumer.go

···
 	"context"
 	"fmt"
 	"io"
+	"log/slog"
 	"net"
 	"time"
 
···
 	return n, err
 }
 
-func HandleRepoStream(ctx context.Context, con *websocket.Conn, sched Scheduler) error {
+// HandleRepoStream
+// con is source of events
+// sched gets AddWork for each event
+// log may be nil for default logger
+func HandleRepoStream(ctx context.Context, con *websocket.Conn, sched Scheduler, log *slog.Logger) error {
+	if log == nil {
+		log = slog.Default().With("system", "events")
+	}
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 	defer sched.Shutdown()
···
 			select {
 			case <-t.C:
 				if err := con.WriteControl(websocket.PingMessage, []byte{}, time.Now().Add(time.Second*10)); err != nil {
-					log.Warnf("failed to ping: %s", err)
+					log.Warn("failed to ping", "err", err)
 				}
 			case <-ctx.Done():
 				con.Close()
···
 
 	con.SetPongHandler(func(_ string) error {
 		if err := con.SetReadDeadline(time.Now().Add(time.Minute)); err != nil {
-			log.Errorf("failed to set read deadline: %s", err)
+			log.Error("failed to set read deadline", "err", err)
 		}
 
 		return nil
···
 				}
 
 				if evt.Seq < lastSeq {
-					log.Errorf("Got events out of order from stream (seq = %d, prev = %d)", evt.Seq, lastSeq)
+					log.Error("Got events out of order from stream", "seq", evt.Seq, "prev", lastSeq)
 				}
 
 				lastSeq = evt.Seq
···
 				}
 
 				if evt.Seq < lastSeq {
-					log.Errorf("Got events out of order from stream (seq = %d, prev = %d)", evt.Seq, lastSeq)
+					log.Error("Got events out of order from stream", "seq", evt.Seq, "prev", lastSeq)
 				}
 				lastSeq = evt.Seq
 
···
 				}
 
 				if evt.Seq < lastSeq {
-					log.Errorf("Got events out of order from stream (seq = %d, prev = %d)", evt.Seq, lastSeq)
+					log.Error("Got events out of order from stream", "seq", evt.Seq, "prev", lastSeq)
 				}
 				lastSeq = evt.Seq
 
···
 				}
 
 				if evt.Seq < lastSeq {
-					log.Errorf("Got events out of order from stream (seq = %d, prev = %d)", evt.Seq, lastSeq)
+					log.Error("Got events out of order from stream", "seq", evt.Seq, "prev", lastSeq)
 				}
 				lastSeq = evt.Seq
 
···
 				}
 
 				if evt.Seq < lastSeq {
-					log.Errorf("Got events out of order from stream (seq = %d, prev = %d)", evt.Seq, lastSeq)
+					log.Error("Got events out of order from stream", "seq", evt.Seq, "prev", lastSeq)
 				}
 				lastSeq = evt.Seq
 
···
 				}
 
 				if evt.Seq < lastSeq {
-					log.Errorf("Got events out of order from stream (seq = %d, prev = %d)", evt.Seq, lastSeq)
+					log.Error("Got events out of order from stream", "seq", evt.Seq, "prev", lastSeq)
 				}
 				lastSeq = evt.Seq
 
···
 				}
 
 				if evt.Seq < lastSeq {
-					log.Errorf("Got events out of order from stream (seq = %d, prev = %d)", evt.Seq, lastSeq)
+					log.Error("Got events out of order from stream", "seq", evt.Seq, "prev", lastSeq)
 				}
 
 				lastSeq = evt.Seq

events/dbpersist.go

···
 
 		if needsFlush {
 			if err := p.Flush(context.Background()); err != nil {
-				log.Errorf("failed to flush batch: %s", err)
+				log.Error("failed to flush batch", "err", err)
 			}
 		}
 	}
···
 func (p *DbPersistence) RecordFromRepoCommit(ctx context.Context, evt *comatproto.SyncSubscribeRepos_Commit) (*RepoEventRecord, error) {
 	// TODO: hack hack hack
 	if len(evt.Ops) > 8192 {
-		log.Errorf("(VERY BAD) truncating ops field in outgoing event (len = %d)", len(evt.Ops))
+		log.Error("(VERY BAD) truncating ops field in outgoing event", "len", len(evt.Ops))
 		evt.Ops = evt.Ops[:8192]
 	}
 

events/dbpersist_test.go

···
 	pds "github.com/bluesky-social/indigo/pds/data"
 	"github.com/bluesky-social/indigo/repomgr"
 	"github.com/bluesky-social/indigo/util"
-	logging "github.com/ipfs/go-log/v2"
 	"gorm.io/driver/sqlite"
 	"gorm.io/gorm"
 )
-
-func init() {
-	logging.SetAllLoggers(logging.LevelDebug)
-}
 
 func BenchmarkDBPersist(b *testing.B) {
 	ctx := context.Background()

events/diskpersist.go

···
 			dp.lk.Lock()
 			if err := dp.flushLog(ctx); err != nil {
 				// TODO: this happening is quite bad. Need a recovery strategy
-				log.Errorf("failed to flush disk log: %s", err)
+				log.Error("failed to flush disk log", "err", err)
 			}
 			dp.lk.Unlock()
 		}
···
 		case <-t.C:
 			if errs := dp.garbageCollect(ctx); len(errs) > 0 {
 				for _, err := range errs {
-					log.Errorf("garbage collection error: %s", err)
+					log.Error("garbage collection error", "err", err)
 				}
 			}
 		}
···
 	refsGarbageCollected.WithLabelValues().Add(float64(refsDeleted))
 	filesGarbageCollected.WithLabelValues().Add(float64(filesDeleted))
 
-	log.Infow("garbage collection complete",
+	log.Info("garbage collection complete",
 		"filesDeleted", filesDeleted,
 		"refsDeleted", refsDeleted,
 		"oldRefsFound", oldRefsFound,
···
 			return nil, err
 		}
 		if since > lastSeq {
-			log.Errorw("playback cursor is greater than last seq of file checked",
+			log.Error("playback cursor is greater than last seq of file checked",
 				"since", since,
 				"lastSeq", lastSeq,
 				"filename", fn,
···
 				return nil, err
 			}
 		default:
-			log.Warnw("unrecognized event kind coming from log file", "seq", h.Seq, "kind", h.Kind)
+			log.Warn("unrecognized event kind coming from log file", "seq", h.Seq, "kind", h.Kind)
 			return nil, fmt.Errorf("halting on unrecognized event kind")
 		}
 	}

events/events.go

···
 	"errors"
 	"fmt"
 	"io"
+	"log/slog"
 	"sync"
 	"time"
 
···
 	"github.com/bluesky-social/indigo/models"
 	"github.com/prometheus/client_golang/prometheus"
 
-	logging "github.com/ipfs/go-log"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"go.opentelemetry.io/otel"
 )
 
-var log = logging.Logger("events")
+var log = slog.Default().With("system", "events")
 
 type Scheduler interface {
 	AddWork(ctx context.Context, repo string, val *XRPCStreamEvent) error
···
 	crossoverBufferSize int
 
 	persister EventPersistence
+
+	log *slog.Logger
 }
 
 func NewEventManager(persister EventPersistence) *EventManager {
···
 		bufferSize:          16 << 10,
 		crossoverBufferSize: 512,
 		persister:           persister,
+		log:                 slog.Default().With("system", "events"),
 	}
 
 	persister.SetEventBroadcaster(em.broadcastEvent)
···
 func (em *EventManager) broadcastEvent(evt *XRPCStreamEvent) {
 	// the main thing we do is send it out, so MarshalCBOR once
 	if err := evt.Preserialize(); err != nil {
-		log.Errorf("broadcast serialize failed, %s", err)
+		em.log.Error("broadcast serialize failed", "err", err)
 		// serialize isn't going to go better later, this event is cursed
 		return
 	}
···
 				// code
 				s.filter = func(*XRPCStreamEvent) bool { return false }
 
-				log.Warnw("dropping slow consumer due to event overflow", "bufferSize", len(s.outgoing), "ident", s.ident)
+				em.log.Warn("dropping slow consumer due to event overflow", "bufferSize", len(s.outgoing), "ident", s.ident)
 				go func(torem *Subscriber) {
 					torem.lk.Lock()
 					if !torem.cleanedUp {
···
 							},
 						}:
 						case <-time.After(time.Second * 5):
-							log.Warnw("failed to send error frame to backed up consumer", "ident", torem.ident)
+							em.log.Warn("failed to send error frame to backed up consumer", "ident", torem.ident)
 						}
 					}
 					torem.lk.Unlock()
···
 	// accept a uid. The lookup inside the persister is notably expensive (despite
 	// being an lru cache?)
 	if err := em.persister.Persist(ctx, evt); err != nil {
-		log.Errorf("failed to persist outbound event: %s", err)
+		em.log.Error("failed to persist outbound event", "err", err)
 	}
 }
 
···
 			}
 		}); err != nil {
 			if errors.Is(err, ErrPlaybackShutdown) {
-				log.Warnf("events playback: %s", err)
+				em.log.Warn("events playback", "err", err)
 			} else {
-				log.Errorf("events playback: %s", err)
+				em.log.Error("events playback", "err", err)
 			}
 
 			// TODO: send an error frame or something?
···
 			}
 		}); err != nil {
 			if !errors.Is(err, ErrCaughtUp) {
-				log.Errorf("events playback: %s", err)
+				em.log.Error("events playback", "err", err)
 
 				// TODO: send an error frame or something?
 				close(out)

events/pebblepersist.go

···
 		case <-ticker.C:
 			err := pp.GarbageCollect(ctx)
 			if err != nil {
-				log.Errorw("GC err", "err", err)
+				log.Error("GC err", "err", err)
 			}
 		case <-ctx.Done():
 			return
···
 	sizeBefore, _ := pp.db.EstimateDiskUsage(zeroKey[:], ffffKey[:])
 	if seq == -1 {
 		// nothing to delete
-		log.Infow("pebble gc nop", "size", sizeBefore)
+		log.Info("pebble gc nop", "size", sizeBefore)
 		return nil
 	}
 	var key [16]byte
 	setKeySeqMillis(key[:], seq, lastKeyTime)
-	log.Infow("pebble gc start", "to", hex.EncodeToString(key[:]))
+	log.Info("pebble gc start", "to", hex.EncodeToString(key[:]))
 	err = pp.db.DeleteRange(zeroKey[:], key[:], pebble.Sync)
 	if err != nil {
 		return err
 	}
 	sizeAfter, _ := pp.db.EstimateDiskUsage(zeroKey[:], ffffKey[:])
-	log.Infow("pebble gc", "before", sizeBefore, "after", sizeAfter)
+	log.Info("pebble gc", "before", sizeBefore, "after", sizeAfter)
 	start := time.Now()
 	err = pp.db.Compact(zeroKey[:], key[:], true)
 	if err != nil {
-		log.Warnw("pebble gc compact", "err", err)
+		log.Warn("pebble gc compact", "err", err)
 	}
 	dt := time.Since(start)
-	log.Infow("pebble gc compact ok", "dt", dt)
+	log.Info("pebble gc compact ok", "dt", dt)
 	return nil
 }

events/schedulers/autoscaling/autoscaling.go

···
 
 import (
 	"context"
+	"log/slog"
 	"sync"
 	"time"
 
 	"github.com/bluesky-social/indigo/events"
 	"github.com/bluesky-social/indigo/events/schedulers"
-	logging "github.com/ipfs/go-log"
 	"github.com/prometheus/client_golang/prometheus"
 )
-
-var log = logging.Logger("autoscaling-scheduler")
 
 // Scheduler is a scheduler that will scale up and down the number of workers based on the throughput of the workers.
 type Scheduler struct {
···
 	autoscaleFrequency time.Duration
 	autoscalerIn       chan struct{}
 	autoscalerOut      chan struct{}
+
+	log *slog.Logger
 }
 
 type AutoscaleSettings struct {
···
 		autoscaleFrequency: autoscaleSettings.AutoscaleFrequency,
 		autoscalerIn:       make(chan struct{}),
 		autoscalerOut:      make(chan struct{}),
+
+		log: slog.Default().With("system", "autoscaling-scheduler"),
 	}
 
 	for i := 0; i < p.concurrency; i++ {
···
 }
 
 func (p *Scheduler) Shutdown() {
-	log.Debugf("shutting down autoscaling scheduler for %s", p.ident)
+	p.log.Debug("shutting down autoscaling scheduler", "ident", p.ident)
 
 	// stop autoscaling
 	p.autoscalerIn <- struct{}{}
 	close(p.autoscalerIn)
 	<-p.autoscalerOut
 
-	log.Debug("stopping autoscaling scheduler workers")
+	p.log.Debug("stopping autoscaling scheduler workers")
 	// stop workers
 	for i := 0; i < p.concurrency; i++ {
 		p.feeder <- &consumerTask{signal: "stop"}
 	}
 	close(p.feeder)
 
-	log.Debug("waiting for autoscaling scheduler workers to stop")
+	p.log.Debug("waiting for autoscaling scheduler workers to stop")
 
 	p.workerGroup.Wait()
 
-	log.Debug("stopping autoscaling scheduler throughput manager")
+	p.log.Debug("stopping autoscaling scheduler throughput manager")
 	p.throughputManager.Stop()
 
-	log.Debug("autoscaling scheduler shutdown complete")
+	p.log.Debug("autoscaling scheduler shutdown complete")
 }
 
 // Add autoscaling function
···
 }
 
 func (p *Scheduler) worker() {
-	log.Debugf("starting autoscaling worker for %s", p.ident)
+	p.log.Debug("starting autoscaling worker", "ident", p.ident)
 	p.workersActive.Inc()
 	p.workerGroup.Add(1)
 	defer p.workerGroup.Done()
···
 		for work != nil {
 			// Check if the work item contains a signal to stop the worker.
 			if work.signal == "stop" {
-				log.Debugf("stopping autoscaling worker for %s", p.ident)
+				p.log.Debug("stopping autoscaling worker", "ident", p.ident)
 				p.workersActive.Dec()
 				return
 			}
 
 			p.itemsActive.Inc()
 			if err := p.do(context.TODO(), work.val); err != nil {
-				log.Errorf("event handler failed: %s", err)
+				p.log.Error("event handler failed", "err", err)
 			}
 			p.itemsProcessed.Inc()
 
 			p.lk.Lock()
 			rem, ok := p.active[work.repo]
 			if !ok {
-				log.Errorf("should always have an 'active' entry if a worker is processing a job")
+				p.log.Error("should always have an 'active' entry if a worker is processing a job")
 			}
 
 			if len(rem) == 0 {

events/schedulers/parallel/parallel.go

···
 
 import (
 	"context"
+	"log/slog"
 	"sync"
 
 	"github.com/bluesky-social/indigo/events"
 	"github.com/bluesky-social/indigo/events/schedulers"
-	logging "github.com/ipfs/go-log"
 
 	"github.com/prometheus/client_golang/prometheus"
 )
-
-var log = logging.Logger("parallel-scheduler")
 
 // Scheduler is a parallel scheduler that will run work on a fixed number of workers
 type Scheduler struct {
···
 	itemsProcessed prometheus.Counter
 	itemsActive    prometheus.Counter
 	workesActive   prometheus.Gauge
+
+	log *slog.Logger
 }
 
 func NewScheduler(maxC, maxQ int, ident string, do func(context.Context, *events.XRPCStreamEvent) error) *Scheduler {
···
 		itemsProcessed: schedulers.WorkItemsProcessed.WithLabelValues(ident, "parallel"),
 		itemsActive:    schedulers.WorkItemsActive.WithLabelValues(ident, "parallel"),
 		workesActive:   schedulers.WorkersActive.WithLabelValues(ident, "parallel"),
+
+		log: slog.Default().With("system", "parallel-scheduler"),
 	}
 
 	for i := 0; i < maxC; i++ {
···
 }
 
 func (p *Scheduler) Shutdown() {
-	log.Infof("shutting down parallel scheduler for %s", p.ident)
+	p.log.Info("shutting down parallel scheduler", "ident", p.ident)
 
 	for i := 0; i < p.maxConcurrency; i++ {
 		p.feeder <- &consumerTask{
···
 		<-p.out
 	}
 
-	log.Info("parallel scheduler shutdown complete")
+	p.log.Info("parallel scheduler shutdown complete")
 }
 
 type consumerTask struct {
···
 
 			p.itemsActive.Inc()
 			if err := p.do(context.TODO(), work.val); err != nil {
-				log.Errorf("event handler failed: %s", err)
+				p.log.Error("event handler failed", "err", err)
 			}
 			p.itemsProcessed.Inc()
 
 			p.lk.Lock()
 			rem, ok := p.active[work.repo]
 			if !ok {
-				log.Errorf("should always have an 'active' entry if a worker is processing a job")
+				p.log.Error("should always have an 'active' entry if a worker is processing a job")
 			}
 
 			if len(rem) == 0 {

events/schedulers/sequential/sequential.go

···
 
 import (
 	"context"
-
 	"github.com/bluesky-social/indigo/events"
 	"github.com/bluesky-social/indigo/events/schedulers"
-	logging "github.com/ipfs/go-log"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
-var log = logging.Logger("sequential-scheduler")
+// var log = slog.Default().With("system", "sequential-scheduler")
 
 // Scheduler is a sequential scheduler that will run work on a single worker
 type Scheduler struct {

fakedata/accounts.go

···
 			return nil, fmt.Errorf("account index didn't match: %d != %d (%s)", i, u.Index, u.AccountType)
 		}
 	}
-	log.Infof("loaded account catalog: regular=%d celebrity=%d", len(catalog.Regulars), len(catalog.Celebs))
+	log.Info("loaded account catalog", "regular", len(catalog.Regulars), "celebrity", len(catalog.Celebs))
 	return catalog, nil
 }
 

fakedata/generators.go

···
 	"bytes"
 	"context"
 	"fmt"
+	"log/slog"
 	"math/rand"
 	"time"
 
···
 	"github.com/bluesky-social/indigo/xrpc"
 
 	"github.com/brianvoe/gofakeit/v6"
-	logging "github.com/ipfs/go-log"
 )
 
-var log = logging.Logger("fakedata")
+var log = slog.Default().With("system", "fakedata")
+
+func SetLogger(logger *slog.Logger) {
+	log = logger
+}
 
 func MeasureIterations(name string) func(int) {
 	start := time.Now()
···
 			return
 		}
 		total := time.Since(start)
-		log.Infof("%s wall runtime: count=%d total=%s mean=%s", name, count, total, total/time.Duration(count))
+		log.Info("wall runtime", "name", name, "count", count, "total", total, "rate", total/time.Duration(count))
 	}
 }
 

go.mod

···
 	github.com/ipfs/go-ipld-cbor v0.1.0
 	github.com/ipfs/go-ipld-format v0.6.0
 	github.com/ipfs/go-libipfs v0.7.0
-	github.com/ipfs/go-log v1.0.5
-	github.com/ipfs/go-log/v2 v2.5.1
 	github.com/ipld/go-car v0.6.1-0.20230509095817-92d28eb23ba4
 	github.com/ipld/go-car/v2 v2.13.1
 	github.com/jackc/pgx/v5 v5.5.0
···
 	github.com/go-redis/redis v6.15.9+incompatible // indirect
 	github.com/golang/snappy v0.0.4 // indirect
 	github.com/hashicorp/golang-lru v1.0.2 // indirect
+	github.com/ipfs/go-log v1.0.5 // indirect
+	github.com/ipfs/go-log/v2 v2.5.1 // indirect
 	github.com/jackc/puddle/v2 v2.2.1 // indirect
 	github.com/klauspost/compress v1.17.3 // indirect
 	github.com/kr/pretty v0.3.1 // indirect

indexer/crawler.go

···
 import (
 	"context"
 	"fmt"
+	"log/slog"
 	"sync"
 	"time"
 
···
 
 	concurrency int
 
+	log *slog.Logger
+
 	done chan struct{}
 }
 
-func NewCrawlDispatcher(repoFn func(context.Context, *crawlWork) error, concurrency int) (*CrawlDispatcher, error) {
+func NewCrawlDispatcher(repoFn func(context.Context, *crawlWork) error, concurrency int, log *slog.Logger) (*CrawlDispatcher, error) {
 	if concurrency < 1 {
 		return nil, fmt.Errorf("must specify a non-zero positive integer for crawl dispatcher concurrency")
 	}
···
 		concurrency: concurrency,
 		todo:        make(map[models.Uid]*crawlWork),
 		inProgress:  make(map[models.Uid]*crawlWork),
+		log:         log,
 		done:        make(chan struct{}),
 	}
 	go out.CatchupRepoGaugePoller()
···
 		select {
 		case job := <-c.repoSync:
 			if err := c.doRepoCrawl(context.TODO(), job); err != nil {
-				log.Errorf("failed to perform repo crawl of %q: %s", job.act.Did, err)
+				c.log.Error("failed to perform repo crawl", "did", job.act.Did, "err", err)
 			}
 
 			// TODO: do we still just do this if it errors?

indexer/indexer.go

···
 	"database/sql"
 	"errors"
 	"fmt"
+	"log/slog"
 	"time"
 
 	comatproto "github.com/bluesky-social/indigo/api/atproto"
···
 	"github.com/bluesky-social/indigo/xrpc"
 
 	"github.com/ipfs/go-cid"
-	logging "github.com/ipfs/go-log"
 	"go.opentelemetry.io/otel"
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 )
-
-var log = logging.Logger("indexer")
 
 const MaxEventSliceLength = 1000000
 const MaxOpsSliceLength = 200
···
 	SendRemoteFollow       func(context.Context, string, uint) error
 	CreateExternalUser     func(context.Context, string) (*models.ActorInfo, error)
 	ApplyPDSClientSettings func(*xrpc.Client)
+
+	log *slog.Logger
 }
 
 func NewIndexer(db *gorm.DB, notifman notifs.NotificationManager, evtman *events.EventManager, didr did.Resolver, fetcher *RepoFetcher, crawl, aggregate, spider bool) (*Indexer, error) {
···
 			return nil
 		},
 		ApplyPDSClientSettings: func(*xrpc.Client) {},
+		log:                    slog.Default().With("system", "indexer"),
 	}
 
 	if crawl {
-		c, err := NewCrawlDispatcher(fetcher.FetchAndIndexRepo, fetcher.MaxConcurrency)
+		c, err := NewCrawlDispatcher(fetcher.FetchAndIndexRepo, fetcher.MaxConcurrency, ix.log)
 		if err != nil {
 			return nil, err
 		}
···
 	ctx, span := otel.Tracer("indexer").Start(ctx, "HandleRepoEvent")
 	defer span.End()
 
-	log.Debugw("Handling Repo Event!", "uid", evt.User)
+	ix.log.Debug("Handling Repo Event!", "uid", evt.User)
 
 	outops := make([]*comatproto.SyncSubscribeRepos_RepoOp, 0, len(evt.Ops))
 	for _, op := range evt.Ops {
···
 		})
 
 		if err := ix.handleRepoOp(ctx, evt, &op); err != nil {
-			log.Errorw("failed to handle repo op", "err", err)
+			ix.log.Error("failed to handle repo op", "err", err)
 		}
 	}
 
···
 		toobig = true
 	}
 
-	log.Debugw("Sending event", "did", did)
+	ix.log.Debug("Sending event", "did", did)
 	if err := ix.events.AddEvent(ctx, &events.XRPCStreamEvent{
 		RepoCommit: &comatproto.SyncSubscribeRepos_Commit{
 			Repo:   did,
···
 			if e.Type == "mention" {
 				_, err := ix.GetUserOrMissing(ctx, e.Value)
 				if err != nil {
-					log.Infow("failed to parse user mention", "ref", e.Value, "err", err)
+					ix.log.Info("failed to parse user mention", "ref", e.Value, "err", err)
 				}
 			}
 		}
···
 		if rec.Reply != nil {
 			if rec.Reply.Parent != nil {
 				if err := ix.crawlAtUriRef(ctx, rec.Reply.Parent.Uri); err != nil {
-					log.Infow("failed to crawl reply parent", "cid", op.RecCid, "replyuri", rec.Reply.Parent.Uri, "err", err)
+					ix.log.Info("failed to crawl reply parent", "cid", op.RecCid, "replyuri", rec.Reply.Parent.Uri, "err", err)
 				}
 			}
 
 			if rec.Reply.Root != nil {
 				if err := ix.crawlAtUriRef(ctx, rec.Reply.Root.Uri); err != nil {
-					log.Infow("failed to crawl reply root", "cid", op.RecCid, "rooturi", rec.Reply.Root.Uri, "err", err)
+					ix.log.Info("failed to crawl reply root", "cid", op.RecCid, "rooturi", rec.Reply.Root.Uri, "err", err)
 				}
 			}
 		}
···
 	case *bsky.FeedRepost:
 		if rec.Subject != nil {
 			if err := ix.crawlAtUriRef(ctx, rec.Subject.Uri); err != nil {
-				log.Infow("failed to crawl repost subject", "cid", op.RecCid, "subjecturi", rec.Subject.Uri, "err", err)
+				ix.log.Info("failed to crawl repost subject", "cid", op.RecCid, "subjecturi", rec.Subject.Uri, "err", err)
 			}
 		}
 		return nil
 	case *bsky.FeedLike:
 		if rec.Subject != nil {
 			if err := ix.crawlAtUriRef(ctx, rec.Subject.Uri); err != nil {
-				log.Infow("failed to crawl like subject", "cid", op.RecCid, "subjecturi", rec.Subject.Uri, "err", err)
+				ix.log.Info("failed to crawl like subject", "cid", op.RecCid, "subjecturi", rec.Subject.Uri, "err", err)
 			}
 		}
 		return nil
 	case *bsky.GraphFollow:
 		_, err := ix.GetUserOrMissing(ctx, rec.Subject)
 		if err != nil {
-			log.Infow("failed to crawl follow subject", "cid", op.RecCid, "subjectdid", rec.Subject, "err", err)
+			ix.log.Info("failed to crawl follow subject", "cid", op.RecCid, "subjectdid", rec.Subject, "err", err)
 		}
 		return nil
 	case *bsky.GraphBlock:
 		_, err := ix.GetUserOrMissing(ctx, rec.Subject)
 		if err != nil {
-			log.Infow("failed to crawl follow subject", "cid", op.RecCid, "subjectdid", rec.Subject, "err", err)
+			ix.log.Info("failed to crawl follow subject", "cid", op.RecCid, "subjectdid", rec.Subject, "err", err)
 		}
 		return nil
 	case *bsky.ActorProfile:
···
 	case *bsky.FeedGenerator:
 		return nil
 	default:
-		log.Warnw("unrecognized record type (crawling references)", "record", op.Record, "collection", op.Collection)
+		ix.log.Warn("unrecognized record type (crawling references)", "record", op.Record, "collection", op.Collection)
 		return nil
 	}
 }
···
 }
 
 func (ix *Indexer) addUserToCrawler(ctx context.Context, ai *models.ActorInfo) error {
-	log.Debugw("Sending user to crawler: ", "did", ai.Did)
+	ix.log.Debug("Sending user to crawler: ", "did", ai.Did)
 	if ix.Crawler == nil {
 		return nil
 	}
···
 }
 
 func (ix *Indexer) handleRecordDelete(ctx context.Context, evt *repomgr.RepoEvent, op *repomgr.RepoOp, local bool) error {
-	log.Debugw("record delete event", "collection", op.Collection)
+	ix.log.Debug("record delete event", "collection", op.Collection)
 
 	switch op.Collection {
 	case "app.bsky.feed.post":
···
 		fp, err := ix.GetPost(ctx, uri)
 		if err != nil {
 			if errors.Is(err, gorm.ErrRecordNotFound) {
-				log.Warnw("deleting post weve never seen before. Weird.", "user", evt.User, "rkey", op.Rkey)
+				ix.log.Warn("deleting post weve never seen before. Weird.", "user", evt.User, "rkey", op.Rkey)
 				return nil
 			}
 			return err
···
 			return err
 		}
 
-		log.Warn("TODO: remove notifications on delete")
+		ix.log.Warn("TODO: remove notifications on delete")
 		/*
 		   if err := ix.notifman.RemoveRepost(ctx, fp.Author, rr.ID, evt.User); err != nil {
 		           return nil, err
···
 		return err
 	}
 
-	log.Warnf("need to delete vote notification")
+	ix.log.Warn("need to delete vote notification")
 	return nil
 }
 
···
 	}
 
 	if q.RowsAffected == 0 {
-		log.Warnw("attempted to delete follow we did not have a record for", "user", evt.User, "rkey", op.Rkey)
+		ix.log.Warn("attempted to delete follow we did not have a record for", "user", evt.User, "rkey", op.Rkey)
 		return nil
 	}
 
···
 }
 
 func (ix *Indexer) handleRecordCreate(ctx context.Context, evt *repomgr.RepoEvent, op *repomgr.RepoOp, local bool) ([]uint, error) {
-	log.Debugw("record create event", "collection", op.Collection)
+	ix.log.Debug("record create event", "collection", op.Collection)
 
 	var out []uint
 	switch rec := op.Record.(type) {
···
 	case *bsky.FeedGenerator:
 		return out, nil
 	case *bsky.ActorProfile:
-		log.Debugf("TODO: got actor profile record creation, need to do something with this")
+		ix.log.Debug("TODO: got actor profile record creation, need to do something with this")
 	default:
 		return nil, fmt.Errorf("unrecognized record type (creation): %s", op.Collection)
 	}
···
 }
 
 func (ix *Indexer) handleRecordUpdate(ctx context.Context, evt *repomgr.RepoEvent, op *repomgr.RepoOp, local bool) error {
-	log.Debugw("record update event", "collection", op.Collection)
+	ix.log.Debug("record update event", "collection", op.Collection)
 
 	switch rec := op.Record.(type) {
 	case *bsky.FeedPost:
···
 
 		if oldReply != newReply {
 			// the 'replyness' of the post was changed... that's weird
-			log.Errorf("need to properly handle case where reply-ness of posts is changed")
+			ix.log.Error("need to properly handle case where reply-ness of posts is changed")
 			return nil
 		}
 
···
 			}
 
 			if replyto.ID != fp.ReplyTo {
-				log.Errorf("post was changed to be a reply to a different post")
+				ix.log.Error("post was changed to be a reply to a different post")
 				return nil
 			}
 		}
···
 
 		return ix.handleRecordCreateGraphFollow(ctx, rec, evt, op)
 	case *bsky.ActorProfile:
-		log.Debugf("TODO: got actor profile record update, need to do something with this")
+		ix.log.Debug("TODO: got actor profile record update, need to do something with this")
 	default:
 		return fmt.Errorf("unrecognized record type (update): %s", op.Collection)
 	}
···
 		// we're likely filling in a missing reference
 		if !maybe.Missing {
 			// TODO: we've already processed this record creation
-			log.Warnw("potentially erroneous event, duplicate create", "rkey", rkey, "user", user)
+			ix.log.Warn("potentially erroneous event, duplicate create", "rkey", rkey, "user", user)
 		}
 
 		if err := ix.db.Clauses(clause.OnConflict{
···
 }
 
 func (ix *Indexer) createMissingPostRecord(ctx context.Context, puri *util.ParsedUri) (*models.FeedPost, error) {
-	log.Warn("creating missing post record")
+	ix.log.Warn("creating missing post record")
 	ai, err := ix.GetUserOrMissing(ctx, puri.Did)
 	if err != nil {
 		return nil, err
···
 	if post.Reply != nil {
 		replyto, err := ix.GetPost(ctx, post.Reply.Parent.Uri)
 		if err != nil {
-			log.Error("probably shouldn't error when processing a reply to a not-found post")
+			ix.log.Error("probably shouldn't error when processing a reply to a not-found post")
 			return err
 		}
 

indexer/keymgr.go

···
 import (
 	"context"
 	"fmt"
+	"log/slog"
 
 	did "github.com/whyrusleeping/go-did"
 	"go.opentelemetry.io/otel"
···
 	didr DidResolver
 
 	signingKey *did.PrivKey
+
+	log *slog.Logger
 }
 
 type DidResolver interface {
···
 	return &KeyManager{
 		didr:       didr,
 		signingKey: k,
+		log:        slog.Default().With("system", "indexer"),
 	}
 }
 
···
 
 	err = k.Verify(msg, sig)
 	if err != nil {
-		log.Warnw("signature failed to verify", "err", err, "did", did, "pubKey", k, "sigBytes", sig, "msgBytes", msg)
+		km.log.Warn("signature failed to verify", "err", err, "did", did, "pubKey", k, "sigBytes", sig, "msgBytes", msg)
 	}
 	return err
 }

indexer/repofetch.go

···
 	"fmt"
 	"io"
 	"io/fs"
+	"log/slog"
 	"sync"
 
 	"github.com/bluesky-social/indigo/api/atproto"
···
 		Limiters:               make(map[uint]*rate.Limiter),
 		ApplyPDSClientSettings: func(*xrpc.Client) {},
 		MaxConcurrency:         maxConcurrency,
+		log:                    slog.Default().With("system", "indexer"),
 	}
 }
 
···
 	MaxConcurrency int
 
 	ApplyPDSClientSettings func(*xrpc.Client)
+
+	log *slog.Logger
 }
 
 func (rf *RepoFetcher) GetLimiter(pdsID uint) *rate.Limiter {
···
 	// Wait to prevent DOSing the PDS when connecting to a new stream with lots of active repos
 	limiter.Wait(ctx)
 
-	log.Debugw("SyncGetRepo", "did", did, "since", rev)
+	rf.log.Debug("SyncGetRepo", "did", did, "since", rev)
 	// TODO: max size on these? A malicious PDS could just send us a petabyte sized repo here and kill us
 	repo, err := atproto.SyncGetRepo(ctx, c, did, rev)
 	if err != nil {
···
 			for i, j := range job.catchup {
 				catchupEventsProcessed.Inc()
 				if err := rf.repoman.HandleExternalUserEvent(ctx, pds.ID, ai.Uid, ai.Did, j.evt.Since, j.evt.Rev, j.evt.Blocks, j.evt.Ops); err != nil {
-					log.Errorw("buffered event catchup failed", "error", err, "did", ai.Did, "i", i, "jobCount", len(job.catchup), "seq", j.evt.Seq)
+					rf.log.Error("buffered event catchup failed", "error", err, "did", ai.Did, "i", i, "jobCount", len(job.catchup), "seq", j.evt.Seq)
 					resync = true // fall back to a repo sync
 					break
 				}
···
 		span.RecordError(err)
 
 		if ipld.IsNotFound(err) || errors.Is(err, io.EOF) || errors.Is(err, fs.ErrNotExist) {
-			log.Errorw("partial repo fetch was missing data", "did", ai.Did, "pds", pds.Host, "rev", rev)
+			rf.log.Error("partial repo fetch was missing data", "did", ai.Did, "pds", pds.Host, "rev", rev)
 			repo, err := rf.fetchRepo(ctx, c, &pds, ai.Did, "")
 			if err != nil {
 				return err

pds/feedgen.go

···
 import (
 	"context"
 	"fmt"
+	"log/slog"
 	"sort"
 	"strings"
 	"time"
···
 	ix *indexer.Indexer
 
 	readRecord ReadRecordFunc
+
+	log *slog.Logger
 }
 
-func NewFeedGenerator(db *gorm.DB, ix *indexer.Indexer, readRecord ReadRecordFunc) (*FeedGenerator, error) {
+func NewFeedGenerator(db *gorm.DB, ix *indexer.Indexer, readRecord ReadRecordFunc, log *slog.Logger) (*FeedGenerator, error) {
 	return &FeedGenerator{
 		db:         db,
 		ix:         ix,
 		readRecord: readRecord,
+		log:        log,
 	}, nil
 }
 
···
 
 func (fg *FeedGenerator) GetVotes(ctx context.Context, uri string, pcid cid.Cid, limit int, before string) ([]*HydratedVote, error) {
 	if before != "" {
-		log.Warn("not respecting 'before' yet")
+		fg.log.Warn("not respecting 'before' yet")
 	}
 
 	p, err := fg.ix.GetPost(ctx, uri)

pds/server.go

···
 	"database/sql"
 	"errors"
 	"fmt"
+	"log/slog"
 	"net"
 	"net/http"
 	"net/mail"
···
 	gojwt "github.com/golang-jwt/jwt"
 	"github.com/gorilla/websocket"
 	"github.com/ipfs/go-cid"
-	logging "github.com/ipfs/go-log"
 	"github.com/labstack/echo/v4"
 	"github.com/labstack/echo/v4/middleware"
 	"github.com/lestrrat-go/jwx/v2/jwt"
 	"github.com/whyrusleeping/go-did"
 	"gorm.io/gorm"
 )
-
-var log = logging.Logger("pds")
 
 type Server struct {
 	db             *gorm.DB
···
 	serviceUrl   string
 
 	plc plc.PLCClient
+
+	log *slog.Logger
 }
 
 // serverListenerBootTimeout is how long to wait for the requested server socket
···
 		serviceUrl:     serviceUrl,
 		jwtSigningKey:  jwtkey,
 		enforcePeering: false,
+
+		log: slog.Default().With("system", "pds"),
 	}
 
 	repoman.SetEventHandler(func(ctx context.Context, evt *repomgr.RepoEvent) {
 		if err := ix.HandleRepoEvent(ctx, evt); err != nil {
-			log.Errorw("handle repo event failed", "user", evt.User, "err", err)
+			s.log.Error("handle repo event failed", "user", evt.User, "err", err)
 		}
 	}, true)
 
 	//ix.SendRemoteFollow = s.sendRemoteFollow
 	ix.CreateExternalUser = s.createExternalUser
 
-	feedgen, err := NewFeedGenerator(db, ix, s.readRecordFunc)
+	feedgen, err := NewFeedGenerator(db, ix, s.readRecordFunc, s.log)
 	if err != nil {
 		return nil, err
 	}
···
 
 func (s *Server) HandleHealthCheck(c echo.Context) error {
 	if err := s.db.Exec("SELECT 1").Error; err != nil {
-		log.Errorf("healthcheck can't connect to database: %v", err)
+		s.log.Error("healthcheck can't connect to database", "err", err)
 		return c.JSON(500, HealthStatus{Status: "error", Message: "can't connect to database"})
 	} else {
 		return c.JSON(200, HealthStatus{Status: "ok"})
···
 func (s *Server) UpdateUserHandle(ctx context.Context, u *User, handle string) error {
 	if u.Handle == handle {
 		// no change? move on
-		log.Warnw("attempted to change handle to current handle", "did", u.Did, "handle", handle)
+		s.log.Warn("attempted to change handle to current handle", "did", u.Did, "handle", handle)
 		return nil
 	}
 

repomgr/repomgr.go

···
 	"errors"
 	"fmt"
 	"io"
+	"log/slog"
 	"strings"
 	"sync"
 	"time"
···
 	"github.com/ipfs/go-datastore"
 	blockstore "github.com/ipfs/go-ipfs-blockstore"
 	ipld "github.com/ipfs/go-ipld-format"
-	logging "github.com/ipfs/go-log/v2"
 	"github.com/ipld/go-car"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
 	"gorm.io/gorm"
 )
-
-var log = logging.Logger("repomgr")
 
 func NewRepoManager(cs carstore.CarStore, kmgr KeyManager) *RepoManager {
 
···
 		cs:        cs,
 		userLocks: make(map[models.Uid]*userLock),
 		kmgr:      kmgr,
+		log:       slog.Default().With("system", "repomgr"),
 	}
 }
 
···
 
 	events         func(context.Context, *RepoEvent)
 	hydrateRecords bool
+
+	log *slog.Logger
 }
 
 type ActorInfo struct {
···
 
 	span.SetAttributes(attribute.Int64("uid", int64(uid)))
 
-	log.Debugw("HandleExternalUserEvent", "pds", pdsid, "uid", uid, "since", since, "nrev", nrev)
+	rm.log.Debug("HandleExternalUserEvent", "pds", pdsid, "uid", uid, "since", since, "nrev", nrev)
 
 	unlock := rm.lockUser(ctx, uid)
 	defer unlock()
···
 		ops := make([]RepoOp, 0, len(diffops))
 		for _, op := range diffops {
 			repoOpsImported.Inc()
-			out, err := processOp(ctx, bs, op, rm.hydrateRecords)
+			out, err := rm.processOp(ctx, bs, op, rm.hydrateRecords)
 			if err != nil {
-				log.Errorw("failed to process repo op", "err", err, "path", op.Rpath, "repo", repoDid)
+				rm.log.Error("failed to process repo op", "err", err, "path", op.Rpath, "repo", repoDid)
 			}
 
 			if out != nil {
···
 	return nil
 }
 
-func processOp(ctx context.Context, bs blockstore.Blockstore, op *mst.DiffOp, hydrateRecords bool) (*RepoOp, error) {
+func (rm *RepoManager) processOp(ctx context.Context, bs blockstore.Blockstore, op *mst.DiffOp, hydrateRecords bool) (*RepoOp, error) {
 	parts := strings.SplitN(op.Rpath, "/", 2)
 	if len(parts) != 2 {
 		return nil, fmt.Errorf("repo mst had invalid rpath: %q", op.Rpath)
···
 					return nil, err
 				}
 
-				log.Warnf("failed processing repo diff: %s", err)
+				rm.log.Warn("failed processing repo diff", "err", err)
 			} else {
 				outop.Record = rec
 			}
···
 	// the repos lifecycle, this will end up erroneously not including
 	// them. We should compute the set of blocks needed to read any repo
 	// ops that happened in the commit and use that for our 'output' blocks
-	cids, err := walkTree(ctx, seen, root, membs, true)
+	cids, err := rm.walkTree(ctx, seen, root, membs, true)
 	if err != nil {
 		return fmt.Errorf("walkTree: %w", err)
 	}
···
 
 // walkTree returns all cids linked recursively by the root, skipping any cids
 // in the 'skip' map, and not erroring on 'not found' if prevMissing is set
-func walkTree(ctx context.Context, skip map[cid.Cid]bool, root cid.Cid, bs blockstore.Blockstore, prevMissing bool) ([]cid.Cid, error) {
+func (rm *RepoManager) walkTree(ctx context.Context, skip map[cid.Cid]bool, root cid.Cid, bs blockstore.Blockstore, prevMissing bool) ([]cid.Cid, error) {
 	// TODO: what if someone puts non-cbor links in their repo?
 	if root.Prefix().Codec != cid.DagCBOR {
 		return nil, fmt.Errorf("can only handle dag-cbor objects in repos (%s is %d)", root, root.Prefix().Codec)
···
 	var links []cid.Cid
 	if err := cbg.ScanForLinks(bytes.NewReader(blk.RawData()), func(c cid.Cid) {
 		if c.Prefix().Codec == cid.Raw {
-			log.Debugw("skipping 'raw' CID in record", "recordCid", root, "rawCid", c)
+			rm.log.Debug("skipping 'raw' CID in record", "recordCid", root, "rawCid", c)
 			return
 		}
 		if skip[c] {
···
 
 	// TODO: should do this non-recursive since i expect these may get deep
 	for _, c := range links {
-		sub, err := walkTree(ctx, skip, c, bs, prevMissing)
+		sub, err := rm.walkTree(ctx, skip, c, bs, prevMissing)
 		if err != nil {
 			if prevMissing && !ipld.IsNotFound(err) {
 				return nil, err

search/firehose.go

···
 			idx.relayhost,
 			rsc.EventHandler,
 		),
+		idx.logger,
 	)
 }
 

splitter/splitter.go

···
 	"errors"
 	"fmt"
 	"io"
+	"log/slog"
 	"math/rand"
 	"net"
 	"net/http"
···
 	events "github.com/bluesky-social/indigo/events"
 	"github.com/bluesky-social/indigo/events/schedulers/sequential"
 	"github.com/gorilla/websocket"
-	logging "github.com/ipfs/go-log"
 	"github.com/labstack/echo/v4"
 	"github.com/labstack/echo/v4/middleware"
 	promclient "github.com/prometheus/client_golang/prometheus"
···
 	dto "github.com/prometheus/client_model/go"
 )
 
-var log = logging.Logger("splitter")
-
 type Splitter struct {
 	erb    *EventRingBuffer
 	pp     *events.PebblePersist
···
 	consumers      map[uint64]*SocketConsumer
 
 	conf SplitterConfig
+
+	log *slog.Logger
 }
 
 type SplitterConfig struct {
···
 		erb:       erb,
 		events:    em,
 		consumers: make(map[uint64]*SocketConsumer),
+		log:       slog.Default().With("system", "splitter"),
 	}
 }
 func NewSplitter(conf SplitterConfig) (*Splitter, error) {
···
 			erb:       erb,
 			events:    em,
 			consumers: make(map[uint64]*SocketConsumer),
+			log:       slog.Default().With("system", "splitter"),
 		}, nil
 	} else {
 		pp, err := events.NewPebblePersistance(conf.PebbleOptions)
···
 			pp:        pp,
 			events:    em,
 			consumers: make(map[uint64]*SocketConsumer),
+			log:       slog.Default().With("system", "splitter"),
 		}, nil
 	}
 }
···
 		pp:        pp,
 		events:    em,
 		consumers: make(map[uint64]*SocketConsumer),
+		log:       slog.Default().With("system", "splitter"),
 	}, nil
 }
 
···
 			if err2 := ctx.JSON(err.Code, map[string]any{
 				"error": err.Message,
 			}); err2 != nil {
-				log.Errorf("Failed to write http error: %s", err2)
+				s.log.Error("Failed to write http error", "err", err2)
 			}
 		default:
 			sendHeader := true
···
 				sendHeader = false
 			}
 
-			log.Warnf("HANDLER ERROR: (%s) %s", ctx.Path(), err)
+			s.log.Warn("HANDLER ERROR", "path", ctx.Path(), "err", err)
 
 			if strings.HasPrefix(ctx.Path(), "/admin/") {
 				ctx.JSON(500, map[string]any{
···
 				}
 
 				if err := conn.WriteControl(websocket.PingMessage, []byte{}, time.Now().Add(5*time.Second)); err != nil {
-					log.Errorf("failed to ping client: %s", err)
+					s.log.Error("failed to ping client", "err", err)
 					cancel()
 					return
 				}
···
 		for {
 			_, _, err := conn.ReadMessage()
 			if err != nil {
-				log.Errorf("failed to read message from client: %s", err)
+				s.log.Error("failed to read message from client", "err", err)
 				cancel()
 				return
 			}
···
 	consumerID := s.registerConsumer(&consumer)
 	defer s.cleanupConsumer(consumerID)
 
-	log.Infow("new consumer",
+	s.log.Info("new consumer",
 		"remote_addr", consumer.RemoteAddr,
 		"user_agent", consumer.UserAgent,
 		"cursor", since,
···
 		select {
 		case evt, ok := <-evts:
 			if !ok {
-				log.Error("event stream closed unexpectedly")
+				s.log.Error("event stream closed unexpectedly")
 				return nil
 			}
 
 			wc, err := conn.NextWriter(websocket.BinaryMessage)
 			if err != nil {
-				log.Errorf("failed to get next writer: %s", err)
+				s.log.Error("failed to get next writer", "err", err)
 				return err
 			}
 
···
 			}
 
 			if err := wc.Close(); err != nil {
-				log.Warnf("failed to flush-close our event write: %s", err)
+				s.log.Warn("failed to flush-close our event write", "err", err)
 				return nil
 			}
 
···
 
 	var m = &dto.Metric{}
 	if err := c.EventsSent.Write(m); err != nil {
-		log.Errorf("failed to get sent counter: %s", err)
+		s.log.Error("failed to get sent counter", "err", err)
 	}
 
-	log.Infow("consumer disconnected",
+	s.log.Info("consumer disconnected",
 		"consumer_id", id,
 		"remote_addr", c.RemoteAddr,
 		"user_agent", c.UserAgent,
···
 		}
 		con, res, err := d.DialContext(ctx, url, header)
 		if err != nil {
-			log.Warnw("dialing failed", "host", host, "err", err, "backoff", backoff)
+			s.log.Warn("dialing failed", "host", host, "err", err, "backoff", backoff)
 			time.Sleep(sleepForBackoff(backoff))
 			backoff++
 
 			continue
 		}
 
-		log.Info("event subscription response code: ", res.StatusCode)
+		s.log.Info("event subscription response", "code", res.StatusCode)
 
 		if err := s.handleConnection(ctx, host, con, &cursor); err != nil {
-			log.Warnf("connection to %q failed: %s", host, err)
+			s.log.Warn("connection failed", "host", host, "err", err)
 		}
 	}
 }
···
 		if seq%5000 == 0 {
 			// TODO: don't need this after we move to getting seq from pebble
 			if err := s.writeCursor(seq); err != nil {
-				log.Errorf("write cursor failed: %s", err)
+				s.log.Error("write cursor failed", "err", err)
 			}
 		}
 
···
 		return nil
 	})
 
-	return events.HandleRepoStream(ctx, con, sched)
+	return events.HandleRepoStream(ctx, con, sched, nil)
 }
 
 func (s *Splitter) getLastCursor() (int64, error) {
 	if s.pp != nil {
 		seq, millis, _, err := s.pp.GetLast(context.Background())
 		if err == nil {
-			log.Debugw("got last cursor from pebble", "seq", seq, "millis", millis)
+			s.log.Debug("got last cursor from pebble", "seq", seq, "millis", millis)
 			return seq, nil
 		} else if errors.Is(err, events.ErrNoLast) {
-			log.Info("pebble no last")
+			s.log.Info("pebble no last")
 		} else {
-			log.Errorw("pebble seq fail", "err", err)
+			s.log.Error("pebble seq fail", "err", err)
 		}
 	}
 

testing/integ_test.go

···
 	"github.com/bluesky-social/indigo/repo"
 	"github.com/bluesky-social/indigo/xrpc"
 	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-log/v2"
 	car "github.com/ipld/go-car"
 	"github.com/stretchr/testify/assert"
 )
-
-func init() {
-	log.SetAllLoggers(log.LevelInfo)
-}
 
 func TestRelayBasic(t *testing.T) {
 	if testing.Short() {

testing/utils.go

···
 			},
 		}
 		seqScheduler := sequential.NewScheduler("test", rsc.EventHandler)
-		if err := events.HandleRepoStream(ctx, con, seqScheduler); err != nil {
+		if err := events.HandleRepoStream(ctx, con, seqScheduler, nil); err != nil {
 			fmt.Println(err)
 		}
 	}()