feat(node): propagated request ID to Identity Node

Signed-off-by: Mohamed Tahar KEDJOUR <mkedjour@cisco.com>

Author: mkedjour

backend/internal/core/identity/identity_service.go

@@ -68,7 +68,7 @@ type Service interface {
 	) error
 }
 
-// The verificationService struct implements the VerificationService interface
+// service struct implements the VerificationService interface
 type service struct {
 	issuerClient          issuersdk.ClientService
 	idClient              idsdk.ClientService
@@ -78,7 +78,7 @@ type service struct {
 	uniqueIssuerPerTenant bool
 }
 
-// NewVerificationService creates a new instance of the VerificationService
+// NewService creates a new instance of the VerificationService
 func NewService(
 	identityHost, identityPort string,
 	keyStore KeyStore,
@@ -90,6 +90,7 @@ func NewService(
 		"",
 		nil,
 	)
+	transport.Transport = newTransportWithRequestID()
 
 	return &service{
 		issuerClient:          issuersdk.New(transport, strfmt.Default),
@@ -145,6 +146,7 @@ func (s *service) RegisterIssuer(
 			Issuer: issuer,
 			Proof:  proof,
 		},
+		Context: ctx,
 	})
 
 	if err != nil &&
@@ -178,6 +180,7 @@ func (s *service) GenerateID(
 			},
 			Proof: proof,
 		},
+		Context: ctx,
 	})
 	if err != nil {
 		return "", fmt.Errorf("error generating ID with identity service: %w", err)
@@ -239,6 +242,7 @@ func (s *service) PublishVerifiableCredential(
 				ProofValue: proof.ProofValue,
 			},
 		},
+		Context: ctx,
 	})
 	if err != nil {
 		return err
@@ -332,6 +336,7 @@ func (s *service) VerifyVerifiableCredential(
 				Value: *vc,
 			},
 		},
+		Context: ctx,
 	})
 	if err != nil {
 		return nil, fmt.Errorf("error verifying verifiable credential: %w", err)
@@ -349,8 +354,8 @@ func (s *service) VerifyVerifiableCredential(
 		MediaType:                    result.MediaType,
 		Controller:                   result.Controller,
 		ControlledIdentifierDocument: result.ControlledIdentifierDocument,
-		Warnings:                     convertutil.ConvertSlice(result.Warnings, convertErroInfo),
-		Errors:                       convertutil.ConvertSlice(result.Errors, convertErroInfo),
+		Warnings:                     convertutil.ConvertSlice(result.Warnings, convertErrorInfo),
+		Errors:                       convertutil.ConvertSlice(result.Errors, convertErrorInfo),
 	}, nil
 }
 
@@ -403,6 +408,7 @@ func (s *service) RevokeVerifiableCredential(
 				ProofValue: proof.ProofValue,
 			},
 		},
+		Context: ctx,
 	})
 	if err != nil {
 		errInfo, err := tryGetErrorInfo(err)
@@ -441,7 +447,7 @@ func tryGetErrorInfo(err error) (*identitymodels.V1alpha1ErrorInfo, error) {
 	return nil, err
 }
 
-func convertErroInfo(err *identitymodels.V1alpha1ErrorInfo) *badgetypes.ErrorInfo {
+func convertErrorInfo(err *identitymodels.V1alpha1ErrorInfo) *badgetypes.ErrorInfo {
 	if err == nil {
 		return nil
 	}

backend/internal/core/identity/transport.go

@@ -0,0 +1,36 @@
+// Copyright 2025 AGNTCY Contributors (https://github.com/agntcy)
+// SPDX-License-Identifier: Apache-2.0
+
+package identity
+
+import (
+	"net/http"
+
+	identitycontext "github.com/agntcy/identity-service/internal/pkg/context"
+)
+
+// transportWithRequestID is an HTTP transport that propagates the request ID to the Identity Node
+type transportWithRequestID struct {
+	Transport http.RoundTripper
+}
+
+func (t *transportWithRequestID) RoundTrip(req *http.Request) (*http.Response, error) {
+	reqID, ok := identitycontext.GetRequestID(req.Context())
+	if !ok || reqID == "" {
+		return t.Transport.RoundTrip(req)
+	}
+
+	if req.Header == nil {
+		req.Header = make(http.Header)
+	}
+
+	req.Header.Add("X-Request-Id", reqID)
+
+	return t.Transport.RoundTrip(req)
+}
+
+func newTransportWithRequestID() *transportWithRequestID {
+	return &transportWithRequestID{
+		Transport: http.DefaultTransport,
+	}
+}

backend/internal/core/identity/transport_test.go

@@ -0,0 +1,97 @@
+// Copyright 2025 AGNTCY Contributors (https://github.com/agntcy)
+// SPDX-License-Identifier: Apache-2.0
+
+//nolint:testpackage // this file is testing a private struct
+package identity
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	identitycontext "github.com/agntcy/identity-service/internal/pkg/context"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+)
+
+func createTestServerWithReqHeadersPropagation(t *testing.T) *httptest.Server {
+	t.Helper()
+
+	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		for k, v := range r.Header {
+			w.Header().Add(k, v[0])
+		}
+
+		_, _ = w.Write([]byte(uuid.NewString()))
+	}))
+}
+
+func TestTransportWithRequestID_should_inject_request_id_in_http_request(t *testing.T) {
+	t.Parallel()
+
+	ts := createTestServerWithReqHeadersPropagation(t)
+	defer ts.Close()
+
+	requestID := uuid.NewString()
+	ctx := identitycontext.InsertRequestID(t.Context(), requestID)
+
+	transport := newTransportWithRequestID()
+	client := http.Client{
+		Transport: transport,
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ts.URL, http.NoBody)
+	assert.NoError(t, err)
+
+	resp, err := client.Do(req)
+
+	defer func() {
+		_ = resp.Body.Close()
+	}()
+
+	assert.NoError(t, err)
+	assert.Equal(t, requestID, resp.Header.Get("X-Request-Id"))
+}
+
+func TestTransportWithRequestID_should_not_inject_request_id_in_http_request(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]*struct {
+		ctx context.Context //nolint:containedctx // essential part of the test case
+	}{
+		"empty request ID in context": {
+			ctx: identitycontext.InsertRequestID(t.Context(), ""),
+		},
+		"context without request ID": {
+			ctx: t.Context(),
+		},
+	}
+
+	for tn, tc := range testCases {
+		t.Run(tn, func(t *testing.T) {
+			t.Parallel()
+
+			ts := createTestServerWithReqHeadersPropagation(t)
+			defer ts.Close()
+
+			transport := newTransportWithRequestID()
+			client := http.Client{Transport: transport}
+
+			req, err := http.NewRequestWithContext(tc.ctx, http.MethodGet, ts.URL, http.NoBody)
+			assert.NoError(t, err)
+
+			resp, err := client.Do(req)
+
+			defer func() {
+				_ = resp.Body.Close()
+			}()
+
+			assert.NoError(t, err)
+
+			v, exists := resp.Header[http.CanonicalHeaderKey("X-Request-Id")]
+			assert.False(t, exists)
+			assert.Empty(t, v)
+		})
+	}
+}