add opentracing instrumentation to http package (#672)

* add opentracing instrumentation to http package

pkg/api/api.go

@@ -134,3 +134,14 @@ func requestModePut(r *http.Request) storage.ModePut {
 func requestEncrypt(r *http.Request) bool {
 	return strings.ToLower(r.Header.Get(SwarmEncryptHeader)) == "true"
 }
+
+func (s *server) newTracingHandler(spanName string) func(h http.Handler) http.Handler {
+	return func(h http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			span, _, ctx := s.Tracer.StartSpanFromContext(r.Context(), spanName, s.Logger)
+			defer span.Finish()
+
+			h.ServeHTTP(w, r.WithContext(ctx))
+		})
+	}
+}

pkg/api/bytes.go

@@ -12,6 +12,7 @@ import (
 	"github.com/ethersphere/bee/pkg/jsonhttp"
 	"github.com/ethersphere/bee/pkg/sctx"
 	"github.com/ethersphere/bee/pkg/swarm"
+	"github.com/ethersphere/bee/pkg/tracing"
 	"github.com/gorilla/mux"
 )
 
@@ -21,10 +22,12 @@ type bytesPostResponse struct {
 
 // bytesUploadHandler handles upload of raw binary data of arbitrary length.
 func (s *server) bytesUploadHandler(w http.ResponseWriter, r *http.Request) {
+	logger := tracing.NewLoggerWithTraceID(r.Context(), s.Logger)
+
 	tag, created, err := s.getOrCreateTag(r.Header.Get(SwarmTagUidHeader))
 	if err != nil {
-		s.Logger.Debugf("bytes upload: get or create tag: %v", err)
-		s.Logger.Error("bytes upload: get or create tag")
+		logger.Debugf("bytes upload: get or create tag: %v", err)
+		logger.Error("bytes upload: get or create tag")
 		jsonhttp.InternalServerError(w, "cannot get or create tag")
 		return
 	}
@@ -35,16 +38,16 @@ func (s *server) bytesUploadHandler(w http.ResponseWriter, r *http.Request) {
 	pipe := pipeline.NewPipelineBuilder(ctx, s.Storer, requestModePut(r), requestEncrypt(r))
 	address, err := pipeline.FeedPipeline(ctx, pipe, r.Body, r.ContentLength)
 	if err != nil {
-		s.Logger.Debugf("bytes upload: split write all: %v", err)
-		s.Logger.Error("bytes upload: split write all")
+		logger.Debugf("bytes upload: split write all: %v", err)
+		logger.Error("bytes upload: split write all")
 		jsonhttp.InternalServerError(w, nil)
 		return
 	}
 	if created {
 		_, err = tag.DoneSplit(address)
 		if err != nil {
-			s.Logger.Debugf("bytes upload: done split: %v", err)
-			s.Logger.Error("bytes upload: done split failed")
+			logger.Debugf("bytes upload: done split: %v", err)
+			logger.Error("bytes upload: done split failed")
 			jsonhttp.InternalServerError(w, nil)
 			return
 		}
@@ -58,12 +61,13 @@ func (s *server) bytesUploadHandler(w http.ResponseWriter, r *http.Request) {
 
 // bytesGetHandler handles retrieval of raw binary data of arbitrary length.
 func (s *server) bytesGetHandler(w http.ResponseWriter, r *http.Request) {
+	logger := tracing.NewLoggerWithTraceID(r.Context(), s.Logger).Logger
 	nameOrHex := mux.Vars(r)["address"]
 
 	address, err := s.resolveNameOrAddress(nameOrHex)
 	if err != nil {
-		s.Logger.Debugf("bytes: parse address %s: %v", nameOrHex, err)
-		s.Logger.Error("bytes: parse address error")
+		logger.Debugf("bytes: parse address %s: %v", nameOrHex, err)
+		logger.Error("bytes: parse address error")
 		jsonhttp.BadRequest(w, "invalid address")
 		return
 	}

pkg/api/bzz.go

@@ -19,9 +19,11 @@ import (
 	"github.com/ethersphere/bee/pkg/jsonhttp"
 	"github.com/ethersphere/bee/pkg/manifest"
 	"github.com/ethersphere/bee/pkg/sctx"
+	"github.com/ethersphere/bee/pkg/tracing"
 )
 
 func (s *server) bzzDownloadHandler(w http.ResponseWriter, r *http.Request) {
+	logger := tracing.NewLoggerWithTraceID(r.Context(), s.Logger)
 	targets := r.URL.Query().Get("targets")
 	r = r.WithContext(sctx.SetTargets(r.Context(), targets))
 	ctx := r.Context()
@@ -31,8 +33,8 @@ func (s *server) bzzDownloadHandler(w http.ResponseWriter, r *http.Request) {
 
 	address, err := s.resolveNameOrAddress(nameOrHex)
 	if err != nil {
-		s.Logger.Debugf("bzz download: parse address %s: %v", nameOrHex, err)
-		s.Logger.Error("bzz download: parse address")
+		logger.Debugf("bzz download: parse address %s: %v", nameOrHex, err)
+		logger.Error("bzz download: parse address")
 		jsonhttp.BadRequest(w, "invalid address")
 		return
 	}
@@ -45,16 +47,16 @@ func (s *server) bzzDownloadHandler(w http.ResponseWriter, r *http.Request) {
 	buf := bytes.NewBuffer(nil)
 	_, err = file.JoinReadAll(ctx, j, address, buf)
 	if err != nil {
-		s.Logger.Debugf("bzz download: read entry %s: %v", address, err)
-		s.Logger.Errorf("bzz download: read entry %s", address)
+		logger.Debugf("bzz download: read entry %s: %v", address, err)
+		logger.Errorf("bzz download: read entry %s", address)
 		jsonhttp.NotFound(w, nil)
 		return
 	}
 	e := &entry.Entry{}
 	err = e.UnmarshalBinary(buf.Bytes())
 	if err != nil {
-		s.Logger.Debugf("bzz download: unmarshal entry %s: %v", address, err)
-		s.Logger.Errorf("bzz download: unmarshal entry %s", address)
+		logger.Debugf("bzz download: unmarshal entry %s: %v", address, err)
+		logger.Errorf("bzz download: unmarshal entry %s", address)
 		jsonhttp.InternalServerError(w, "error unmarshaling entry")
 		return
 	}
@@ -63,16 +65,16 @@ func (s *server) bzzDownloadHandler(w http.ResponseWriter, r *http.Request) {
 	buf = bytes.NewBuffer(nil)
 	_, err = file.JoinReadAll(ctx, j, e.Metadata(), buf)
 	if err != nil {
-		s.Logger.Debugf("bzz download: read metadata %s: %v", address, err)
-		s.Logger.Errorf("bzz download: read metadata %s", address)
+		logger.Debugf("bzz download: read metadata %s: %v", address, err)
+		logger.Errorf("bzz download: read metadata %s", address)
 		jsonhttp.NotFound(w, nil)
 		return
 	}
 	manifestMetadata := &entry.Metadata{}
 	err = json.Unmarshal(buf.Bytes(), manifestMetadata)
 	if err != nil {
-		s.Logger.Debugf("bzz download: unmarshal metadata %s: %v", address, err)
-		s.Logger.Errorf("bzz download: unmarshal metadata %s", address)
+		logger.Debugf("bzz download: unmarshal metadata %s: %v", address, err)
+		logger.Errorf("bzz download: unmarshal metadata %s", address)
 		jsonhttp.InternalServerError(w, "error unmarshaling metadata")
 		return
 	}
@@ -86,16 +88,16 @@ func (s *server) bzzDownloadHandler(w http.ResponseWriter, r *http.Request) {
 		s.Storer,
 	)
 	if err != nil {
-		s.Logger.Debugf("bzz download: not manifest %s: %v", address, err)
-		s.Logger.Error("bzz download: not manifest")
+		logger.Debugf("bzz download: not manifest %s: %v", address, err)
+		logger.Error("bzz download: not manifest")
 		jsonhttp.BadRequest(w, "not manifest")
 		return
 	}
 
 	me, err := m.Lookup(path)
 	if err != nil {
-		s.Logger.Debugf("bzz download: invalid path %s/%s: %v", address, path, err)
-		s.Logger.Error("bzz download: invalid path")
+		logger.Debugf("bzz download: invalid path %s/%s: %v", address, path, err)
+		logger.Error("bzz download: invalid path")
 
 		if errors.Is(err, manifest.ErrNotFound) {
 			jsonhttp.NotFound(w, "path address not found")
@@ -111,16 +113,16 @@ func (s *server) bzzDownloadHandler(w http.ResponseWriter, r *http.Request) {
 	buf = bytes.NewBuffer(nil)
 	_, err = file.JoinReadAll(ctx, j, manifestEntryAddress, buf)
 	if err != nil {
-		s.Logger.Debugf("bzz download: read file entry %s: %v", address, err)
-		s.Logger.Errorf("bzz download: read file entry %s", address)
+		logger.Debugf("bzz download: read file entry %s: %v", address, err)
+		logger.Errorf("bzz download: read file entry %s", address)
 		jsonhttp.NotFound(w, nil)
 		return
 	}
 	fe := &entry.Entry{}
 	err = fe.UnmarshalBinary(buf.Bytes())
 	if err != nil {
-		s.Logger.Debugf("bzz download: unmarshal file entry %s: %v", address, err)
-		s.Logger.Errorf("bzz download: unmarshal file entry %s", address)
+		logger.Debugf("bzz download: unmarshal file entry %s: %v", address, err)
+		logger.Errorf("bzz download: unmarshal file entry %s", address)
 		jsonhttp.InternalServerError(w, "error unmarshaling file entry")
 		return
 	}
@@ -129,16 +131,16 @@ func (s *server) bzzDownloadHandler(w http.ResponseWriter, r *http.Request) {
 	buf = bytes.NewBuffer(nil)
 	_, err = file.JoinReadAll(ctx, j, fe.Metadata(), buf)
 	if err != nil {
-		s.Logger.Debugf("bzz download: read file metadata %s: %v", address, err)
-		s.Logger.Errorf("bzz download: read file metadata %s", address)
+		logger.Debugf("bzz download: read file metadata %s: %v", address, err)
+		logger.Errorf("bzz download: read file metadata %s", address)
 		jsonhttp.NotFound(w, nil)
 		return
 	}
 	fileMetadata := &entry.Metadata{}
 	err = json.Unmarshal(buf.Bytes(), fileMetadata)
 	if err != nil {
-		s.Logger.Debugf("bzz download: unmarshal metadata %s: %v", address, err)
-		s.Logger.Errorf("bzz download: unmarshal metadata %s", address)
+		logger.Debugf("bzz download: unmarshal metadata %s: %v", address, err)
+		logger.Errorf("bzz download: unmarshal metadata %s", address)
 		jsonhttp.InternalServerError(w, "error unmarshaling metadata")
 		return
 	}

pkg/api/dirs.go

@@ -24,6 +24,7 @@ import (
 	"github.com/ethersphere/bee/pkg/sctx"
 	"github.com/ethersphere/bee/pkg/storage"
 	"github.com/ethersphere/bee/pkg/swarm"
+	"github.com/ethersphere/bee/pkg/tracing"
 )
 
 const (
@@ -33,18 +34,19 @@ const (
 
 // dirUploadHandler uploads a directory supplied as a tar in an HTTP request
 func (s *server) dirUploadHandler(w http.ResponseWriter, r *http.Request) {
+	logger := tracing.NewLoggerWithTraceID(r.Context(), s.Logger)
 	err := validateRequest(r)
 	if err != nil {
-		s.Logger.Errorf("dir upload, validate request")
-		s.Logger.Debugf("dir upload, validate request err: %v", err)
+		logger.Errorf("dir upload, validate request")
+		logger.Debugf("dir upload, validate request err: %v", err)
 		jsonhttp.BadRequest(w, "could not validate request")
 		return
 	}
 
 	tag, created, err := s.getOrCreateTag(r.Header.Get(SwarmTagUidHeader))
 	if err != nil {
-		s.Logger.Debugf("dir upload: get or create tag: %v", err)
-		s.Logger.Error("dir upload: get or create tag")
+		logger.Debugf("dir upload: get or create tag: %v", err)
+		logger.Error("dir upload: get or create tag")
 		jsonhttp.InternalServerError(w, "cannot get or create tag")
 		return
 	}
@@ -54,16 +56,16 @@ func (s *server) dirUploadHandler(w http.ResponseWriter, r *http.Request) {
 
 	reference, err := storeDir(ctx, r.Body, s.Storer, requestModePut(r), s.Logger, requestEncrypt(r))
 	if err != nil {
-		s.Logger.Debugf("dir upload: store dir err: %v", err)
-		s.Logger.Errorf("dir upload: store dir")
+		logger.Debugf("dir upload: store dir err: %v", err)
+		logger.Errorf("dir upload: store dir")
 		jsonhttp.InternalServerError(w, "could not store dir")
 		return
 	}
 	if created {
 		_, err = tag.DoneSplit(reference)
 		if err != nil {
-			s.Logger.Debugf("dir upload: done split: %v", err)
-			s.Logger.Error("dir upload: done split failed")
+			logger.Debugf("dir upload: done split: %v", err)
+			logger.Error("dir upload: done split failed")
 			jsonhttp.InternalServerError(w, nil)
 			return
 		}
@@ -92,7 +94,8 @@ func validateRequest(r *http.Request) error {
 
 // storeDir stores all files recursively contained in the directory given as a tar
 // it returns the hash for the uploaded manifest corresponding to the uploaded dir
-func storeDir(ctx context.Context, reader io.ReadCloser, s storage.Storer, mode storage.ModePut, logger logging.Logger, encrypt bool) (swarm.Address, error) {
+func storeDir(ctx context.Context, reader io.ReadCloser, s storage.Storer, mode storage.ModePut, log logging.Logger, encrypt bool) (swarm.Address, error) {
+	logger := tracing.NewLoggerWithTraceID(ctx, log)
 
 	dirManifest, err := manifest.NewDefaultManifest(encrypt, s)
 	if err != nil {

pkg/api/file.go

@@ -27,6 +27,7 @@ import (
 	"github.com/ethersphere/bee/pkg/sctx"
 	"github.com/ethersphere/bee/pkg/storage"
 	"github.com/ethersphere/bee/pkg/swarm"
+	"github.com/ethersphere/bee/pkg/tracing"
 	"github.com/gorilla/mux"
 )
 
@@ -45,6 +46,7 @@ type fileUploadResponse struct {
 func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
 	var (
 		reader                  io.Reader
+		logger                  = tracing.NewLoggerWithTraceID(r.Context(), s.Logger)
 		fileName, contentLength string
 		fileSize                uint64
 		mode                    = requestModePut(r)
@@ -53,16 +55,16 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
 
 	mediaType, params, err := mime.ParseMediaType(contentType)
 	if err != nil {
-		s.Logger.Debugf("file upload: parse content type header %q: %v", contentType, err)
-		s.Logger.Errorf("file upload: parse content type header %q", contentType)
+		logger.Debugf("file upload: parse content type header %q: %v", contentType, err)
+		logger.Errorf("file upload: parse content type header %q", contentType)
 		jsonhttp.BadRequest(w, "invalid content-type header")
 		return
 	}
 
 	tag, created, err := s.getOrCreateTag(r.Header.Get(SwarmTagUidHeader))
 	if err != nil {
-		s.Logger.Debugf("file upload: get or create tag: %v", err)
-		s.Logger.Error("file upload: get or create tag")
+		logger.Debugf("file upload: get or create tag: %v", err)
+		logger.Error("file upload: get or create tag")
 		jsonhttp.InternalServerError(w, "cannot get or create tag")
 		return
 	}
@@ -76,8 +78,8 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
 		// read only the first part, as only one file upload is supported
 		part, err := mr.NextPart()
 		if err != nil {
-			s.Logger.Debugf("file upload: read multipart: %v", err)
-			s.Logger.Error("file upload: read multipart")
+			logger.Debugf("file upload: read multipart: %v", err)
+			logger.Error("file upload: read multipart")
 			jsonhttp.BadRequest(w, "invalid multipart/form-data")
 			return
 		}
@@ -96,8 +98,8 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
 			br := bufio.NewReader(part)
 			buf, err := br.Peek(512)
 			if err != nil && err != io.EOF {
-				s.Logger.Debugf("file upload: read content type, file %q: %v", fileName, err)
-				s.Logger.Errorf("file upload: read content type, file %q", fileName)
+				logger.Debugf("file upload: read content type, file %q: %v", fileName, err)
+				logger.Errorf("file upload: read content type, file %q", fileName)
 				jsonhttp.BadRequest(w, "error reading content type")
 				return
 			}
@@ -116,8 +118,8 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
 	if contentLength != "" {
 		fileSize, err = strconv.ParseUint(contentLength, 10, 64)
 		if err != nil {
-			s.Logger.Debugf("file upload: content length, file %q: %v", fileName, err)
-			s.Logger.Errorf("file upload: content length, file %q", fileName)
+			logger.Debugf("file upload: content length, file %q: %v", fileName, err)
+			logger.Errorf("file upload: content length, file %q", fileName)
 			jsonhttp.BadRequest(w, "invalid content length header")
 			return
 		}
@@ -125,8 +127,8 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
 		// copy the part to a tmp file to get its size
 		tmp, err := ioutil.TempFile("", "bee-multipart")
 		if err != nil {
-			s.Logger.Debugf("file upload: create temporary file: %v", err)
-			s.Logger.Errorf("file upload: create temporary file")
+			logger.Debugf("file upload: create temporary file: %v", err)
+			logger.Errorf("file upload: create temporary file")
 			jsonhttp.InternalServerError(w, nil)
 			return
 		}
@@ -134,14 +136,14 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
 		defer tmp.Close()
 		n, err := io.Copy(tmp, reader)
 		if err != nil {
-			s.Logger.Debugf("file upload: write temporary file: %v", err)
-			s.Logger.Error("file upload: write temporary file")
+			logger.Debugf("file upload: write temporary file: %v", err)
+			logger.Error("file upload: write temporary file")
 			jsonhttp.InternalServerError(w, nil)
 			return
 		}
 		if _, err := tmp.Seek(0, io.SeekStart); err != nil {
-			s.Logger.Debugf("file upload: seek to beginning of temporary file: %v", err)
-			s.Logger.Error("file upload: seek to beginning of temporary file")
+			logger.Debugf("file upload: seek to beginning of temporary file: %v", err)
+			logger.Error("file upload: seek to beginning of temporary file")
 			jsonhttp.InternalServerError(w, nil)
 			return
 		}
@@ -153,8 +155,8 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
 	pipe := pipeline.NewPipelineBuilder(ctx, s.Storer, mode, requestEncrypt(r))
 	fr, err := pipeline.FeedPipeline(ctx, pipe, reader, int64(fileSize))
 	if err != nil {
-		s.Logger.Debugf("file upload: file store, file %q: %v", fileName, err)
-		s.Logger.Errorf("file upload: file store, file %q", fileName)
+		logger.Debugf("file upload: file store, file %q: %v", fileName, err)
+		logger.Errorf("file upload: file store, file %q", fileName)
 		jsonhttp.InternalServerError(w, "could not store file data")
 		return
 	}
@@ -169,16 +171,16 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
 	m.MimeType = contentType
 	metadataBytes, err := json.Marshal(m)
 	if err != nil {
-		s.Logger.Debugf("file upload: metadata marshal, file %q: %v", fileName, err)
-		s.Logger.Errorf("file upload: metadata marshal, file %q", fileName)
+		logger.Debugf("file upload: metadata marshal, file %q: %v", fileName, err)
+		logger.Errorf("file upload: metadata marshal, file %q", fileName)
 		jsonhttp.InternalServerError(w, "metadata marshal error")
 		return
 	}
 	pipe = pipeline.NewPipelineBuilder(ctx, s.Storer, mode, requestEncrypt(r))
 	mr, err := pipeline.FeedPipeline(ctx, pipe, bytes.NewReader(metadataBytes), int64(len(metadataBytes)))
 	if err != nil {
-		s.Logger.Debugf("file upload: metadata store, file %q: %v", fileName, err)
-		s.Logger.Errorf("file upload: metadata store, file %q", fileName)
+		logger.Debugf("file upload: metadata store, file %q: %v", fileName, err)
+		logger.Errorf("file upload: metadata store, file %q", fileName)
 		jsonhttp.InternalServerError(w, "could not store metadata")
 		return
 	}
@@ -187,24 +189,24 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
 	entrie := entry.New(fr, mr)
 	fileEntryBytes, err := entrie.MarshalBinary()
 	if err != nil {
-		s.Logger.Debugf("file upload: entry marshal, file %q: %v", fileName, err)
-		s.Logger.Errorf("file upload: entry marshal, file %q", fileName)
+		logger.Debugf("file upload: entry marshal, file %q: %v", fileName, err)
+		logger.Errorf("file upload: entry marshal, file %q", fileName)
 		jsonhttp.InternalServerError(w, "entry marshal error")
 		return
 	}
 	pipe = pipeline.NewPipelineBuilder(ctx, s.Storer, mode, requestEncrypt(r))
 	reference, err := pipeline.FeedPipeline(ctx, pipe, bytes.NewReader(fileEntryBytes), int64(len(fileEntryBytes)))
 	if err != nil {
-		s.Logger.Debugf("file upload: entry store, file %q: %v", fileName, err)
-		s.Logger.Errorf("file upload: entry store, file %q", fileName)
+		logger.Debugf("file upload: entry store, file %q: %v", fileName, err)
+		logger.Errorf("file upload: entry store, file %q", fileName)
 		jsonhttp.InternalServerError(w, "could not store entry")
 		return
 	}
 	if created {
 		_, err = tag.DoneSplit(reference)
 		if err != nil {
-			s.Logger.Debugf("file upload: done split: %v", err)
-			s.Logger.Error("file upload: done split failed")
+			logger.Debugf("file upload: done split: %v", err)
+			logger.Error("file upload: done split failed")
 			jsonhttp.InternalServerError(w, nil)
 			return
 		}
@@ -227,34 +229,35 @@ type fileUploadInfo struct {
 
 // fileDownloadHandler downloads the file given the entry's reference.
 func (s *server) fileDownloadHandler(w http.ResponseWriter, r *http.Request) {
+	logger := tracing.NewLoggerWithTraceID(r.Context(), s.Logger)
 	nameOrHex := mux.Vars(r)["addr"]
 
 	address, err := s.resolveNameOrAddress(nameOrHex)
 	if err != nil {
-		s.Logger.Debugf("file download: parse file address %s: %v", nameOrHex, err)
-		s.Logger.Errorf("file download: parse file address %s", nameOrHex)
+		logger.Debugf("file download: parse file address %s: %v", nameOrHex, err)
+		logger.Errorf("file download: parse file address %s", nameOrHex)
 		jsonhttp.BadRequest(w, "invalid file address")
 		return
 	}
 
 	targets := r.URL.Query().Get("targets")
-	sctx.SetTargets(r.Context(), targets)
+	r = r.WithContext(sctx.SetTargets(r.Context(), targets))
 
 	// read entry.
 	j := seekjoiner.NewSimpleJoiner(s.Storer)
 	buf := bytes.NewBuffer(nil)
 	_, err = file.JoinReadAll(r.Context(), j, address, buf)
 	if err != nil {
-		s.Logger.Debugf("file download: read entry %s: %v", address, err)
-		s.Logger.Errorf("file download: read entry %s", address)
+		logger.Debugf("file download: read entry %s: %v", address, err)
+		logger.Errorf("file download: read entry %s", address)
 		jsonhttp.NotFound(w, nil)
 		return
 	}
 	e := &entry.Entry{}
 	err = e.UnmarshalBinary(buf.Bytes())
 	if err != nil {
-		s.Logger.Debugf("file download: unmarshal entry %s: %v", address, err)
-		s.Logger.Errorf("file download: unmarshal entry %s", address)
+		logger.Debugf("file download: unmarshal entry %s: %v", address, err)
+		logger.Errorf("file download: unmarshal entry %s", address)
 		jsonhttp.InternalServerError(w, "error unmarshaling entry")
 		return
 	}
@@ -273,16 +276,16 @@ func (s *server) fileDownloadHandler(w http.ResponseWriter, r *http.Request) {
 	buf = bytes.NewBuffer(nil)
 	_, err = file.JoinReadAll(r.Context(), j, e.Metadata(), buf)
 	if err != nil {
-		s.Logger.Debugf("file download: read metadata %s: %v", nameOrHex, err)
-		s.Logger.Errorf("file download: read metadata %s", nameOrHex)
+		logger.Debugf("file download: read metadata %s: %v", nameOrHex, err)
+		logger.Errorf("file download: read metadata %s", nameOrHex)
 		jsonhttp.NotFound(w, nil)
 		return
 	}
 	metaData := &entry.Metadata{}
 	err = json.Unmarshal(buf.Bytes(), metaData)
 	if err != nil {
-		s.Logger.Debugf("file download: unmarshal metadata %s: %v", nameOrHex, err)
-		s.Logger.Errorf("file download: unmarshal metadata %s", nameOrHex)
+		logger.Debugf("file download: unmarshal metadata %s: %v", nameOrHex, err)
+		logger.Errorf("file download: unmarshal metadata %s", nameOrHex)
 		jsonhttp.InternalServerError(w, "error unmarshaling metadata")
 		return
 	}
@@ -297,6 +300,7 @@ func (s *server) fileDownloadHandler(w http.ResponseWriter, r *http.Request) {
 
 // downloadHandler contains common logic for dowloading Swarm file from API
 func (s *server) downloadHandler(w http.ResponseWriter, r *http.Request, reference swarm.Address, additionalHeaders http.Header) {
+	logger := tracing.NewLoggerWithTraceID(r.Context(), s.Logger)
 	targets := r.URL.Query().Get("targets")
 	r = r.WithContext(sctx.SetTargets(r.Context(), targets))
 
@@ -304,13 +308,13 @@ func (s *server) downloadHandler(w http.ResponseWriter, r *http.Request, referen
 	reader, l, err := rs.Join(r.Context(), reference)
 	if err != nil {
 		if errors.Is(err, storage.ErrNotFound) {
-			s.Logger.Debugf("api download: not found %s: %v", reference, err)
-			s.Logger.Error("api download: not found")
+			logger.Debugf("api download: not found %s: %v", reference, err)
+			logger.Error("api download: not found")
 			jsonhttp.NotFound(w, "not found")
 			return
 		}
-		s.Logger.Debugf("api download: invalid root chunk %s: %v", reference, err)
-		s.Logger.Error("api download: invalid root chunk")
+		logger.Debugf("api download: invalid root chunk %s: %v", reference, err)
+		logger.Error("api download: invalid root chunk")
 		jsonhttp.NotFound(w, nil)
 		return
 	}

pkg/api/router.go

@@ -38,21 +38,36 @@ func (s *server) setupRouting() {
 	})
 
 	handle(router, "/files", jsonhttp.MethodHandler{
-		"POST": http.HandlerFunc(s.fileUploadHandler),
+		"POST": web.ChainHandlers(
+			s.newTracingHandler("files-upload"),
+			web.FinalHandlerFunc(s.fileUploadHandler),
+		),
 	})
 	handle(router, "/files/{addr}", jsonhttp.MethodHandler{
-		"GET": http.HandlerFunc(s.fileDownloadHandler),
+		"GET": web.ChainHandlers(
+			s.newTracingHandler("files-download"),
+			web.FinalHandlerFunc(s.fileDownloadHandler),
+		),
 	})
 
 	handle(router, "/dirs", jsonhttp.MethodHandler{
-		"POST": http.HandlerFunc(s.dirUploadHandler),
+		"POST": web.ChainHandlers(
+			s.newTracingHandler("dirs-upload"),
+			web.FinalHandlerFunc(s.dirUploadHandler),
+		),
 	})
 
 	handle(router, "/bytes", jsonhttp.MethodHandler{
-		"POST": http.HandlerFunc(s.bytesUploadHandler),
+		"POST": web.ChainHandlers(
+			s.newTracingHandler("bytes-upload"),
+			web.FinalHandlerFunc(s.bytesUploadHandler),
+		),
 	})
 	handle(router, "/bytes/{address}", jsonhttp.MethodHandler{
-		"GET": http.HandlerFunc(s.bytesGetHandler),
+		"GET": web.ChainHandlers(
+			s.newTracingHandler("bytes-download"),
+			web.FinalHandlerFunc(s.bytesGetHandler),
+		),
 	})
 
 	handle(router, "/chunks/{addr}", jsonhttp.MethodHandler{
@@ -64,7 +79,10 @@ func (s *server) setupRouting() {
 	})
 
 	handle(router, "/bzz/{address}/{path:.*}", jsonhttp.MethodHandler{
-		"GET": http.HandlerFunc(s.bzzDownloadHandler),
+		"GET": web.ChainHandlers(
+			s.newTracingHandler("bzz-download"),
+			web.FinalHandlerFunc(s.bzzDownloadHandler),
+		),
 	})
 
 	handle(router, "/tags", web.ChainHandlers(