diff --git a/pkg/networkservice/chains/client/client.go b/pkg/networkservice/chains/client/client.go index 9ea09dbb5..a8467383d 100644 --- a/pkg/networkservice/chains/client/client.go +++ b/pkg/networkservice/chains/client/client.go @@ -1,4 +1,4 @@ -// Copyright (c) 2021-2023 Cisco and/or its affiliates. +// Copyright (c) 2021-2022 Cisco and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -53,8 +53,8 @@ func NewClient(ctx context.Context, clientOpts ...Option) networkservice.Network append( []networkservice.NetworkServiceClient{ updatepath.NewClient(opts.name), - metadata.NewClient(), begin.NewClient(), + metadata.NewClient(), opts.refreshClient, clienturl.NewClient(opts.clientURL), clientconn.NewClient(opts.cc), diff --git a/pkg/networkservice/chains/endpoint/server.go b/pkg/networkservice/chains/endpoint/server.go index 01aff636d..59b8694c6 100644 --- a/pkg/networkservice/chains/endpoint/server.go +++ b/pkg/networkservice/chains/endpoint/server.go @@ -1,6 +1,6 @@ // Copyright (c) 2020-2022 Cisco Systems, Inc. // -// Copyright (c) 2020-2023 Doc.ai and/or its affiliates. +// Copyright (c) 2020-2022 Doc.ai and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -121,10 +121,10 @@ func NewServer(ctx context.Context, tokenGenerator token.GeneratorFunc, options rv.NetworkServiceServer = chain.NewNetworkServiceServer( append([]networkservice.NetworkServiceServer{ updatepath.NewServer(opts.name), - metadata.NewServer(), begin.NewServer(), updatetoken.NewServer(tokenGenerator), opts.authorizeServer, + metadata.NewServer(), timeout.NewServer(ctx), monitor.NewServer(ctx, &mcsPtr), trimpath.NewServer(), diff --git a/pkg/networkservice/chains/nsmgr/server.go b/pkg/networkservice/chains/nsmgr/server.go index 4db9b9845..2b715d59d 100644 --- a/pkg/networkservice/chains/nsmgr/server.go +++ b/pkg/networkservice/chains/nsmgr/server.go @@ -58,7 +58,6 @@ import ( registryrecvfd "github.com/networkservicemesh/sdk/pkg/registry/common/recvfd" registrysendfd "github.com/networkservicemesh/sdk/pkg/registry/common/sendfd" "github.com/networkservicemesh/sdk/pkg/registry/common/updatepath" - "github.com/networkservicemesh/sdk/pkg/registry/utils/metadata" registryadapter "github.com/networkservicemesh/sdk/pkg/registry/core/adapters" "github.com/networkservicemesh/sdk/pkg/registry/core/chain" @@ -237,7 +236,6 @@ func NewServer(ctx context.Context, tokenGenerator token.GeneratorFunc, options // Use remote registry nsRegistry = registryconnect.NewNetworkServiceRegistryServer( chain.NewNetworkServiceRegistryClient( - metadata.NewNetworkServiceClient(), clienturl.NewNetworkServiceRegistryClient(opts.regURL), begin.NewNetworkServiceRegistryClient(), clientconn.NewNetworkServiceRegistryClient(), @@ -254,17 +252,14 @@ func NewServer(ctx context.Context, tokenGenerator token.GeneratorFunc, options nsRegistry = chain.NewNetworkServiceRegistryServer( grpcmetadata.NewNetworkServiceRegistryServer(), updatepath.NewNetworkServiceRegistryServer(tokenGenerator), - metadata.NewNetworkServiceServer(), opts.authorizeNSRegistryServer, nsRegistry, ) var remoteOrLocalRegistry = chain.NewNetworkServiceEndpointRegistryServer( - metadata.NewNetworkServiceEndpointServer(), localbypass.NewNetworkServiceEndpointRegistryServer(opts.url), registryconnect.NewNetworkServiceEndpointRegistryServer( chain.NewNetworkServiceEndpointRegistryClient( - metadata.NewNetworkServiceEndpointClient(), begin.NewNetworkServiceEndpointRegistryClient(), clienturl.NewNetworkServiceEndpointRegistryClient(opts.regURL), clientconn.NewNetworkServiceEndpointRegistryClient(), @@ -280,7 +275,6 @@ func NewServer(ctx context.Context, tokenGenerator token.GeneratorFunc, options if opts.regURL == nil { remoteOrLocalRegistry = chain.NewNetworkServiceEndpointRegistryServer( - metadata.NewNetworkServiceEndpointServer(), memory.NewNetworkServiceEndpointRegistryServer(), localbypass.NewNetworkServiceEndpointRegistryServer(opts.url), ) @@ -289,7 +283,6 @@ func NewServer(ctx context.Context, tokenGenerator token.GeneratorFunc, options var nseRegistry = chain.NewNetworkServiceEndpointRegistryServer( grpcmetadata.NewNetworkServiceEndpointRegistryServer(), updatepath.NewNetworkServiceEndpointRegistryServer(tokenGenerator), - metadata.NewNetworkServiceEndpointServer(), opts.authorizeNSERegistryServer, begin.NewNetworkServiceEndpointRegistryServer(), registryclientinfo.NewNetworkServiceEndpointRegistryServer(), @@ -338,6 +331,7 @@ func NewServer(ctx context.Context, tokenGenerator token.GeneratorFunc, options nsRegistry, nseRegistry, ) + return rv } diff --git a/pkg/networkservice/chains/nsmgrproxy/server.go b/pkg/networkservice/chains/nsmgrproxy/server.go index 738b64303..2a0795727 100644 --- a/pkg/networkservice/chains/nsmgrproxy/server.go +++ b/pkg/networkservice/chains/nsmgrproxy/server.go @@ -1,4 +1,4 @@ -// Copyright (c) 2020-2023 Doc.ai and/or its affiliates. +// Copyright (c) 2020-2022 Doc.ai and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -50,7 +50,6 @@ import ( registryswapip "github.com/networkservicemesh/sdk/pkg/registry/common/swapip" "github.com/networkservicemesh/sdk/pkg/registry/common/updatepath" "github.com/networkservicemesh/sdk/pkg/registry/core/chain" - "github.com/networkservicemesh/sdk/pkg/registry/utils/metadata" "github.com/networkservicemesh/sdk/pkg/tools/fs" "github.com/networkservicemesh/sdk/pkg/tools/grpcutils" "github.com/networkservicemesh/sdk/pkg/tools/log" @@ -226,7 +225,6 @@ func NewServer(ctx context.Context, regURL, proxyURL *url.URL, tokenGenerator to var interdomainBypassNSEServer registryapi.NetworkServiceEndpointRegistryServer nseClient := chain.NewNetworkServiceEndpointRegistryClient( - metadata.NewNetworkServiceEndpointClient(), begin.NewNetworkServiceEndpointRegistryClient(), clienturl.NewNetworkServiceEndpointRegistryClient(regURL), clientconn.NewNetworkServiceEndpointRegistryClient(), @@ -238,7 +236,6 @@ func NewServer(ctx context.Context, regURL, proxyURL *url.URL, tokenGenerator to ) nsClient := chain.NewNetworkServiceRegistryClient( - metadata.NewNetworkServiceClient(), begin.NewNetworkServiceRegistryClient(), clienturl.NewNetworkServiceRegistryClient(regURL), clientconn.NewNetworkServiceRegistryClient(), @@ -274,7 +271,6 @@ func NewServer(ctx context.Context, regURL, proxyURL *url.URL, tokenGenerator to var nsServerChain = registryconnect.NewNetworkServiceRegistryServer( chain.NewNetworkServiceRegistryClient( - metadata.NewNetworkServiceClient(), begin.NewNetworkServiceRegistryClient(), clienturl.NewNetworkServiceRegistryClient(proxyURL), clientconn.NewNetworkServiceRegistryClient(), @@ -290,7 +286,6 @@ func NewServer(ctx context.Context, regURL, proxyURL *url.URL, tokenGenerator to nsServerChain = chain.NewNetworkServiceRegistryServer( grpcmetadata.NewNetworkServiceRegistryServer(), updatepath.NewNetworkServiceRegistryServer(tokenGenerator), - metadata.NewNetworkServiceServer(), opts.authorizeNSRegistryServer, nsServerChain, ) @@ -298,7 +293,6 @@ func NewServer(ctx context.Context, regURL, proxyURL *url.URL, tokenGenerator to var nseServerChain = chain.NewNetworkServiceEndpointRegistryServer( grpcmetadata.NewNetworkServiceEndpointRegistryServer(), updatepath.NewNetworkServiceEndpointRegistryServer(tokenGenerator), - metadata.NewNetworkServiceEndpointServer(), opts.authorizeNSERegistryServer, begin.NewNetworkServiceEndpointRegistryServer(), clienturl.NewNetworkServiceEndpointRegistryServer(proxyURL), @@ -307,7 +301,6 @@ func NewServer(ctx context.Context, regURL, proxyURL *url.URL, tokenGenerator to registryclusterinfo.NewNetworkServiceEndpointRegistryServer(), registryconnect.NewNetworkServiceEndpointRegistryServer( chain.NewNetworkServiceEndpointRegistryClient( - metadata.NewNetworkServiceEndpointClient(), clientconn.NewNetworkServiceEndpointRegistryClient(), opts.authorizeNSERegistryClient, grpcmetadata.NewNetworkServiceEndpointRegistryClient(), diff --git a/pkg/networkservice/common/mechanisms/checkmechanism/check_client_sets_mechanism_preferences.go b/pkg/networkservice/common/mechanisms/checkmechanism/check_client_sets_mechanism_preferences.go index cd1c9b465..84b34f891 100644 --- a/pkg/networkservice/common/mechanisms/checkmechanism/check_client_sets_mechanism_preferences.go +++ b/pkg/networkservice/common/mechanisms/checkmechanism/check_client_sets_mechanism_preferences.go @@ -1,4 +1,4 @@ -// Copyright (c) 2020-2023 Cisco and/or its affiliates. +// Copyright (c) 2020-2022 Cisco and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -30,7 +30,6 @@ import ( "github.com/networkservicemesh/sdk/pkg/networkservice/core/adapters" "github.com/networkservicemesh/sdk/pkg/networkservice/core/chain" "github.com/networkservicemesh/sdk/pkg/networkservice/utils/checks/checkrequest" - "github.com/networkservicemesh/sdk/pkg/networkservice/utils/metadata" ) type checkClientSetsMechanismPreferences struct { @@ -49,7 +48,6 @@ type checkClientSetsMechanismPreferences struct { func CheckClientSetsMechanismPreferences(t *testing.T, clientUnderTest networkservice.NetworkServiceClient, mechanismType string, mechanismCheck func(*testing.T, *networkservice.Mechanism)) networkservice.NetworkServiceClient { rv := &checkClientSetsMechanismPreferences{} rv.NetworkServiceClient = chain.NewNetworkServiceClient( - metadata.NewClient(), clientUnderTest, // Check after the clientUnderTest under test is run to make sure we have the right MechanismPreferences set checkrequest.NewClient(t, diff --git a/pkg/networkservice/common/mechanisms/checkmechanism/check_context.go b/pkg/networkservice/common/mechanisms/checkmechanism/check_context.go index 82dc2e44b..91b998bfd 100644 --- a/pkg/networkservice/common/mechanisms/checkmechanism/check_context.go +++ b/pkg/networkservice/common/mechanisms/checkmechanism/check_context.go @@ -1,4 +1,4 @@ -// Copyright (c) 2020-2023 Cisco and/or its affiliates. +// Copyright (c) 2020-2022 Cisco and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -28,7 +28,6 @@ import ( "github.com/networkservicemesh/sdk/pkg/networkservice/core/chain" "github.com/networkservicemesh/sdk/pkg/networkservice/utils/checks/checkcontext" "github.com/networkservicemesh/sdk/pkg/networkservice/utils/checks/checkcontextonreturn" - "github.com/networkservicemesh/sdk/pkg/networkservice/utils/metadata" ) // CheckClientContextOnReturn - returns a NetworkServiceClient that will check the state of the context.Context @@ -40,7 +39,6 @@ import ( // check - function to check the state of the context.Context after the clientUnderTest has returned func CheckClientContextOnReturn(t *testing.T, clientUnderTest networkservice.NetworkServiceClient, mechanismType string, check func(*testing.T, context.Context)) networkservice.NetworkServiceClient { return chain.NewNetworkServiceClient( - metadata.NewClient(), checkcontextonreturn.NewClient(t, check), clientUnderTest, adapters.NewServerToClient(mechanisms.NewServer( @@ -62,7 +60,6 @@ func CheckClientContextOnReturn(t *testing.T, clientUnderTest networkservice.Net // (as it cannot know what to do at this stage) func CheckClientContextAfter(t *testing.T, client networkservice.NetworkServiceClient, mechanismType string, check func(*testing.T, context.Context)) networkservice.NetworkServiceClient { return chain.NewNetworkServiceClient( - metadata.NewClient(), client, checkcontext.NewClient(t, check), adapters.NewServerToClient(mechanisms.NewServer( @@ -82,7 +79,6 @@ func CheckClientContextAfter(t *testing.T, client networkservice.NetworkServiceC // check - function to check that the serverUnderTest has taken action to implement the Mechanism func CheckContextAfterServer(t *testing.T, serverUnderTest networkservice.NetworkServiceServer, mechanismType string, check func(*testing.T, context.Context)) networkservice.NetworkServiceServer { return chain.NewNetworkServiceServer( - metadata.NewServer(), mechanisms.NewServer( map[string]networkservice.NetworkServiceServer{ mechanismType: serverUnderTest, diff --git a/pkg/networkservice/common/mechanisms/checkmechanism/server_suite.go b/pkg/networkservice/common/mechanisms/checkmechanism/server_suite.go index c2e4bf958..9b0284d71 100644 --- a/pkg/networkservice/common/mechanisms/checkmechanism/server_suite.go +++ b/pkg/networkservice/common/mechanisms/checkmechanism/server_suite.go @@ -1,4 +1,4 @@ -// Copyright (c) 2020-2023 Cisco and/or its affiliates. +// Copyright (c) 2020-2022 Cisco and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -28,7 +28,6 @@ import ( "github.com/networkservicemesh/sdk/pkg/networkservice/core/chain" "github.com/networkservicemesh/sdk/pkg/networkservice/utils/checks/checkerror" "github.com/networkservicemesh/sdk/pkg/networkservice/utils/checks/checkrequest" - "github.com/networkservicemesh/sdk/pkg/networkservice/utils/metadata" ) // ServerSuite - test suite to check that a NetworkServiceServer implementing a Mechanism meets basic contracts @@ -100,7 +99,6 @@ func (m *ServerSuite) TestContextAfter() { // before calling the next chain element have been made func (m *ServerSuite) TestMechanismAfter() { contract := chain.NewNetworkServiceServer( - metadata.NewServer(), mechanisms.NewServer( map[string]networkservice.NetworkServiceServer{ m.mechanismType: m.serverUnderTest, diff --git a/pkg/networkservice/common/mechanisms/client.go b/pkg/networkservice/common/mechanisms/client.go index 9bae53adb..fc7ae7446 100644 --- a/pkg/networkservice/common/mechanisms/client.go +++ b/pkg/networkservice/common/mechanisms/client.go @@ -1,4 +1,4 @@ -// Copyright (c) 2021-2023 Doc.ai and/or its affiliates. +// Copyright (c) 2021 Doc.ai and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -25,7 +25,6 @@ import ( "google.golang.org/grpc" "github.com/networkservicemesh/sdk/pkg/networkservice/core/chain" - "github.com/networkservicemesh/sdk/pkg/networkservice/utils/metadata" ) type mechanismsClient struct { @@ -38,7 +37,7 @@ func NewClient(mechanisms map[string]networkservice.NetworkServiceClient) networ mechanisms: make(map[string]networkservice.NetworkServiceClient), } for m, c := range mechanisms { - result.mechanisms[m] = chain.NewNetworkServiceClient(metadata.NewClient(), c) + result.mechanisms[m] = chain.NewNetworkServiceClient(c) } return result diff --git a/pkg/networkservice/common/mechanisms/server.go b/pkg/networkservice/common/mechanisms/server.go index f2406032e..602a9e972 100644 --- a/pkg/networkservice/common/mechanisms/server.go +++ b/pkg/networkservice/common/mechanisms/server.go @@ -28,7 +28,6 @@ import ( "github.com/pkg/errors" "github.com/networkservicemesh/sdk/pkg/networkservice/core/chain" - "github.com/networkservicemesh/sdk/pkg/networkservice/utils/metadata" ) type mechanismsServer struct { @@ -49,7 +48,7 @@ func NewServer(mechanisms map[string]networkservice.NetworkServiceServer) networ for mechanismType, server := range mechanisms { // We wrap in a chain here to make sure that if the 'server' is calling next.Server(ctx) it doesn't // skips past returning here. - rv.mechanisms[mechanismType] = chain.NewNetworkServiceServer(metadata.NewServer(), server) + rv.mechanisms[mechanismType] = chain.NewNetworkServiceServer(server) } return rv } diff --git a/pkg/networkservice/common/passthrough/client.go b/pkg/networkservice/common/passthrough/client.go index a20864c12..a4e47b150 100644 --- a/pkg/networkservice/common/passthrough/client.go +++ b/pkg/networkservice/common/passthrough/client.go @@ -1,4 +1,4 @@ -// Copyright (c) 2022-2023 Cisco and/or its affiliates. +// Copyright (c) 2022 Cisco and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -23,13 +23,11 @@ import ( "github.com/networkservicemesh/sdk/pkg/networkservice/common/passthrough/replacelabels" "github.com/networkservicemesh/sdk/pkg/networkservice/common/passthrough/replacensename" "github.com/networkservicemesh/sdk/pkg/networkservice/core/chain" - "github.com/networkservicemesh/sdk/pkg/networkservice/utils/metadata" ) // NewClient returns a combination for passthrough cases func NewClient(labels map[string]string) networkservice.NetworkServiceClient { return chain.NewNetworkServiceClient( - metadata.NewClient(), replacelabels.NewClient(labels), replacensename.NewClient(), ) diff --git a/pkg/networkservice/core/chain/client.go b/pkg/networkservice/core/chain/client.go index 8f5a2e1e1..c3fa4424f 100644 --- a/pkg/networkservice/core/chain/client.go +++ b/pkg/networkservice/core/chain/client.go @@ -1,6 +1,6 @@ // Copyright (c) 2020 Cisco Systems, Inc. // -// Copyright (c) 2021-2023 Doc.ai and/or its affiliates. +// Copyright (c) 2021 Doc.ai and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -20,21 +20,14 @@ package chain import ( "github.com/networkservicemesh/api/pkg/api/networkservice" - "github.com/sirupsen/logrus" - "github.com/networkservicemesh/sdk/pkg/networkservice/core/debug" "github.com/networkservicemesh/sdk/pkg/networkservice/core/next" "github.com/networkservicemesh/sdk/pkg/networkservice/core/trace" ) -// NewNetworkServiceClient - chains together a list of networkservice.NetworkServiceClient with tracing or debugging +// NewNetworkServiceClient - chains together a list of networkservice.NetworkServiceClient with tracing func NewNetworkServiceClient(clients ...networkservice.NetworkServiceClient) networkservice.NetworkServiceClient { - client := trace.NewNetworkServiceClient - if logrus.GetLevel() == logrus.DebugLevel { - client = debug.NewNetworkServiceClient - } - return next.NewNetworkServiceClient( - next.NewWrappedNetworkServiceClient(client, clients...), + next.NewWrappedNetworkServiceClient(trace.NewNetworkServiceClient, clients...), ) } diff --git a/pkg/networkservice/core/chain/server.go b/pkg/networkservice/core/chain/server.go index e030badb3..3fc07f232 100644 --- a/pkg/networkservice/core/chain/server.go +++ b/pkg/networkservice/core/chain/server.go @@ -1,6 +1,6 @@ // Copyright (c) 2020 Cisco Systems, Inc. // -// Copyright (c) 2021-2023 Doc.ai and/or its affiliates. +// Copyright (c) 2021 Doc.ai and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -22,21 +22,14 @@ package chain import ( "github.com/networkservicemesh/api/pkg/api/networkservice" - "github.com/sirupsen/logrus" - "github.com/networkservicemesh/sdk/pkg/networkservice/core/debug" "github.com/networkservicemesh/sdk/pkg/networkservice/core/next" "github.com/networkservicemesh/sdk/pkg/networkservice/core/trace" ) -// NewNetworkServiceServer - chains together a list of networkservice.Servers with tracing or debugging +// NewNetworkServiceServer - chains together a list of networkservice.Servers with tracing func NewNetworkServiceServer(servers ...networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { - server := trace.NewNetworkServiceServer - if logrus.GetLevel() == logrus.DebugLevel { - server = debug.NewNetworkServiceServer - } - return next.NewNetworkServiceServer( - next.NewWrappedNetworkServiceServer(server, servers...), + next.NewWrappedNetworkServiceServer(trace.NewNetworkServiceServer, servers...), ) } diff --git a/pkg/networkservice/core/debug/client.go b/pkg/networkservice/core/debug/client.go deleted file mode 100644 index 815b7af23..000000000 --- a/pkg/networkservice/core/debug/client.go +++ /dev/null @@ -1,133 +0,0 @@ -// Copyright (c) 2023 Doc.ai and/or its affiliates. -// -// SPDX-License-Identifier: Apache-2.0 -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at: -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package debug - -import ( - "context" - - "github.com/golang/protobuf/ptypes/empty" - "google.golang.org/grpc" - - "github.com/networkservicemesh/api/pkg/api/networkservice" - - "github.com/networkservicemesh/sdk/pkg/networkservice/core/next" - "github.com/networkservicemesh/sdk/pkg/tools/typeutils" -) - -type beginDebugClient struct { - debugged networkservice.NetworkServiceClient -} - -type endDebugClient struct{} - -const ( - clientRequestLoggedKey contextKeyType = "clientRequestLoggedKey" - clientCloseLoggedKey contextKeyType = "clientCloseLoggedKey" - clientPrefix = "client" -) - -// NewNetworkServiceClient - wraps tracing around the supplied networkservice.NetworkServiceClient -func NewNetworkServiceClient(debugged networkservice.NetworkServiceClient) networkservice.NetworkServiceClient { - return next.NewNetworkServiceClient( - &beginDebugClient{debugged: debugged}, - &endDebugClient{}, - ) -} - -func (t *beginDebugClient) Request(ctx context.Context, request *networkservice.NetworkServiceRequest, opts ...grpc.CallOption) (*networkservice.Connection, error) { - // Create a new logger - operation := typeutils.GetFuncName(t.debugged, methodNameRequest) - updatedContext := withLog(ctx, request.GetConnection().GetId()) - - if updatedContext.Value(clientRequestLoggedKey) == nil && isReadyForLogging(ctx, true) { - updatedContext = context.WithValue(updatedContext, clientRequestLoggedKey, true) - logRequest(updatedContext, request, clientPrefix, requestPrefix) - } - - // Actually call the next - rv, err := t.debugged.Request(updatedContext, request, opts...) - if err != nil { - if err != nil && isReadyForLogging(ctx, false) { - lastError, ok := getClientRequestError(ctx) - if !ok || lastError == nil || err.Error() != (*lastError).Error() { - storeClientRequestError(ctx, &err) - return nil, logError(updatedContext, err, operation) - } - } - } - - return rv, err -} - -func (t *beginDebugClient) Close(ctx context.Context, conn *networkservice.Connection, opts ...grpc.CallOption) (*empty.Empty, error) { - // Create a new logger - operation := typeutils.GetFuncName(t.debugged, methodNameClose) - updatedContext := withLog(ctx, conn.GetId()) - - if updatedContext.Value(clientCloseLoggedKey) == nil && isReadyForLogging(ctx, true) { - updatedContext = context.WithValue(updatedContext, clientCloseLoggedKey, true) - logRequest(updatedContext, conn, clientPrefix, closePrefix) - } - - // Actually call the next - rv, err := t.debugged.Close(updatedContext, conn, opts...) - if err != nil { - if err != nil && isReadyForLogging(ctx, false) { - lastError, ok := getClientCloseError(ctx) - if !ok || lastError == nil || err.Error() != (*lastError).Error() { - storeClientCloseError(ctx, &err) - return nil, logError(updatedContext, err, operation) - } - } - } - - return rv, err -} - -func (t *endDebugClient) Request(ctx context.Context, request *networkservice.NetworkServiceRequest, opts ...grpc.CallOption) (*networkservice.Connection, error) { - if isReadyForLogging(ctx, true) { - nextClient := next.Client(ctx) - withClientRequestTail(ctx, &nextClient) - - conn, err := nextClient.Request(ctx, request, opts...) - - tail, ok := clientRequestTail(ctx) - if ok && &nextClient == tail { - logResponse(ctx, conn, clientPrefix, requestPrefix) - } - - return conn, err - } - return next.Client(ctx).Request(ctx, request, opts...) -} - -func (t *endDebugClient) Close(ctx context.Context, conn *networkservice.Connection, opts ...grpc.CallOption) (*empty.Empty, error) { - if isReadyForLogging(ctx, true) { - nextClient := next.Client(ctx) - withClientCloseTail(ctx, &nextClient) - - r, err := nextClient.Close(ctx, conn, opts...) - - tail, ok := clientCloseTail(ctx) - if ok && &nextClient == tail { - logResponse(ctx, conn, clientPrefix, closePrefix) - } - - return r, err - } - return next.Client(ctx).Close(ctx, conn, opts...) -} diff --git a/pkg/networkservice/core/debug/context.go b/pkg/networkservice/core/debug/context.go deleted file mode 100644 index d601be0b3..000000000 --- a/pkg/networkservice/core/debug/context.go +++ /dev/null @@ -1,156 +0,0 @@ -// Copyright (c) 2023 Doc.ai and/or its affiliates. -// -// SPDX-License-Identifier: Apache-2.0 -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at: -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -// Package debug provides a wrapper for logging around a networkservice.NetworkServiceClient -package debug - -import ( - "context" - - "github.com/networkservicemesh/api/pkg/api/networkservice" - - "github.com/networkservicemesh/sdk/pkg/networkservice/utils/metadata" - "github.com/networkservicemesh/sdk/pkg/tools/log" - "github.com/networkservicemesh/sdk/pkg/tools/log/logruslogger" -) - -type contextKeyType string - -const ( - serverChainRequestTailKey contextKeyType = "serverChainRequestTailKey" - serverChainCloseTailKey contextKeyType = "serverChainCloseTailKey" - serverRequestErrorKey contextKeyType = "serverRequestErrorKey" - serverCloseErrorKey contextKeyType = "serverCloseErrorKey" - clientRequestErrorKey contextKeyType = "clientRequestErrorKey" - clientCloseErrorKey contextKeyType = "clientCloseErrorKey" - clientChainRequestTailKey contextKeyType = "clientChainRequestTailKey" - clientChainCloseTailKey contextKeyType = "clientChainCloseTailKey" - loggedType string = "networkService" -) - -func withLog(parent context.Context, connectionID string) (c context.Context) { - if parent == nil { - panic("cannot create context from nil parent") - } - - fields := []*log.Field{log.NewField("id", connectionID), log.NewField("type", loggedType)} - lLogger := logruslogger.LoggerWithFields(fields) - - return log.WithLog(parent, lLogger) -} - -func withServerRequestTail(ctx context.Context, server *networkservice.NetworkServiceServer) { - metadata.Map(ctx, false).Store(serverChainRequestTailKey, server) -} - -func serverRequestTail(ctx context.Context) (server *networkservice.NetworkServiceServer, ok bool) { - rawValue, ok := metadata.Map(ctx, false).Load(serverChainRequestTailKey) - if !ok { - return - } - value, ok := rawValue.(*networkservice.NetworkServiceServer) - return value, ok -} - -func withServerCloseTail(ctx context.Context, server *networkservice.NetworkServiceServer) { - metadata.Map(ctx, false).Store(serverChainCloseTailKey, server) -} - -func serverCloseTail(ctx context.Context) (server *networkservice.NetworkServiceServer, ok bool) { - rawValue, ok := metadata.Map(ctx, false).Load(serverChainCloseTailKey) - if !ok { - return - } - value, ok := rawValue.(*networkservice.NetworkServiceServer) - return value, ok -} - -func storeServerRequestError(ctx context.Context, err *error) { - metadata.Map(ctx, false).Store(serverRequestErrorKey, err) -} - -func getServerRequestError(ctx context.Context) (err *error, ok bool) { - return getError(ctx, false, serverRequestErrorKey) -} - -func storeServerCloseError(ctx context.Context, err *error) { - metadata.Map(ctx, false).Store(serverCloseErrorKey, err) -} - -func getServerCloseError(ctx context.Context) (err *error, ok bool) { - return getError(ctx, false, serverCloseErrorKey) -} - -func storeClientRequestError(ctx context.Context, err *error) { - metadata.Map(ctx, true).Store(clientRequestErrorKey, err) -} - -func getClientRequestError(ctx context.Context) (err *error, ok bool) { - return getError(ctx, true, clientRequestErrorKey) -} - -func storeClientCloseError(ctx context.Context, err *error) { - metadata.Map(ctx, true).Store(clientCloseErrorKey, err) -} - -func getClientCloseError(ctx context.Context) (err *error, ok bool) { - return getError(ctx, true, clientCloseErrorKey) -} - -func withClientRequestTail(ctx context.Context, client *networkservice.NetworkServiceClient) { - metadata.Map(ctx, true).Store(clientChainRequestTailKey, client) -} - -func clientRequestTail(ctx context.Context) (client *networkservice.NetworkServiceClient, ok bool) { - rawValue, ok := metadata.Map(ctx, true).Load(clientChainRequestTailKey) - if !ok { - return - } - value, ok := rawValue.(*networkservice.NetworkServiceClient) - return value, ok -} - -func withClientCloseTail(ctx context.Context, client *networkservice.NetworkServiceClient) { - metadata.Map(ctx, true).Store(clientChainCloseTailKey, client) -} - -func clientCloseTail(ctx context.Context) (client *networkservice.NetworkServiceClient, ok bool) { - rawValue, ok := metadata.Map(ctx, true).Load(clientChainCloseTailKey) - if !ok { - return - } - value, ok := rawValue.(*networkservice.NetworkServiceClient) - return value, ok -} - -func isReadyForLogging(ctx context.Context, isClient bool) (isReady bool) { - defer func() { - if r := recover(); r != nil { - isReady = false - } - }() - metadata.Map(ctx, isClient) - return true -} - -func getError(ctx context.Context, isClient bool, key contextKeyType) (err *error, ok bool) { - rawValue, ok := metadata.Map(ctx, isClient).Load(key) - if !ok { - return - } - value, ok := rawValue.(*error) - return value, ok -} diff --git a/pkg/networkservice/core/debug/server.go b/pkg/networkservice/core/debug/server.go deleted file mode 100644 index 41c6c1f5b..000000000 --- a/pkg/networkservice/core/debug/server.go +++ /dev/null @@ -1,128 +0,0 @@ -// Copyright (c) 2023 Doc.ai and/or its affiliates. -// -// SPDX-License-Identifier: Apache-2.0 -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at: -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package debug - -import ( - "context" - - "github.com/golang/protobuf/ptypes/empty" - - "github.com/networkservicemesh/api/pkg/api/networkservice" - - "github.com/networkservicemesh/sdk/pkg/networkservice/core/next" - "github.com/networkservicemesh/sdk/pkg/tools/typeutils" -) - -type beginDebugServer struct { - debugged networkservice.NetworkServiceServer -} - -type endDebugServer struct{} - -const ( - serverRequestLoggedKey contextKeyType = "serverRequestLoggedKey" - serverCloseLoggedKey contextKeyType = "serverCloseLoggedKey" - serverPrefix = "server" -) - -// NewNetworkServiceServer - wraps tracing around the supplied traced -func NewNetworkServiceServer(debugged networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { - return next.NewNetworkServiceServer( - &beginDebugServer{debugged: debugged}, - &endDebugServer{}, - ) -} - -func (t *beginDebugServer) Request(ctx context.Context, request *networkservice.NetworkServiceRequest) (*networkservice.Connection, error) { - // Create a new logger - operation := typeutils.GetFuncName(t.debugged, methodNameRequest) - updatedContext := withLog(ctx, request.GetConnection().GetId()) - - if updatedContext.Value(serverRequestLoggedKey) == nil && isReadyForLogging(updatedContext, false) { - updatedContext = context.WithValue(updatedContext, serverRequestLoggedKey, true) - logRequest(updatedContext, request, serverPrefix, requestPrefix) - } - - // Actually call the next - rv, err := t.debugged.Request(updatedContext, request) - if err != nil && isReadyForLogging(ctx, false) { - lastError, ok := getServerRequestError(ctx) - if !ok || lastError == nil || err.Error() != (*lastError).Error() { - storeServerRequestError(ctx, &err) - return nil, logError(updatedContext, err, operation) - } - } - - return rv, err -} - -func (t *beginDebugServer) Close(ctx context.Context, conn *networkservice.Connection) (*empty.Empty, error) { - // Create a new logger - operation := typeutils.GetFuncName(t.debugged, methodNameClose) - updatedContext := withLog(ctx, conn.GetId()) - - if updatedContext.Value(serverCloseLoggedKey) == nil && isReadyForLogging(updatedContext, false) { - updatedContext = context.WithValue(updatedContext, serverCloseLoggedKey, true) - logRequest(updatedContext, conn, serverPrefix, closePrefix) - } - - // Actually call the next - rv, err := t.debugged.Close(updatedContext, conn) - if err != nil && isReadyForLogging(ctx, false) { - lastError, ok := getServerCloseError(ctx) - if !ok || lastError == nil || err.Error() != (*lastError).Error() { - storeServerCloseError(ctx, &err) - return nil, logError(updatedContext, err, operation) - } - } - - return rv, err -} - -func (t *endDebugServer) Request(ctx context.Context, request *networkservice.NetworkServiceRequest) (*networkservice.Connection, error) { - if isReadyForLogging(ctx, false) { - nextServer := next.Server(ctx) - withServerRequestTail(ctx, &nextServer) - - conn, err := nextServer.Request(ctx, request) - - tail, ok := serverRequestTail(ctx) - if ok && &nextServer == tail { - logResponse(ctx, conn, serverPrefix, requestPrefix) - } - - return conn, err - } - return next.Server(ctx).Request(ctx, request) -} - -func (t *endDebugServer) Close(ctx context.Context, conn *networkservice.Connection) (*empty.Empty, error) { - if isReadyForLogging(ctx, false) { - nextServer := next.Server(ctx) - withServerCloseTail(ctx, &nextServer) - - r, err := nextServer.Close(ctx, conn) - - tail, ok := serverCloseTail(ctx) - if ok && &nextServer == tail { - logResponse(ctx, conn, serverPrefix, closePrefix) - } - - return r, err - } - return next.Server(ctx).Close(ctx, conn) -} diff --git a/pkg/networkservice/core/trace/client.go b/pkg/networkservice/core/trace/client.go index 14aed7674..5c8e6c1a2 100644 --- a/pkg/networkservice/core/trace/client.go +++ b/pkg/networkservice/core/trace/client.go @@ -1,6 +1,4 @@ -// Copyright (c) 2020-2023 Cisco Systems, Inc. -// -// Copyright (c) 2021-2023 Doc.ai and/or its affiliates. +// Copyright (c) 2023 Cisco and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -16,76 +14,53 @@ // See the License for the specific language governing permissions and // limitations under the License. +// Package trace provides wrappers for tracing around a networkservice.NetworkServiceClient package trace import ( "context" + "github.com/sirupsen/logrus" + "github.com/golang/protobuf/ptypes/empty" "google.golang.org/grpc" "github.com/networkservicemesh/api/pkg/api/networkservice" "github.com/networkservicemesh/sdk/pkg/networkservice/core/next" - "github.com/networkservicemesh/sdk/pkg/tools/typeutils" + "github.com/networkservicemesh/sdk/pkg/networkservice/core/trace/traceconcise" + "github.com/networkservicemesh/sdk/pkg/networkservice/core/trace/traceverbose" ) -type beginTraceClient struct { - traced networkservice.NetworkServiceClient +type traceClient struct { + verbose networkservice.NetworkServiceClient + concise networkservice.NetworkServiceClient } -type endTraceClient struct{} - // NewNetworkServiceClient - wraps tracing around the supplied networkservice.NetworkServiceClient func NewNetworkServiceClient(traced networkservice.NetworkServiceClient) networkservice.NetworkServiceClient { - return next.NewNetworkServiceClient( - &beginTraceClient{traced: traced}, - &endTraceClient{}, - ) -} - -func (t *beginTraceClient) Request(ctx context.Context, request *networkservice.NetworkServiceRequest, opts ...grpc.CallOption) (*networkservice.Connection, error) { - // Create a new logger - operation := typeutils.GetFuncName(t.traced, methodNameRequest) - ctx, finish := withLog(ctx, operation, methodNameRequest, request.GetConnection().GetId()) - defer finish() - - logRequest(ctx, request, "request") - // Actually call the next - rv, err := t.traced.Request(ctx, request, opts...) - if err != nil { - return nil, logError(ctx, err, operation) + return &traceClient{ + verbose: traceverbose.NewNetworkServiceClient(traced), + concise: traceconcise.NewNetworkServiceClient(traced), } - logResponse(ctx, rv, "request") - return rv, err } -func (t *beginTraceClient) Close(ctx context.Context, conn *networkservice.Connection, opts ...grpc.CallOption) (*empty.Empty, error) { - // Create a new logger - operation := typeutils.GetFuncName(t.traced, methodNameClose) - ctx, finish := withLog(ctx, operation, methodNameClose, conn.GetId()) - defer finish() - - logRequest(ctx, conn, "close") - rv, err := t.traced.Close(ctx, conn, opts...) - if err != nil { - return nil, logError(ctx, err, operation) +func (t *traceClient) Request(ctx context.Context, request *networkservice.NetworkServiceRequest, opts ...grpc.CallOption) (*networkservice.Connection, error) { + switch logrus.GetLevel() { + case logrus.TraceLevel: + return t.verbose.Request(ctx, request, opts...) + case logrus.InfoLevel, logrus.DebugLevel: + return t.concise.Request(ctx, request, opts...) } - logResponse(ctx, conn, "close") - - return rv, err + return next.Client(ctx).Request(ctx, request, opts...) } -func (t *endTraceClient) Request(ctx context.Context, request *networkservice.NetworkServiceRequest, opts ...grpc.CallOption) (*networkservice.Connection, error) { - logRequest(ctx, request, "request") - conn, err := next.Client(ctx).Request(ctx, request, opts...) - logResponse(ctx, conn, "request") - return conn, err -} - -func (t *endTraceClient) Close(ctx context.Context, conn *networkservice.Connection, opts ...grpc.CallOption) (*empty.Empty, error) { - logRequest(ctx, conn, "close") - r, err := next.Client(ctx).Close(ctx, conn, opts...) - logResponse(ctx, conn, "close") - return r, err +func (t *traceClient) Close(ctx context.Context, conn *networkservice.Connection, opts ...grpc.CallOption) (*empty.Empty, error) { + switch logrus.GetLevel() { + case logrus.TraceLevel: + return t.verbose.Close(ctx, conn, opts...) + case logrus.InfoLevel, logrus.DebugLevel: + return t.verbose.Close(ctx, conn, opts...) + } + return next.Client(ctx).Close(ctx, conn, opts...) } diff --git a/pkg/networkservice/core/trace/server.go b/pkg/networkservice/core/trace/server.go index 218f5be4d..5c3127b3c 100644 --- a/pkg/networkservice/core/trace/server.go +++ b/pkg/networkservice/core/trace/server.go @@ -1,6 +1,4 @@ -// Copyright (c) 2020-2023 Cisco Systems, Inc. -// -// Copyright (c) 2021-2023 Doc.ai and/or its affiliates. +// Copyright (c) 2023 Cisco and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -21,69 +19,47 @@ package trace import ( "context" + "github.com/sirupsen/logrus" + + "github.com/networkservicemesh/sdk/pkg/networkservice/core/trace/traceconcise" + "github.com/networkservicemesh/sdk/pkg/networkservice/core/trace/traceverbose" + "github.com/golang/protobuf/ptypes/empty" "github.com/networkservicemesh/api/pkg/api/networkservice" "github.com/networkservicemesh/sdk/pkg/networkservice/core/next" - "github.com/networkservicemesh/sdk/pkg/tools/typeutils" ) -type beginTraceServer struct { - traced networkservice.NetworkServiceServer +type traceServer struct { + verbose networkservice.NetworkServiceServer + concise networkservice.NetworkServiceServer } -type endTraceServer struct{} - // NewNetworkServiceServer - wraps tracing around the supplied traced func NewNetworkServiceServer(traced networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { - return next.NewNetworkServiceServer( - &beginTraceServer{traced: traced}, - &endTraceServer{}, - ) -} - -func (t *beginTraceServer) Request(ctx context.Context, request *networkservice.NetworkServiceRequest) (*networkservice.Connection, error) { - // Create a new logger - operation := typeutils.GetFuncName(t.traced, methodNameRequest) - ctx, finish := withLog(ctx, operation, methodNameRequest, request.GetConnection().GetId()) - defer finish() - - logRequest(ctx, request, "request") - // Actually call the next - rv, err := t.traced.Request(ctx, request) - if err != nil { - return nil, logError(ctx, err, operation) + return &traceServer{ + verbose: traceverbose.NewNetworkServiceServer(traced), + concise: traceconcise.NewNetworkServiceServer(traced), } - logResponse(ctx, rv, "request") - return rv, err } -func (t *beginTraceServer) Close(ctx context.Context, conn *networkservice.Connection) (*empty.Empty, error) { - // Create a new logger - operation := typeutils.GetFuncName(t.traced, methodNameClose) - ctx, finish := withLog(ctx, operation, methodNameClose, conn.GetId()) - defer finish() - - logRequest(ctx, conn, "close") - rv, err := t.traced.Close(ctx, conn) - if err != nil { - return nil, logError(ctx, err, operation) +func (t *traceServer) Request(ctx context.Context, request *networkservice.NetworkServiceRequest) (*networkservice.Connection, error) { + switch logrus.GetLevel() { + case logrus.TraceLevel: + return t.verbose.Request(ctx, request) + case logrus.InfoLevel, logrus.DebugLevel: + return t.concise.Request(ctx, request) } - logResponse(ctx, conn, "close") - return rv, err + return next.Server(ctx).Request(ctx, request) } -func (t *endTraceServer) Request(ctx context.Context, request *networkservice.NetworkServiceRequest) (*networkservice.Connection, error) { - logRequest(ctx, request, "request") - conn, err := next.Server(ctx).Request(ctx, request) - logResponse(ctx, conn, "request") - return conn, err -} - -func (t *endTraceServer) Close(ctx context.Context, conn *networkservice.Connection) (*empty.Empty, error) { - logRequest(ctx, conn, "close") - r, err := next.Server(ctx).Close(ctx, conn) - logResponse(ctx, conn, "close") - return r, err +func (t *traceServer) Close(ctx context.Context, conn *networkservice.Connection) (*empty.Empty, error) { + switch logrus.GetLevel() { + case logrus.TraceLevel: + return t.verbose.Close(ctx, conn) + case logrus.InfoLevel, logrus.DebugLevel: + return t.concise.Close(ctx, conn) + } + return next.Server(ctx).Close(ctx, conn) } diff --git a/pkg/networkservice/core/testutil/testutil.go b/pkg/networkservice/core/trace/testutil/testutil.go similarity index 100% rename from pkg/networkservice/core/testutil/testutil.go rename to pkg/networkservice/core/trace/testutil/testutil.go diff --git a/pkg/networkservice/core/debug/README.md b/pkg/networkservice/core/trace/traceconcise/README.md similarity index 57% rename from pkg/networkservice/core/debug/README.md rename to pkg/networkservice/core/trace/traceconcise/README.md index 3fbed83da..731a39d50 100644 --- a/pkg/networkservice/core/debug/README.md +++ b/pkg/networkservice/core/trace/traceconcise/README.md @@ -1,6 +1,6 @@ -# Debug chain element +# Traceconcise chain element -The purpose of `debug` is to log server-client chain the following way: +The purpose of `traceconcise` is to log server-client chain the following way: 1. log server request 2. log client request diff --git a/pkg/networkservice/core/trace/traceconcise/client.go b/pkg/networkservice/core/trace/traceconcise/client.go new file mode 100644 index 000000000..a280c4250 --- /dev/null +++ b/pkg/networkservice/core/trace/traceconcise/client.go @@ -0,0 +1,129 @@ +// Copyright (c) 2023 Cisco and/or its affiliates. +// +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at: +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package traceconcise + +import ( + "context" + + "github.com/golang/protobuf/ptypes/empty" + "google.golang.org/grpc" + + "github.com/networkservicemesh/api/pkg/api/networkservice" + + "github.com/networkservicemesh/sdk/pkg/networkservice/core/next" + "github.com/networkservicemesh/sdk/pkg/tools/typeutils" +) + +type beginConciseClient struct { + traced networkservice.NetworkServiceClient +} + +type endConciseClient struct{} + +const ( + clientPrefix = "client" +) + +// NewNetworkServiceClient - wraps tracing around the supplied networkservice.NetworkServiceClient +func NewNetworkServiceClient(traced networkservice.NetworkServiceClient) networkservice.NetworkServiceClient { + return next.NewNetworkServiceClient( + &beginConciseClient{traced: traced}, + &endConciseClient{}, + ) +} + +func (t *beginConciseClient) Request(ctx context.Context, request *networkservice.NetworkServiceRequest, opts ...grpc.CallOption) (*networkservice.Connection, error) { + // Create a new logger + connID := request.GetConnection().GetId() + if request.GetConnection().GetPath() != nil && len(request.GetConnection().GetPath().GetPathSegments()) > 0 { + connID = request.GetConnection().GetPath().GetPathSegments()[0].GetId() + } + + var tail *networkservice.NetworkServiceClient + if ctx, tail = clientRequestTail(ctx); tail == nil { + var finish func() + ctx, finish = withLog(ctx, connID, methodNameRequest) + defer finish() + logRequest(ctx, request, clientPrefix, requestPrefix) + } + + // Actually call the next + rv, err := t.traced.Request(ctx, request, opts...) + if err != nil { + lastError := loadAndStoreClientRequestError(ctx, &err) + if lastError == nil || err.Error() != (*lastError).Error() { + operation := typeutils.GetFuncName(t.traced, methodNameRequest) + return nil, logError(ctx, err, operation) + } + } + + return rv, err +} + +func (t *beginConciseClient) Close(ctx context.Context, conn *networkservice.Connection, opts ...grpc.CallOption) (*empty.Empty, error) { + // Create a new logger + connID := conn.GetId() + if conn.GetPath() != nil && len(conn.GetPath().GetPathSegments()) > 0 { + connID = conn.GetPath().GetPathSegments()[0].GetId() + } + + var tail *networkservice.NetworkServiceClient + if ctx, tail = clientCloseTail(ctx); tail == nil { + var finish func() + ctx, finish = withLog(ctx, connID, methodNameClose) + defer finish() + logRequest(ctx, conn, clientPrefix, closePrefix) + } + + // Actually call the next + rv, err := t.traced.Close(ctx, conn, opts...) + if err != nil { + lastError := loadAndStoreClientCloseError(ctx, &err) + if lastError == nil || err.Error() != (*lastError).Error() { + operation := typeutils.GetFuncName(t.traced, methodNameClose) + return nil, logError(ctx, err, operation) + } + } + + return rv, err +} + +func (t *endConciseClient) Request(ctx context.Context, request *networkservice.NetworkServiceRequest, opts ...grpc.CallOption) (*networkservice.Connection, error) { + nextClient := next.Client(ctx) + ctx = withClientRequestTail(ctx, &nextClient) + + conn, err := nextClient.Request(ctx, request, opts...) + + var tail *networkservice.NetworkServiceClient + if ctx, tail = clientRequestTail(ctx); tail == &nextClient { + logResponse(ctx, conn, clientPrefix, requestPrefix) + } + return conn, err +} + +func (t *endConciseClient) Close(ctx context.Context, conn *networkservice.Connection, opts ...grpc.CallOption) (*empty.Empty, error) { + nextClient := next.Client(ctx) + ctx = withClientCloseTail(ctx, &nextClient) + + r, err := nextClient.Close(ctx, conn, opts...) + + var tail *networkservice.NetworkServiceClient + if ctx, tail = clientCloseTail(ctx); tail == &nextClient { + logResponse(ctx, conn, clientPrefix, closePrefix) + } + return r, err +} diff --git a/pkg/networkservice/core/debug/common.go b/pkg/networkservice/core/trace/traceconcise/common.go similarity index 77% rename from pkg/networkservice/core/debug/common.go rename to pkg/networkservice/core/trace/traceconcise/common.go index a470d5ad1..235c31fb1 100644 --- a/pkg/networkservice/core/debug/common.go +++ b/pkg/networkservice/core/trace/traceconcise/common.go @@ -1,4 +1,4 @@ -// Copyright (c) 2023 Doc.ai and/or its affiliates. +// Copyright (c) 2023 Cisco and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -14,7 +14,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -package debug +package traceconcise import ( "context" @@ -36,20 +36,25 @@ const ( func logRequest(ctx context.Context, request any, prefixes ...string) { msg := strings.Join(prefixes, "-") - logObjectDebug(ctx, msg, request) + logObject(ctx, msg, request) } func logResponse(ctx context.Context, response any, prefixes ...string) { msg := strings.Join(append(prefixes, "response"), "-") - logObjectDebug(ctx, msg, response) + logObject(ctx, msg, response) } func logError(ctx context.Context, err error, operation string) error { - log.FromContext(ctx).Errorf("%v", errors.Wrapf(err, "Error returned from %s", operation)) + if log.IsTracingEnabled() { + log.FromContext(ctx).Errorf("%v", errors.Wrapf(err, "Error returned from %s", operation)) + } return err } -func logObjectDebug(ctx context.Context, k, v interface{}) { +func logObject(ctx context.Context, k, v interface{}) { + if !log.IsTracingEnabled() { + return + } s := log.FromContext(ctx) msg := "" cc, err := json.Marshal(v) @@ -58,5 +63,5 @@ func logObjectDebug(ctx context.Context, k, v interface{}) { } else { msg = fmt.Sprint(v) } - s.Debugf("%v=%s", k, msg) + s.Infof("%v=%s", k, msg) } diff --git a/pkg/networkservice/core/debug/common_test.go b/pkg/networkservice/core/trace/traceconcise/common_test.go similarity index 79% rename from pkg/networkservice/core/debug/common_test.go rename to pkg/networkservice/core/trace/traceconcise/common_test.go index f868f7036..70f295920 100644 --- a/pkg/networkservice/core/debug/common_test.go +++ b/pkg/networkservice/core/trace/traceconcise/common_test.go @@ -1,6 +1,4 @@ -// Copyright (c) 2020 Cisco Systems, Inc. -// -// Copyright (c) 2021-2023 Doc.ai and/or its affiliates. +// Copyright (c) 2023 Cisco and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -16,8 +14,8 @@ // See the License for the specific language governing permissions and // limitations under the License. -// Package debug_test has few tests for logs in debug mode -package debug_test +// Package traceconcise_test has few tests for logs in concise mode +package traceconcise_test import ( "bytes" @@ -29,11 +27,11 @@ import ( "github.com/stretchr/testify/require" "github.com/networkservicemesh/sdk/pkg/networkservice/core/chain" - "github.com/networkservicemesh/sdk/pkg/networkservice/core/testutil" - "github.com/networkservicemesh/sdk/pkg/networkservice/utils/metadata" + "github.com/networkservicemesh/sdk/pkg/networkservice/core/trace/testutil" + "github.com/networkservicemesh/sdk/pkg/tools/log" ) -func TestDebugOutput(t *testing.T) { +func TestOutput(t *testing.T) { // Configure logging // Set output to buffer var buff bytes.Buffer @@ -41,11 +39,11 @@ func TestDebugOutput(t *testing.T) { logrus.SetFormatter(&logrus.TextFormatter{ DisableTimestamp: true, }) - logrus.SetLevel(logrus.DebugLevel) + log.EnableTracing(true) + logrus.SetLevel(logrus.InfoLevel) // Create a chain with modifying elements ch := chain.NewNetworkServiceServer( - metadata.NewServer(), &testutil.LabelChangerFirstServer{}, &testutil.LabelChangerSecondServer{}, ) @@ -61,15 +59,14 @@ func TestDebugOutput(t *testing.T) { require.NotNil(t, e) expectedOutput := - "\x1b[37m [DEBU] [id:conn-1] [type:networkService] \x1b[0mserver-request={\"connection\":" + + "\x1b[36m [INFO] [id:conn-1] [type:networkService] \x1b[0mserver-request={\"connection\":" + "{\"id\":\"conn-1\",\"context\":{\"ip_context\":{\"src_ip_required\":true}}},\"mechanism_preferences\":" + "[{\"cls\":\"LOCAL\",\"type\":\"KERNEL\"},{\"cls\":\"LOCAL\",\"type\":\"KERNEL\",\"parameters\":{\"label\":\"v2\"}}]}" + - "\n\x1b[37m [DEBU] [id:conn-1] [type:networkService] \x1b[0mserver-request-response={\"id\":\"conn-1\",\"context\":" + + "\n\x1b[36m [INFO] [id:conn-1] [type:networkService] \x1b[0mserver-request-response={\"id\":\"conn-1\",\"context\":" + "{\"ip_context\":{\"src_ip_required\":true}},\"labels\":{\"Label\":\"B\"}}" + - "\n\x1b[37m [DEBU] [id:conn-1] [connID:conn-1] [metadata:server] [type:networkService] \x1b[0mmetadata deleted" + - "\n\x1b[37m [DEBU] [id:conn-1] [type:networkService] \x1b[0mserver-close={\"id\":\"conn-1\",\"context\":{\"ip_context\":" + + "\n\x1b[36m [INFO] [id:conn-1] [type:networkService] \x1b[0mserver-close={\"id\":\"conn-1\",\"context\":{\"ip_context\":" + "{\"src_ip_required\":true}},\"labels\":{\"Label\":\"D\"}}" + - "\n\x1b[37m [DEBU] [id:conn-1] [type:networkService] \x1b[0mserver-close-response={\"id\":\"conn-1\",\"context\":" + + "\n\x1b[36m [INFO] [id:conn-1] [type:networkService] \x1b[0mserver-close-response={\"id\":\"conn-1\",\"context\":" + "{\"ip_context\":{\"src_ip_required\":true}},\"labels\":{\"Label\":\"X\"}}\n" result := testutil.TrimLogTime(&buff) @@ -85,11 +82,11 @@ func TestErrorOutput(t *testing.T) { logrus.SetFormatter(&logrus.TextFormatter{ DisableTimestamp: true, }) - logrus.SetLevel(logrus.DebugLevel) + log.EnableTracing(true) + logrus.SetLevel(logrus.InfoLevel) // Create a chain with modifying elements ch := chain.NewNetworkServiceServer( - metadata.NewServer(), &testutil.LabelChangerFirstServer{}, &testutil.LabelChangerSecondServer{}, &testutil.ErrorServer{}, @@ -102,12 +99,12 @@ func TestErrorOutput(t *testing.T) { require.Nil(t, conn) expectedOutput := - "\x1b[37m [DEBU] [id:conn-1] [type:networkService] \x1b[0mserver-request={\"connection\":" + + "\x1b[36m [INFO] [id:conn-1] [type:networkService] \x1b[0mserver-request={\"connection\":" + "{\"id\":\"conn-1\",\"context\":{\"ip_context\":{\"src_ip_required\":true}}},\"mechanism_preferences\":" + "[{\"cls\":\"LOCAL\",\"type\":\"KERNEL\"},{\"cls\":\"LOCAL\",\"type\":\"KERNEL\",\"parameters\":{\"label\":\"v2\"}}]}\n" + - "\x1b[37m [DEBU] [id:conn-1] [type:networkService] \x1b[0mserver-request-response={\"id\":\"conn-1\",\"context\":" + + "\x1b[36m [INFO] [id:conn-1] [type:networkService] \x1b[0mserver-request-response={\"id\":\"conn-1\",\"context\":" + "{\"ip_context\":{\"src_ip_required\":true}},\"labels\":{\"Label\":\"B\"}}\n" + - "\x1b[31m [ERRO] [id:conn-1] [type:networkService] \x1b[0mError returned from sdk/pkg/networkservice/core/testutil/ErrorServer.Request:" + + "\x1b[31m [ERRO] [id:conn-1] [type:networkService] \x1b[0mError returned from sdk/pkg/networkservice/core/trace/testutil/ErrorServer.Request:" + " Error returned from api/pkg/api/networkservice/networkServiceClient.Close;" + "\tgithub.com/networkservicemesh/sdk/pkg/networkservice/core/trace.(*beginTraceClient).Close;" + "\t\t/root/go/pkg/mod/github.com/networkservicemesh/sdk@v0.5.1-0.20210929180427-ec235de055f1/pkg/networkservice/core/trace/client.go:85;" + @@ -118,8 +115,7 @@ func TestErrorOutput(t *testing.T) { "\tgithub.com/networkservicemesh/sdk/pkg/networkservice/core/trace.(*endTraceClient).Close;" + "\t\t/root/go/pkg/mod/github.com/networkservicemesh/sdk@v0.5.1-0.20210929180427-ec235de055f1/pkg/networkservice/core/trace/client.go:106;" + "\tgithub.com/networkservicemesh/sdk/pkg/networkservice/core/next.(*nextClient).Close;" + - "\t\t/root/go/pkg/mod/github.com/networkservicemesh/sdk@v0.5.1-0.20210929180427-ec235de055f1/pkg/networkservice/core/next/client.go:65;\t\n" + - "\x1b[37m [DEBU] [id:conn-1] [connID:conn-1] [metadata:server] [type:networkService] \x1b[0mmetadata deleted\n" + "\t\t/root/go/pkg/mod/github.com/networkservicemesh/sdk@v0.5.1-0.20210929180427-ec235de055f1/pkg/networkservice/core/next/client.go:65;\t\n" result := testutil.TrimLogTime(&buff) require.Equal(t, expectedOutput, result) diff --git a/pkg/networkservice/core/trace/traceconcise/context.go b/pkg/networkservice/core/trace/traceconcise/context.go new file mode 100644 index 000000000..17e0d271d --- /dev/null +++ b/pkg/networkservice/core/trace/traceconcise/context.go @@ -0,0 +1,154 @@ +// Copyright (c) 2023 Cisco and/or its affiliates. +// +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at: +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package traceconcise provides a wrapper for logging around a networkservice.NetworkServiceClient +package traceconcise + +import ( + "context" + + "github.com/networkservicemesh/sdk/pkg/tools/grpcutils" + "github.com/networkservicemesh/sdk/pkg/tools/log/spanlogger" + + "github.com/networkservicemesh/api/pkg/api/networkservice" + + "github.com/networkservicemesh/sdk/pkg/tools/log" + "github.com/networkservicemesh/sdk/pkg/tools/log/logruslogger" +) + +type contextKeyType string + +const ( + conciseInfoKey contextKeyType = "conciseInfoLogNetworkservice" + loggedType string = "networkService" +) + +type conciseInfo struct { + serverRequestTail *networkservice.NetworkServiceServer + serverCloseTail *networkservice.NetworkServiceServer + clientRequestTail *networkservice.NetworkServiceClient + clientCloseTail *networkservice.NetworkServiceClient + + serverRequestError *error + serverCloseError *error + clientRequestError *error + clientCloseError *error +} + +func withLog(parent context.Context, connectionID, methodName string) (c context.Context, f func()) { + if parent == nil { + panic("cannot create context from nil parent") + } + + // Update outgoing grpc context + parent = grpcutils.PassTraceToOutgoing(parent) + + fields := []*log.Field{log.NewField("id", connectionID), log.NewField("type", loggedType)} + + ctx, sLogger, span, sFinish := spanlogger.FromContext(parent, "", methodName, fields) + ctx, lLogger, lFinish := logruslogger.FromSpan(ctx, span, "", fields) + ctx = log.WithLog(ctx, sLogger, lLogger) + + return ctx, func() { + sFinish() + lFinish() + } +} + +func conciseInfoFromCtx(ctx context.Context) (context.Context, *conciseInfo) { + if ctx == nil { + panic("cannot create context from nil parent") + } + + v, ok := ctx.Value(conciseInfoKey).(*conciseInfo) + if ok { + return ctx, v + } + v = new(conciseInfo) + return context.WithValue(ctx, conciseInfoKey, v), v +} + +func withServerRequestTail(ctx context.Context, server *networkservice.NetworkServiceServer) context.Context { + c, d := conciseInfoFromCtx(ctx) + d.serverRequestTail = server + return c +} + +func serverRequestTail(ctx context.Context) (context.Context, *networkservice.NetworkServiceServer) { + c, d := conciseInfoFromCtx(ctx) + return c, d.serverRequestTail +} + +func withServerCloseTail(ctx context.Context, server *networkservice.NetworkServiceServer) context.Context { + c, d := conciseInfoFromCtx(ctx) + d.serverCloseTail = server + return c +} + +func serverCloseTail(ctx context.Context) (context.Context, *networkservice.NetworkServiceServer) { + c, d := conciseInfoFromCtx(ctx) + return c, d.serverCloseTail +} + +func withClientRequestTail(ctx context.Context, client *networkservice.NetworkServiceClient) context.Context { + c, d := conciseInfoFromCtx(ctx) + d.clientRequestTail = client + return c +} + +func clientRequestTail(ctx context.Context) (context.Context, *networkservice.NetworkServiceClient) { + c, d := conciseInfoFromCtx(ctx) + return c, d.clientRequestTail +} + +func withClientCloseTail(ctx context.Context, client *networkservice.NetworkServiceClient) context.Context { + c, d := conciseInfoFromCtx(ctx) + d.clientCloseTail = client + return c +} + +func clientCloseTail(ctx context.Context) (context.Context, *networkservice.NetworkServiceClient) { + c, d := conciseInfoFromCtx(ctx) + return c, d.clientCloseTail +} + +func loadAndStoreServerRequestError(ctx context.Context, err *error) (prevErr *error) { + _, d := conciseInfoFromCtx(ctx) + prevErr = d.serverRequestError + d.serverRequestError = err + return prevErr +} + +func loadAndStoreServerCloseError(ctx context.Context, err *error) (prevErr *error) { + _, d := conciseInfoFromCtx(ctx) + prevErr = d.serverCloseError + d.serverCloseError = err + return prevErr +} + +func loadAndStoreClientRequestError(ctx context.Context, err *error) (prevErr *error) { + _, d := conciseInfoFromCtx(ctx) + prevErr = d.clientRequestError + d.clientRequestError = err + return prevErr +} + +func loadAndStoreClientCloseError(ctx context.Context, err *error) (prevErr *error) { + _, d := conciseInfoFromCtx(ctx) + prevErr = d.clientCloseError + d.clientCloseError = err + return prevErr +} diff --git a/pkg/networkservice/core/trace/traceconcise/server.go b/pkg/networkservice/core/trace/traceconcise/server.go new file mode 100644 index 000000000..261dfc465 --- /dev/null +++ b/pkg/networkservice/core/trace/traceconcise/server.go @@ -0,0 +1,129 @@ +// Copyright (c) 2023 Cisco and/or its affiliates. +// +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at: +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package traceconcise + +import ( + "context" + + "github.com/golang/protobuf/ptypes/empty" + + "github.com/networkservicemesh/api/pkg/api/networkservice" + + "github.com/networkservicemesh/sdk/pkg/networkservice/core/next" + "github.com/networkservicemesh/sdk/pkg/tools/typeutils" +) + +type beginConciseServer struct { + traced networkservice.NetworkServiceServer +} + +type endConciseServer struct{} + +const ( + serverPrefix = "server" +) + +// NewNetworkServiceServer - wraps tracing around the supplied traced +func NewNetworkServiceServer(traced networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { + return next.NewNetworkServiceServer( + &beginConciseServer{traced: traced}, + &endConciseServer{}, + ) +} + +func (t *beginConciseServer) Request(ctx context.Context, request *networkservice.NetworkServiceRequest) (*networkservice.Connection, error) { + // Create a new logger + connID := request.GetConnection().GetId() + if request.GetConnection().GetPath() != nil && len(request.GetConnection().GetPath().GetPathSegments()) > 0 { + connID = request.GetConnection().GetPath().GetPathSegments()[0].GetId() + } + + var tail *networkservice.NetworkServiceServer + if ctx, tail = serverRequestTail(ctx); tail == nil { + var finish func() + ctx, finish = withLog(ctx, connID, methodNameRequest) + defer finish() + logRequest(ctx, request, serverPrefix, requestPrefix) + } + + // Actually call the next + rv, err := t.traced.Request(ctx, request) + if err != nil { + lastError := loadAndStoreServerRequestError(ctx, &err) + if lastError == nil || err.Error() != (*lastError).Error() { + operation := typeutils.GetFuncName(t.traced, methodNameRequest) + return nil, logError(ctx, err, operation) + } + } + + return rv, err +} + +func (t *beginConciseServer) Close(ctx context.Context, conn *networkservice.Connection) (*empty.Empty, error) { + // Create a new logger + connID := conn.GetId() + if conn.GetPath() != nil && len(conn.GetPath().GetPathSegments()) > 0 { + connID = conn.GetPath().GetPathSegments()[0].GetId() + } + + var tail *networkservice.NetworkServiceServer + if ctx, tail = serverCloseTail(ctx); tail == nil { + var finish func() + ctx, finish = withLog(ctx, connID, methodNameClose) + defer finish() + + logRequest(ctx, conn, serverPrefix, closePrefix) + } + + // Actually call the next + rv, err := t.traced.Close(ctx, conn) + if err != nil { + lastError := loadAndStoreServerCloseError(ctx, &err) + if lastError == nil || err.Error() != (*lastError).Error() { + operation := typeutils.GetFuncName(t.traced, methodNameClose) + return nil, logError(ctx, err, operation) + } + } + + return rv, err +} + +func (t *endConciseServer) Request(ctx context.Context, request *networkservice.NetworkServiceRequest) (*networkservice.Connection, error) { + nextServer := next.Server(ctx) + ctx = withServerRequestTail(ctx, &nextServer) + + conn, err := nextServer.Request(ctx, request) + + var tail *networkservice.NetworkServiceServer + if ctx, tail = serverRequestTail(ctx); tail == &nextServer { + logResponse(ctx, conn, serverPrefix, requestPrefix) + } + return conn, err +} + +func (t *endConciseServer) Close(ctx context.Context, conn *networkservice.Connection) (*empty.Empty, error) { + nextServer := next.Server(ctx) + ctx = withServerCloseTail(ctx, &nextServer) + + r, err := nextServer.Close(ctx, conn) + + var tail *networkservice.NetworkServiceServer + if ctx, tail = serverCloseTail(ctx); tail == &nextServer { + logResponse(ctx, conn, serverPrefix, closePrefix) + } + return r, err +} diff --git a/pkg/networkservice/core/trace/README.md b/pkg/networkservice/core/trace/traceverbose/README.md similarity index 100% rename from pkg/networkservice/core/trace/README.md rename to pkg/networkservice/core/trace/traceverbose/README.md diff --git a/pkg/networkservice/core/trace/traceverbose/client.go b/pkg/networkservice/core/trace/traceverbose/client.go new file mode 100644 index 000000000..b22219a8d --- /dev/null +++ b/pkg/networkservice/core/trace/traceverbose/client.go @@ -0,0 +1,91 @@ +// Copyright (c) 2020-2023 Cisco Systems, Inc. +// +// Copyright (c) 2021-2023 Doc.ai and/or its affiliates. +// +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at: +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package traceverbose + +import ( + "context" + + "github.com/golang/protobuf/ptypes/empty" + "google.golang.org/grpc" + + "github.com/networkservicemesh/api/pkg/api/networkservice" + + "github.com/networkservicemesh/sdk/pkg/networkservice/core/next" + "github.com/networkservicemesh/sdk/pkg/tools/typeutils" +) + +type beginTraceClient struct { + traced networkservice.NetworkServiceClient +} + +type endTraceClient struct{} + +// NewNetworkServiceClient - wraps tracing around the supplied networkservice.NetworkServiceClient +func NewNetworkServiceClient(traced networkservice.NetworkServiceClient) networkservice.NetworkServiceClient { + return next.NewNetworkServiceClient( + &beginTraceClient{traced: traced}, + &endTraceClient{}, + ) +} + +func (t *beginTraceClient) Request(ctx context.Context, request *networkservice.NetworkServiceRequest, opts ...grpc.CallOption) (*networkservice.Connection, error) { + // Create a new logger + operation := typeutils.GetFuncName(t.traced, methodNameRequest) + ctx, finish := withLog(ctx, operation, methodNameRequest, request.GetConnection().GetId()) + defer finish() + + logRequest(ctx, request, "request") + // Actually call the next + rv, err := t.traced.Request(ctx, request, opts...) + if err != nil { + return nil, logError(ctx, err, operation) + } + logResponse(ctx, rv, "request") + return rv, err +} + +func (t *beginTraceClient) Close(ctx context.Context, conn *networkservice.Connection, opts ...grpc.CallOption) (*empty.Empty, error) { + // Create a new logger + operation := typeutils.GetFuncName(t.traced, methodNameClose) + ctx, finish := withLog(ctx, operation, methodNameClose, conn.GetId()) + defer finish() + + logRequest(ctx, conn, "close") + rv, err := t.traced.Close(ctx, conn, opts...) + if err != nil { + return nil, logError(ctx, err, operation) + } + logResponse(ctx, conn, "close") + + return rv, err +} + +func (t *endTraceClient) Request(ctx context.Context, request *networkservice.NetworkServiceRequest, opts ...grpc.CallOption) (*networkservice.Connection, error) { + logRequest(ctx, request, "request") + conn, err := next.Client(ctx).Request(ctx, request, opts...) + logResponse(ctx, conn, "request") + return conn, err +} + +func (t *endTraceClient) Close(ctx context.Context, conn *networkservice.Connection, opts ...grpc.CallOption) (*empty.Empty, error) { + logRequest(ctx, conn, "close") + r, err := next.Client(ctx).Close(ctx, conn, opts...) + logResponse(ctx, conn, "close") + return r, err +} diff --git a/pkg/networkservice/core/trace/common.go b/pkg/networkservice/core/trace/traceverbose/common.go similarity index 99% rename from pkg/networkservice/core/trace/common.go rename to pkg/networkservice/core/trace/traceverbose/common.go index df4debfd2..cd5fc66e3 100644 --- a/pkg/networkservice/core/trace/common.go +++ b/pkg/networkservice/core/trace/traceverbose/common.go @@ -16,7 +16,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -package trace +package traceverbose import ( "context" diff --git a/pkg/networkservice/core/trace/common_test.go b/pkg/networkservice/core/trace/traceverbose/common_test.go similarity index 91% rename from pkg/networkservice/core/trace/common_test.go rename to pkg/networkservice/core/trace/traceverbose/common_test.go index b7a25c036..0d9fc66f1 100644 --- a/pkg/networkservice/core/trace/common_test.go +++ b/pkg/networkservice/core/trace/traceverbose/common_test.go @@ -1,4 +1,4 @@ -// Copyright (c) 2020 Cisco Systems, Inc. +// Copyright (c) 2020-2023 Cisco Systems, Inc. // // Copyright (c) 2021-2023 Doc.ai and/or its affiliates. // @@ -17,12 +17,13 @@ // limitations under the License. // Package trace_test has few tests for tracing diffs -package trace_test +package traceverbose_test import ( "bytes" "context" "encoding/json" + "testing" "github.com/sirupsen/logrus" @@ -31,8 +32,8 @@ import ( "github.com/stretchr/testify/require" "github.com/networkservicemesh/sdk/pkg/networkservice/core/chain" - "github.com/networkservicemesh/sdk/pkg/networkservice/core/testutil" - "github.com/networkservicemesh/sdk/pkg/networkservice/core/trace" + "github.com/networkservicemesh/sdk/pkg/networkservice/core/trace/testutil" + "github.com/networkservicemesh/sdk/pkg/networkservice/core/trace/traceverbose" "github.com/networkservicemesh/sdk/pkg/tools/log" ) @@ -40,7 +41,7 @@ func TestDiffMechanism(t *testing.T) { c1 := testutil.NewConnection() c2 := testutil.NewConnection() c2.MechanismPreferences[1].Type = "MEMIF" - diffMsg, diff := trace.Diff(c1.ProtoReflect(), c2.ProtoReflect()) + diffMsg, diff := traceverbose.Diff(c1.ProtoReflect(), c2.ProtoReflect()) jsonOut, _ := json.Marshal(diffMsg) require.Equal(t, `{"mechanism_preferences":{"1":{"type":"MEMIF"}}}`, string(jsonOut)) require.True(t, diff) @@ -53,7 +54,7 @@ func TestDiffLabels(t *testing.T) { "label": "v3", "label2": "v4", } - diffMsg, diff := trace.Diff(c1.ProtoReflect(), c2.ProtoReflect()) + diffMsg, diff := traceverbose.Diff(c1.ProtoReflect(), c2.ProtoReflect()) jsonOut, _ := json.Marshal(diffMsg) require.Equal(t, `{"mechanism_preferences":{"1":{"parameters":{"+label2":"v4","label":"v3"}}}}`, string(jsonOut)) require.True(t, diff) @@ -70,7 +71,7 @@ func TestDiffPath(t *testing.T) { }, } - diffMsg, diff := trace.Diff(c1.ProtoReflect(), c2.ProtoReflect()) + diffMsg, diff := traceverbose.Diff(c1.ProtoReflect(), c2.ProtoReflect()) jsonOut, _ := json.Marshal(diffMsg) require.Equal(t, `{"connection":{"path":{"path_segments":{"-0":{"id":"id1","token":"t1"}}}}}`, string(jsonOut)) require.True(t, diff) @@ -94,7 +95,7 @@ func TestDiffPathAdd(t *testing.T) { }, } - diffMsg, diff := trace.Diff(c1.ProtoReflect(), c2.ProtoReflect()) + diffMsg, diff := traceverbose.Diff(c1.ProtoReflect(), c2.ProtoReflect()) jsonOut, _ := json.Marshal(diffMsg) require.Equal(t, `{"connection":{"path":{"path_segments":{"+1":{"id":"id2","token":"t2"}}}}}`, string(jsonOut)) require.True(t, diff) @@ -128,23 +129,23 @@ func TestTraceOutput(t *testing.T) { require.NotNil(t, e) expectedOutput := - "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(1) ⎆ sdk/pkg/networkservice/core/testutil/LabelChangerFirstServer.Request()\n" + + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(1) ⎆ sdk/pkg/networkservice/core/trace/testutil/LabelChangerFirstServer.Request()\n" + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(1.1) request={\"connection\":{\"id\":\"conn-1\",\"context\":" + "{\"ip_context\":{\"src_ip_required\":true}}},\"mechanism_preferences\":[{\"cls\":\"LOCAL\"," + "\"type\":\"KERNEL\"},{\"cls\":\"LOCAL\",\"type\":\"KERNEL\",\"parameters\":{\"label\"" + ":\"v2\"}}]}\n" + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(1.2) request-diff={\"connection\":{\"labels\":{\"+Label\":\"A\"}}}\n" + - "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(2) ⎆ sdk/pkg/networkservice/core/testutil/LabelChangerSecondServer.Request()\n" + + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(2) ⎆ sdk/pkg/networkservice/core/trace/testutil/LabelChangerSecondServer.Request()\n" + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(2.1) request-diff={\"connection\":{\"labels\":{\"Label\":\"B\"}}}\n" + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(2.2) request-response={\"id\":\"conn-1\",\"context\":{\"ip_context\":{\"src_ip_required\":true}}," + "\"labels\":{\"Label\":\"B\"}}\n" + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(2.3) request-response-diff={\"labels\":{\"Label\":\"C\"}}\n" + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(1.3) request-response-diff={\"labels\":{\"Label\":\"D\"}}\n" + - "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(1) ⎆ sdk/pkg/networkservice/core/testutil/LabelChangerFirstServer.Close()\n" + + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(1) ⎆ sdk/pkg/networkservice/core/trace/testutil/LabelChangerFirstServer.Close()\n" + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(1.1) close={\"id\":\"conn-1\",\"context\":{\"ip_context\":{\"src_ip_required\":true}}," + "\"labels\":{\"Label\":\"D\"}}\n" + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(1.2) close-diff={\"labels\":{\"Label\":\"W\"}}\n" + - "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(2) ⎆ sdk/pkg/networkservice/core/testutil/LabelChangerSecondServer.Close()\n" + + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(2) ⎆ sdk/pkg/networkservice/core/trace/testutil/LabelChangerSecondServer.Close()\n" + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(2.1) close-diff={\"labels\":{\"Label\":\"X\"}}\n" + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(2.2) close-response={\"id\":\"conn-1\",\"context\":{\"ip_context\":{\"src_ip_required\"" + ":true}},\"labels\":{\"Label\":\"X\"}}\n" + @@ -180,15 +181,15 @@ func TestErrorOutput(t *testing.T) { require.Nil(t, conn) expectedOutput := - "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(1) ⎆ sdk/pkg/networkservice/core/testutil/LabelChangerFirstServer.Request()\n" + + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(1) ⎆ sdk/pkg/networkservice/core/trace/testutil/LabelChangerFirstServer.Request()\n" + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(1.1) request={\"connection\":{\"id\":\"conn-1\",\"context\":" + "{\"ip_context\":{\"src_ip_required\":true}}},\"mechanism_preferences\":[{\"cls\":\"LOCAL\"," + "\"type\":\"KERNEL\"},{\"cls\":\"LOCAL\",\"type\":\"KERNEL\",\"parameters\":{\"label\"" + ":\"v2\"}}]}\n" + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(1.2) request-diff={\"connection\":{\"labels\":{\"+Label\":\"A\"}}}\n" + - "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(2) ⎆ sdk/pkg/networkservice/core/testutil/LabelChangerSecondServer.Request()\n" + + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(2) ⎆ sdk/pkg/networkservice/core/trace/testutil/LabelChangerSecondServer.Request()\n" + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(2.1) request-diff={\"connection\":{\"labels\":{\"Label\":\"B\"}}}\n" + - "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(3) ⎆ sdk/pkg/networkservice/core/testutil/ErrorServer.Request()\n" + + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(3) ⎆ sdk/pkg/networkservice/core/trace/testutil/ErrorServer.Request()\n" + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(3.1) request-response={\"id\":\"conn-1\",\"context\":{\"ip_context\":{\"src_ip_required\":true}},\"labels\":{\"Label\":\"B\"}}\n" + "\x1b[31m [ERRO] [id:conn-1] [type:networkService] \x1b[0m(3.2) Error returned from api/pkg/api/networkservice/networkServiceClient.Close;\tgithub.com/networkservicemesh/sdk/pkg/networkservice/core/trace.(*beginTraceClient).Close;\t\t/root/go/pkg/mod/github.com/networkservicemesh/sdk@v0.5.1-0.20210929180427-ec235de055f1/pkg/networkservice/core/trace/client.go:85;\tgithub.com/networkservicemesh/sdk/pkg/networkservice/core/next.(*nextClient).Close;\t\t/root/go/pkg/mod/github.com/networkservicemesh/sdk@v0.5.1-0.20210929180427-ec235de055f1/pkg/networkservice/core/next/client.go:65;\tgithub.com/networkservicemesh/sdk/pkg/networkservice/core/next.(*nextClient).Close;\t\t/root/go/pkg/mod/github.com/networkservicemesh/sdk@v0.5.1-0.20210929180427-ec235de055f1/pkg/networkservice/core/next/client.go:65;\tgithub.com/networkservicemesh/sdk/pkg/networkservice/core/trace.(*endTraceClient).Close;\t\t/root/go/pkg/mod/github.com/networkservicemesh/sdk@v0.5.1-0.20210929180427-ec235de055f1/pkg/networkservice/core/trace/client.go:106;\tgithub.com/networkservicemesh/sdk/pkg/networkservice/core/next.(*nextClient).Close;\t\t/root/go/pkg/mod/github.com/networkservicemesh/sdk@v0.5.1-0.20210929180427-ec235de055f1/pkg/networkservice/core/next/client.go:65;\t\n" + "\x1b[37m [TRAC] [id:conn-1] [type:networkService] \x1b[0m(2.2) request-response-diff={\"context\":{\"ip_context\":{\"src_ip_required\":false}},\"id\":\"\",\"labels\":{\"-Label\":\"B\"}}\n" + diff --git a/pkg/networkservice/core/trace/context.go b/pkg/networkservice/core/trace/traceverbose/context.go similarity index 95% rename from pkg/networkservice/core/trace/context.go rename to pkg/networkservice/core/trace/traceverbose/context.go index c60d35755..148f3a82d 100644 --- a/pkg/networkservice/core/trace/context.go +++ b/pkg/networkservice/core/trace/traceverbose/context.go @@ -16,8 +16,8 @@ // See the License for the specific language governing permissions and // limitations under the License. -// Package trace provides a wrapper for tracing around a networkservice.NetworkServiceClient -package trace +// Package traceverbose provides a wrapper for tracing around a networkservice.NetworkServiceClient +package traceverbose import ( "context" diff --git a/pkg/networkservice/core/trace/traceverbose/server.go b/pkg/networkservice/core/trace/traceverbose/server.go new file mode 100644 index 000000000..d444d6c2c --- /dev/null +++ b/pkg/networkservice/core/trace/traceverbose/server.go @@ -0,0 +1,89 @@ +// Copyright (c) 2020-2023 Cisco Systems, Inc. +// +// Copyright (c) 2021-2023 Doc.ai and/or its affiliates. +// +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at: +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package traceverbose + +import ( + "context" + + "github.com/golang/protobuf/ptypes/empty" + + "github.com/networkservicemesh/api/pkg/api/networkservice" + + "github.com/networkservicemesh/sdk/pkg/networkservice/core/next" + "github.com/networkservicemesh/sdk/pkg/tools/typeutils" +) + +type beginTraceServer struct { + traced networkservice.NetworkServiceServer +} + +type endTraceServer struct{} + +// NewNetworkServiceServer - wraps tracing around the supplied traced +func NewNetworkServiceServer(traced networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { + return next.NewNetworkServiceServer( + &beginTraceServer{traced: traced}, + &endTraceServer{}, + ) +} + +func (t *beginTraceServer) Request(ctx context.Context, request *networkservice.NetworkServiceRequest) (*networkservice.Connection, error) { + // Create a new logger + operation := typeutils.GetFuncName(t.traced, methodNameRequest) + ctx, finish := withLog(ctx, operation, methodNameRequest, request.GetConnection().GetId()) + defer finish() + + logRequest(ctx, request, "request") + // Actually call the next + rv, err := t.traced.Request(ctx, request) + if err != nil { + return nil, logError(ctx, err, operation) + } + logResponse(ctx, rv, "request") + return rv, err +} + +func (t *beginTraceServer) Close(ctx context.Context, conn *networkservice.Connection) (*empty.Empty, error) { + // Create a new logger + operation := typeutils.GetFuncName(t.traced, methodNameClose) + ctx, finish := withLog(ctx, operation, methodNameClose, conn.GetId()) + defer finish() + + logRequest(ctx, conn, "close") + rv, err := t.traced.Close(ctx, conn) + if err != nil { + return nil, logError(ctx, err, operation) + } + logResponse(ctx, conn, "close") + return rv, err +} + +func (t *endTraceServer) Request(ctx context.Context, request *networkservice.NetworkServiceRequest) (*networkservice.Connection, error) { + logRequest(ctx, request, "request") + conn, err := next.Server(ctx).Request(ctx, request) + logResponse(ctx, conn, "request") + return conn, err +} + +func (t *endTraceServer) Close(ctx context.Context, conn *networkservice.Connection) (*empty.Empty, error) { + logRequest(ctx, conn, "close") + r, err := next.Server(ctx).Close(ctx, conn) + logResponse(ctx, conn, "close") + return r, err +} diff --git a/pkg/networkservice/ipam/groupipam/server.go b/pkg/networkservice/ipam/groupipam/server.go index f864ac5d9..c71e11bfd 100644 --- a/pkg/networkservice/ipam/groupipam/server.go +++ b/pkg/networkservice/ipam/groupipam/server.go @@ -26,7 +26,6 @@ import ( "github.com/networkservicemesh/sdk/pkg/networkservice/core/chain" "github.com/networkservicemesh/sdk/pkg/networkservice/ipam/point2pointipam" - "github.com/networkservicemesh/sdk/pkg/networkservice/utils/metadata" ) type options struct { @@ -52,8 +51,6 @@ func WithCustomIPAMServer(f func(...*net.IPNet) networkservice.NetworkServiceSer // Options can be passed optionally func NewServer(groups [][]*net.IPNet, opts ...Option) networkservice.NetworkServiceServer { var ipamServers []networkservice.NetworkServiceServer - ipamServers = append(ipamServers, metadata.NewServer()) - var o = options{ newIPAMServerFn: point2pointipam.NewServer, } diff --git a/pkg/networkservice/utils/checks/checkerror/check_propogate_error.go b/pkg/networkservice/utils/checks/checkerror/check_propogate_error.go index ac8338231..0011edb45 100644 --- a/pkg/networkservice/utils/checks/checkerror/check_propogate_error.go +++ b/pkg/networkservice/utils/checks/checkerror/check_propogate_error.go @@ -1,4 +1,4 @@ -// Copyright (c) 2020-2023 Cisco and/or its affiliates. +// Copyright (c) 2020 Cisco and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -24,13 +24,11 @@ import ( "github.com/networkservicemesh/sdk/pkg/networkservice/core/chain" "github.com/networkservicemesh/sdk/pkg/networkservice/utils/inject/injecterror" - "github.com/networkservicemesh/sdk/pkg/networkservice/utils/metadata" ) // CheckPropagatesErrorClient - NetworkServiceClient that will check to see if the clientUnderTest correctly propagates error func CheckPropagatesErrorClient(t *testing.T, clientUnderTest networkservice.NetworkServiceClient) networkservice.NetworkServiceClient { return chain.NewNetworkServiceClient( - metadata.NewClient(), NewClient(t, false), clientUnderTest, injecterror.NewClient(), @@ -40,7 +38,6 @@ func CheckPropagatesErrorClient(t *testing.T, clientUnderTest networkservice.Net // CheckPropogatesErrorServer - NetworkServiceServer that will check to see if the serverUnderTest correctly propagates error func CheckPropogatesErrorServer(t *testing.T, serverUnderTest networkservice.NetworkServiceServer) networkservice.NetworkServiceServer { return chain.NewNetworkServiceServer( - metadata.NewServer(), NewServer(t, false), serverUnderTest, injecterror.NewServer(), diff --git a/pkg/networkservice/utils/checks/checkopts/check_propogate_opts.go b/pkg/networkservice/utils/checks/checkopts/check_propogate_opts.go index 35da17f91..68f4d6269 100644 --- a/pkg/networkservice/utils/checks/checkopts/check_propogate_opts.go +++ b/pkg/networkservice/utils/checks/checkopts/check_propogate_opts.go @@ -1,4 +1,4 @@ -// Copyright (c) 2020-2023 Cisco and/or its affiliates. +// Copyright (c) 2020 Cisco and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -24,13 +24,11 @@ import ( "github.com/networkservicemesh/sdk/pkg/networkservice/core/chain" "github.com/networkservicemesh/sdk/pkg/networkservice/utils/inject/injectopts" - "github.com/networkservicemesh/sdk/pkg/networkservice/utils/metadata" ) // CheckPropogateOptsClient - returns NetworkServiceClient that checks to make sure the clientUnderTest is passing through the grpc.CallOptions func CheckPropogateOptsClient(t *testing.T, clientUnderTest networkservice.NetworkServiceClient) networkservice.NetworkServiceClient { return chain.NewNetworkServiceClient( - metadata.NewClient(), injectopts.NewClient(), clientUnderTest, NewClient(t), diff --git a/pkg/registry/chains/memory/server.go b/pkg/registry/chains/memory/server.go index 9aca42afa..c35583d3a 100644 --- a/pkg/registry/chains/memory/server.go +++ b/pkg/registry/chains/memory/server.go @@ -140,7 +140,6 @@ func NewServer(ctx context.Context, tokenGenerator token.GeneratorFunc, options nseChain := chain.NewNetworkServiceEndpointRegistryServer( grpcmetadata.NewNetworkServiceEndpointRegistryServer(), updatepath.NewNetworkServiceEndpointRegistryServer(tokenGenerator), - metadata.NewNetworkServiceEndpointServer(), opts.authorizeNSERegistryServer, begin.NewNetworkServiceEndpointRegistryServer(), metadata.NewNetworkServiceEndpointServer(), @@ -157,10 +156,8 @@ func NewServer(ctx context.Context, tokenGenerator token.GeneratorFunc, options return false }, Action: chain.NewNetworkServiceEndpointRegistryServer( - metadata.NewNetworkServiceEndpointServer(), connect.NewNetworkServiceEndpointRegistryServer( chain.NewNetworkServiceEndpointRegistryClient( - metadata.NewNetworkServiceEndpointClient(), begin.NewNetworkServiceEndpointRegistryClient(), clienturl.NewNetworkServiceEndpointRegistryClient(opts.proxyRegistryURL), clientconn.NewNetworkServiceEndpointRegistryClient(), @@ -177,7 +174,6 @@ func NewServer(ctx context.Context, tokenGenerator token.GeneratorFunc, options switchcase.NSEServerCase{ Condition: func(c context.Context, nse *registry.NetworkServiceEndpoint) bool { return true }, Action: chain.NewNetworkServiceEndpointRegistryServer( - metadata.NewNetworkServiceEndpointServer(), setregistrationtime.NewNetworkServiceEndpointRegistryServer(), expire.NewNetworkServiceEndpointRegistryServer(ctx, expire.WithDefaultExpiration(opts.defaultExpiration)), memory.NewNetworkServiceEndpointRegistryServer(), @@ -198,7 +194,6 @@ func NewServer(ctx context.Context, tokenGenerator token.GeneratorFunc, options }, Action: connect.NewNetworkServiceRegistryServer( chain.NewNetworkServiceRegistryClient( - metadata.NewNetworkServiceClient(), clienturl.NewNetworkServiceRegistryClient(opts.proxyRegistryURL), begin.NewNetworkServiceRegistryClient(), clientconn.NewNetworkServiceRegistryClient(), diff --git a/pkg/registry/chains/proxydns/server.go b/pkg/registry/chains/proxydns/server.go index 62f304fb9..7f61e5c9f 100644 --- a/pkg/registry/chains/proxydns/server.go +++ b/pkg/registry/chains/proxydns/server.go @@ -1,4 +1,4 @@ -// Copyright (c) 2020-2023 Doc.ai and/or its affiliates. +// Copyright (c) 2020-2022 Doc.ai and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -32,7 +32,6 @@ import ( "github.com/networkservicemesh/sdk/pkg/registry/common/dial" "github.com/networkservicemesh/sdk/pkg/registry/common/dnsresolve" "github.com/networkservicemesh/sdk/pkg/registry/common/grpcmetadata" - "github.com/networkservicemesh/sdk/pkg/registry/utils/metadata" "github.com/networkservicemesh/sdk/pkg/registry/common/updatepath" "github.com/networkservicemesh/sdk/pkg/registry/core/chain" @@ -112,13 +111,11 @@ func NewServer(ctx context.Context, tokenGenerator token.GeneratorFunc, dnsResol nseChain := chain.NewNetworkServiceEndpointRegistryServer( grpcmetadata.NewNetworkServiceEndpointRegistryServer(), updatepath.NewNetworkServiceEndpointRegistryServer(tokenGenerator), - metadata.NewNetworkServiceEndpointServer(), opts.authorizeNSERegistryServer, begin.NewNetworkServiceEndpointRegistryServer(), dnsresolve.NewNetworkServiceEndpointRegistryServer(dnsresolve.WithResolver(dnsResolver)), connect.NewNetworkServiceEndpointRegistryServer( chain.NewNetworkServiceEndpointRegistryClient( - metadata.NewNetworkServiceEndpointClient(), clientconn.NewNetworkServiceEndpointRegistryClient(), opts.authorizeNSERegistryClient, grpcmetadata.NewNetworkServiceEndpointRegistryClient(), @@ -131,13 +128,11 @@ func NewServer(ctx context.Context, tokenGenerator token.GeneratorFunc, dnsResol nsChain := chain.NewNetworkServiceRegistryServer( grpcmetadata.NewNetworkServiceRegistryServer(), updatepath.NewNetworkServiceRegistryServer(tokenGenerator), - metadata.NewNetworkServiceServer(), begin.NewNetworkServiceRegistryServer(), opts.authorizeNSRegistryServer, dnsresolve.NewNetworkServiceRegistryServer(dnsresolve.WithResolver(dnsResolver)), connect.NewNetworkServiceRegistryServer( chain.NewNetworkServiceRegistryClient( - metadata.NewNetworkServiceClient(), clientconn.NewNetworkServiceRegistryClient(), opts.authorizeNSRegistryClient, grpcmetadata.NewNetworkServiceRegistryClient(), diff --git a/pkg/registry/core/chain/ns_registry.go b/pkg/registry/core/chain/ns_registry.go index 82140ea76..71a198a3a 100644 --- a/pkg/registry/core/chain/ns_registry.go +++ b/pkg/registry/core/chain/ns_registry.go @@ -1,6 +1,6 @@ // Copyright (c) 2020 Cisco Systems, Inc. // -// Copyright (c) 2020-2023 Doc.ai and/or its affiliates. +// Copyright (c) 2020-2021 Doc.ai and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -20,29 +20,17 @@ package chain import ( "github.com/networkservicemesh/api/pkg/api/registry" - "github.com/sirupsen/logrus" - "github.com/networkservicemesh/sdk/pkg/registry/core/debug" "github.com/networkservicemesh/sdk/pkg/registry/core/next" "github.com/networkservicemesh/sdk/pkg/registry/core/trace" ) // NewNetworkServiceRegistryServer - creates a chain of servers func NewNetworkServiceRegistryServer(servers ...registry.NetworkServiceRegistryServer) registry.NetworkServiceRegistryServer { - server := trace.NewNetworkServiceRegistryServer - if logrus.GetLevel() == logrus.DebugLevel { - server = debug.NewNetworkServiceRegistryServer - } - - return next.NewNetworkServiceRegistryServer(next.NewWrappedNetworkServiceRegistryServer(server, servers...)) + return next.NewNetworkServiceRegistryServer(next.NewWrappedNetworkServiceRegistryServer(trace.NewNetworkServiceRegistryServer, servers...)) } // NewNetworkServiceRegistryClient - creates a chain of clients func NewNetworkServiceRegistryClient(clients ...registry.NetworkServiceRegistryClient) registry.NetworkServiceRegistryClient { - client := trace.NewNetworkServiceRegistryClient - if logrus.GetLevel() == logrus.DebugLevel { - client = debug.NewNetworkServiceRegistryClient - } - - return next.NewNetworkServiceRegistryClient(next.NewWrappedNetworkServiceRegistryClient(client, clients...)) + return next.NewNetworkServiceRegistryClient(next.NewWrappedNetworkServiceRegistryClient(trace.NewNetworkServiceRegistryClient, clients...)) } diff --git a/pkg/registry/core/chain/nse_registry.go b/pkg/registry/core/chain/nse_registry.go index 5a335e7d7..341611d6e 100644 --- a/pkg/registry/core/chain/nse_registry.go +++ b/pkg/registry/core/chain/nse_registry.go @@ -1,6 +1,6 @@ // Copyright (c) 2020 Cisco Systems, Inc. // -// Copyright (c) 2020-2023 Doc.ai and/or its affiliates. +// Copyright (c) 2020-2021 Doc.ai and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -21,29 +21,17 @@ package chain import ( "github.com/networkservicemesh/api/pkg/api/registry" - "github.com/sirupsen/logrus" - "github.com/networkservicemesh/sdk/pkg/registry/core/debug" "github.com/networkservicemesh/sdk/pkg/registry/core/next" "github.com/networkservicemesh/sdk/pkg/registry/core/trace" ) // NewNetworkServiceEndpointRegistryServer - creates a chain of servers func NewNetworkServiceEndpointRegistryServer(servers ...registry.NetworkServiceEndpointRegistryServer) registry.NetworkServiceEndpointRegistryServer { - server := trace.NewNetworkServiceEndpointRegistryServer - if logrus.GetLevel() == logrus.DebugLevel { - server = debug.NewNetworkServiceEndpointRegistryServer - } - - return next.NewWrappedNetworkServiceEndpointRegistryServer(server, servers...) + return next.NewWrappedNetworkServiceEndpointRegistryServer(trace.NewNetworkServiceEndpointRegistryServer, servers...) } // NewNetworkServiceEndpointRegistryClient - creates a chain of clients func NewNetworkServiceEndpointRegistryClient(clients ...registry.NetworkServiceEndpointRegistryClient) registry.NetworkServiceEndpointRegistryClient { - client := trace.NewNetworkServiceEndpointRegistryClient - if logrus.GetLevel() == logrus.DebugLevel { - client = debug.NewNetworkServiceEndpointRegistryClient - } - - return next.NewNetworkServiceEndpointRegistryClient(next.NewWrappedNetworkServiceEndpointRegistryClient(client, clients...)) + return next.NewNetworkServiceEndpointRegistryClient(next.NewWrappedNetworkServiceEndpointRegistryClient(trace.NewNetworkServiceEndpointRegistryClient, clients...)) } diff --git a/pkg/registry/core/debug/context.go b/pkg/registry/core/debug/context.go deleted file mode 100644 index e616687f2..000000000 --- a/pkg/registry/core/debug/context.go +++ /dev/null @@ -1,125 +0,0 @@ -// Copyright (c) 2023 Doc.ai and/or its affiliates. -// -// SPDX-License-Identifier: Apache-2.0 -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at: -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package debug - -import ( - "context" - - "github.com/networkservicemesh/sdk/pkg/registry/utils/metadata" - "github.com/networkservicemesh/sdk/pkg/tools/log" - "github.com/networkservicemesh/sdk/pkg/tools/log/logruslogger" -) - -type contextKeyType string - -const ( - loggedType string = "registry" - nsClientRecvLoggedKey contextKeyType = "nsClientRecvLoggedKey" - nsClientRecvErrorLoggedKey contextKeyType = "nsClientRecvErrorLoggedKey" - nsServerSendLoggedKey contextKeyType = "nsServerSendLoggedKey" - nsServerSendErrorLoggedKey contextKeyType = "nsServerSendErrorLoggedKey" - nseClientRecvLoggedKey contextKeyType = "nseClientRecvLoggedKey" - nseClientRecvErrorLoggedKey contextKeyType = "nseClientRecvErrorLoggedKey" - nseServerSendLoggedKey contextKeyType = "nseServerSendLoggedKey" - nseServerSendErrorLoggedKey contextKeyType = "nseServerSendErrorLoggedKey" -) - -// withLog - provides corresponding logger in context -func withLog(parent context.Context) (c context.Context) { - if parent == nil { - panic("cannot create context from nil parent") - } - - fields := []*log.Field{log.NewField("type", loggedType)} - lLogger := logruslogger.LoggerWithFields(fields) - - return log.WithLog(parent, lLogger) -} - -func storeNSClientRecvLogged(ctx context.Context) (stored bool) { - _, ok := metadata.Map(ctx, true).Load(nsClientRecvLoggedKey) - if !ok { - metadata.Map(ctx, true).Store(nsClientRecvLoggedKey, true) - } - return !ok -} - -func storeNSClientRecvErrorLogged(ctx context.Context) (stored bool) { - _, ok := metadata.Map(ctx, true).Load(nsClientRecvErrorLoggedKey) - if !ok { - metadata.Map(ctx, true).Store(nsClientRecvErrorLoggedKey, true) - } - return !ok -} - -func storeNSServerSendLogged(ctx context.Context) (stored bool) { - _, ok := metadata.Map(ctx, false).Load(nsServerSendLoggedKey) - if !ok { - metadata.Map(ctx, false).Store(nsServerSendLoggedKey, true) - } - return !ok -} - -func storeNSServerSendErrorLogged(ctx context.Context) (stored bool) { - _, ok := metadata.Map(ctx, false).Load(nsServerSendErrorLoggedKey) - if !ok { - metadata.Map(ctx, false).Store(nsServerSendErrorLoggedKey, true) - } - return !ok -} - -func storeNSEClientRecvLogged(ctx context.Context) (stored bool) { - _, ok := metadata.Map(ctx, true).Load(nseClientRecvLoggedKey) - if !ok { - metadata.Map(ctx, true).Store(nseClientRecvLoggedKey, true) - } - return !ok -} - -func storeNSEClientRecvErrorLogged(ctx context.Context) (stored bool) { - _, ok := metadata.Map(ctx, true).Load(nseClientRecvErrorLoggedKey) - if !ok { - metadata.Map(ctx, true).Store(nseClientRecvErrorLoggedKey, true) - } - return !ok -} - -func storeNSEServerSendLogged(ctx context.Context) (stored bool) { - _, ok := metadata.Map(ctx, false).Load(nseServerSendLoggedKey) - if !ok { - metadata.Map(ctx, false).Store(nseServerSendLoggedKey, true) - } - return !ok -} - -func storeNSEServerSendErrorLogged(ctx context.Context) (stored bool) { - _, ok := metadata.Map(ctx, false).Load(nseServerSendErrorLoggedKey) - if !ok { - metadata.Map(ctx, false).Store(nseServerSendErrorLoggedKey, true) - } - return !ok -} - -func isReadyForLogging(ctx context.Context, isClient bool) (isReady bool) { - defer func() { - if r := recover(); r != nil { - isReady = false - } - }() - metadata.Map(ctx, isClient) - return true -} diff --git a/pkg/registry/core/debug/ns_registry.go b/pkg/registry/core/debug/ns_registry.go deleted file mode 100644 index 3594556e5..000000000 --- a/pkg/registry/core/debug/ns_registry.go +++ /dev/null @@ -1,261 +0,0 @@ -// Copyright (c) 2023 Doc.ai and/or its affiliates. -// -// SPDX-License-Identifier: Apache-2.0 -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at: -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -// Package debug provides a wrapper for debugging around a registry.{Registry,Discovery}{Server,Client} -package debug - -import ( - "context" - "io" - - "github.com/networkservicemesh/sdk/pkg/registry/core/streamcontext" - "github.com/networkservicemesh/sdk/pkg/tools/typeutils" - - "github.com/golang/protobuf/ptypes/empty" - "github.com/pkg/errors" - "google.golang.org/grpc" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" - - "github.com/networkservicemesh/api/pkg/api/registry" -) - -type debugNetworkServiceRegistryClient struct { - debugged registry.NetworkServiceRegistryClient -} - -type debugNetworkServiceRegistryFindClient struct { - registry.NetworkServiceRegistry_FindClient -} - -const ( - nsClientRegisterLoggedKey contextKeyType = "nsClientRegisterLoggedKey" - nsClientFindLoggedKey contextKeyType = "nsClientFindLoggedKey" - nsClientUnregisterLoggedKey contextKeyType = "nsClientUnregisterLoggedKey" - nsServerRegisterLoggedKey contextKeyType = "nsServerRegisterLoggedKey" - nsServerFindLoggedKey contextKeyType = "nsServerFindLoggedKey" - nsServerUnregisterLoggedKey contextKeyType = "nsServerUnregisterLoggedKey" -) - -func (t *debugNetworkServiceRegistryFindClient) Recv() (*registry.NetworkServiceResponse, error) { - operation := typeutils.GetFuncName(t.NetworkServiceRegistry_FindClient, methodNameRecv) - updatedContext := withLog(t.Context()) - - s := streamcontext.NetworkServiceRegistryFindClient(updatedContext, t.NetworkServiceRegistry_FindClient) - rv, err := s.Recv() - - if err != nil { - if errors.Is(err, io.EOF) { - return nil, errors.WithStack(err) - } - if status.Code(err) == codes.Canceled { - return nil, errors.WithStack(err) - } - - if isReadyForLogging(updatedContext, true) && storeNSClientRecvErrorLogged(updatedContext) { - return nil, logError(updatedContext, err, operation) - } - - return nil, err - } - - if isReadyForLogging(updatedContext, true) && storeNSClientRecvLogged(updatedContext) { - logObjectDebug(updatedContext, "ns-recv-response", rv.NetworkService) - } - - return rv, nil -} - -func (t *debugNetworkServiceRegistryClient) Register(ctx context.Context, in *registry.NetworkService, opts ...grpc.CallOption) (*registry.NetworkService, error) { - operation := typeutils.GetFuncName(t.debugged, methodNameRegister) - updatedContext := withLog(ctx) - - if updatedContext.Value(nsClientRegisterLoggedKey) == nil { - updatedContext = context.WithValue(updatedContext, nsClientRegisterLoggedKey, t) - logObjectDebug(updatedContext, "ns-register", in) - } - - rv, err := t.debugged.Register(updatedContext, in, opts...) - if err != nil { - if updatedContext.Value(nsClientRegisterLoggedKey) == t { - return nil, logError(updatedContext, err, operation) - } - return nil, err - } - - if updatedContext.Value(nsClientRegisterLoggedKey) == t { - logObjectDebug(updatedContext, "ns-register-response", rv) - } - return rv, nil -} - -func (t *debugNetworkServiceRegistryClient) Find(ctx context.Context, in *registry.NetworkServiceQuery, opts ...grpc.CallOption) (registry.NetworkServiceRegistry_FindClient, error) { - operation := typeutils.GetFuncName(t.debugged, methodNameFind) - updatedContext := withLog(ctx) - - if updatedContext.Value(nsClientFindLoggedKey) == nil { - updatedContext = context.WithValue(updatedContext, nsClientFindLoggedKey, t) - logObjectDebug(updatedContext, "ns-find", in) - } - - // Actually call the next - rv, err := t.debugged.Find(updatedContext, in, opts...) - if err != nil { - if updatedContext.Value(nsClientFindLoggedKey) == t { - return nil, logError(updatedContext, err, operation) - } - return nil, err - } - - if updatedContext.Value(nsClientFindLoggedKey) == t { - logObjectDebug(updatedContext, "ns-find-response", rv) - } - return &debugNetworkServiceRegistryFindClient{NetworkServiceRegistry_FindClient: rv}, nil -} - -func (t *debugNetworkServiceRegistryClient) Unregister(ctx context.Context, in *registry.NetworkService, opts ...grpc.CallOption) (*empty.Empty, error) { - operation := typeutils.GetFuncName(t.debugged, methodNameUnregister) - updatedContext := withLog(ctx) - - if updatedContext.Value(nsClientUnregisterLoggedKey) == nil { - updatedContext = context.WithValue(updatedContext, nsClientUnregisterLoggedKey, t) - logObjectDebug(updatedContext, "ns-unregister", in) - } - - // Actually call the next - rv, err := t.debugged.Unregister(updatedContext, in, opts...) - if err != nil { - if updatedContext.Value(nsClientUnregisterLoggedKey) == t { - return nil, logError(updatedContext, err, operation) - } - return nil, err - } - - if updatedContext.Value(nsClientUnregisterLoggedKey) == t { - logObjectDebug(updatedContext, "ns-unregister-response", rv) - } - return rv, nil -} - -// NewNetworkServiceRegistryClient - wraps registry.NetworkServiceRegistryClient with tracing -func NewNetworkServiceRegistryClient(debugged registry.NetworkServiceRegistryClient) registry.NetworkServiceRegistryClient { - return &debugNetworkServiceRegistryClient{debugged: debugged} -} - -type debugNetworkServiceRegistryServer struct { - debugged registry.NetworkServiceRegistryServer -} - -func (t *debugNetworkServiceRegistryServer) Register(ctx context.Context, in *registry.NetworkService) (*registry.NetworkService, error) { - operation := typeutils.GetFuncName(t.debugged, methodNameRegister) - updatedContext := withLog(ctx) - - if updatedContext.Value(nsServerRegisterLoggedKey) == nil { - updatedContext = context.WithValue(updatedContext, nsServerRegisterLoggedKey, t) - logObjectDebug(updatedContext, "ns-server-register", in) - } - - rv, err := t.debugged.Register(updatedContext, in) - if err != nil { - if updatedContext.Value(nsServerRegisterLoggedKey) == t { - return nil, logError(updatedContext, err, operation) - } - return nil, err - } - - if updatedContext.Value(nsServerRegisterLoggedKey) == t { - logObjectDebug(updatedContext, "ns-server-register-response", rv) - } - return rv, nil -} - -func (t *debugNetworkServiceRegistryServer) Find(in *registry.NetworkServiceQuery, s registry.NetworkServiceRegistry_FindServer) error { - operation := typeutils.GetFuncName(t.debugged, methodNameFind) - updatedContext := withLog(s.Context()) - - if updatedContext.Value(nsServerFindLoggedKey) == nil { - updatedContext = context.WithValue(updatedContext, nsServerFindLoggedKey, t) - logObjectDebug(updatedContext, "ns-server-find", in) - } - - s = &debugNetworkServiceRegistryFindServer{ - NetworkServiceRegistry_FindServer: streamcontext.NetworkServiceRegistryFindServer(updatedContext, s), - } - - // Actually call the next - err := t.debugged.Find(in, s) - if err != nil { - if updatedContext.Value(nsServerFindLoggedKey) == t { - return logError(updatedContext, err, operation) - } - - return err - } - return nil -} - -func (t *debugNetworkServiceRegistryServer) Unregister(ctx context.Context, in *registry.NetworkService) (*empty.Empty, error) { - operation := typeutils.GetFuncName(t.debugged, methodNameUnregister) - updatedContext := withLog(ctx) - - if updatedContext.Value(nsServerUnregisterLoggedKey) == nil { - updatedContext = context.WithValue(updatedContext, nsServerUnregisterLoggedKey, t) - logObjectDebug(updatedContext, "ns-server-unregister", in) - } - - // Actually call the next - rv, err := t.debugged.Unregister(updatedContext, in) - if err != nil { - if updatedContext.Value(nsServerUnregisterLoggedKey) == t { - return nil, logError(updatedContext, err, operation) - } - return nil, err - } - - if updatedContext.Value(nsServerUnregisterLoggedKey) == t { - logObjectDebug(updatedContext, "ns-server-unregister-response", rv) - } - return rv, nil -} - -// NewNetworkServiceRegistryServer - wraps registry.NetworkServiceRegistryServer with tracing -func NewNetworkServiceRegistryServer(debugged registry.NetworkServiceRegistryServer) registry.NetworkServiceRegistryServer { - return &debugNetworkServiceRegistryServer{debugged: debugged} -} - -type debugNetworkServiceRegistryFindServer struct { - registry.NetworkServiceRegistry_FindServer -} - -func (t *debugNetworkServiceRegistryFindServer) Send(nsResp *registry.NetworkServiceResponse) error { - operation := typeutils.GetFuncName(t.NetworkServiceRegistry_FindServer, methodNameSend) - updatedContext := withLog(t.Context()) - - if isReadyForLogging(updatedContext, false) && storeNSServerSendLogged(updatedContext) { - logObjectDebug(updatedContext, "network service", nsResp.NetworkService) - } - - s := streamcontext.NetworkServiceRegistryFindServer(updatedContext, t.NetworkServiceRegistry_FindServer) - err := s.Send(nsResp) - if err != nil { - if isReadyForLogging(updatedContext, false) && storeNSServerSendErrorLogged(updatedContext) { - return logError(updatedContext, err, operation) - } - return err - } - - return nil -} diff --git a/pkg/registry/core/debug/nse_registry.go b/pkg/registry/core/debug/nse_registry.go deleted file mode 100644 index 1fc349730..000000000 --- a/pkg/registry/core/debug/nse_registry.go +++ /dev/null @@ -1,263 +0,0 @@ -// Copyright (c) 2023 Doc.ai and/or its affiliates. -// -// SPDX-License-Identifier: Apache-2.0 -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at: -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package debug - -import ( - "context" - "io" - - "github.com/networkservicemesh/sdk/pkg/registry/core/streamcontext" - "github.com/networkservicemesh/sdk/pkg/tools/typeutils" - - "github.com/golang/protobuf/ptypes/empty" - "github.com/pkg/errors" - "google.golang.org/grpc" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" - - "github.com/networkservicemesh/api/pkg/api/registry" -) - -type debugNetworkServiceEndpointRegistryClient struct { - debugged registry.NetworkServiceEndpointRegistryClient -} - -type debugNetworkServiceEndpointRegistryFindClient struct { - registry.NetworkServiceEndpointRegistry_FindClient -} - -const ( - nseClientRegisterLoggedKey contextKeyType = "nseClientRegisterLoggedKey" - nseClientFindLoggedKey contextKeyType = "nseClientFindLoggedKey" - nseClientUnregisterLoggedKey contextKeyType = "nseClientUnregisterLoggedKey" - nseServerRegisterLoggedKey contextKeyType = "nseServerRegisterLoggedKey" - nseServerFindLoggedKey contextKeyType = "nseServerFindLoggedKey" - nseServerUnregisterLoggedKey contextKeyType = "nseServerUnregisterLoggedKey" -) - -func (t *debugNetworkServiceEndpointRegistryFindClient) Recv() (*registry.NetworkServiceEndpointResponse, error) { - operation := typeutils.GetFuncName(t.NetworkServiceEndpointRegistry_FindClient, methodNameRecv) - updatedContext := withLog(t.Context()) - - s := streamcontext.NetworkServiceEndpointRegistryFindClient(updatedContext, t.NetworkServiceEndpointRegistry_FindClient) - rv, err := s.Recv() - - if err != nil { - if errors.Is(err, io.EOF) { - return nil, errors.WithStack(err) - } - if status.Code(err) == codes.Canceled { - return nil, errors.WithStack(err) - } - - if isReadyForLogging(updatedContext, true) && storeNSEClientRecvErrorLogged(updatedContext) { - return nil, logError(updatedContext, err, operation) - } - - return nil, err - } - - if isReadyForLogging(updatedContext, true) && storeNSEClientRecvLogged(updatedContext) { - logObjectDebug(updatedContext, "nse-recv-response", rv) - } - - return rv, nil -} - -func (t *debugNetworkServiceEndpointRegistryClient) Register(ctx context.Context, in *registry.NetworkServiceEndpoint, opts ...grpc.CallOption) (*registry.NetworkServiceEndpoint, error) { - operation := typeutils.GetFuncName(t.debugged, methodNameRegister) - updatedContext := withLog(ctx) - - if updatedContext.Value(nseClientRegisterLoggedKey) == nil { - updatedContext = context.WithValue(updatedContext, nseClientRegisterLoggedKey, t) - logObjectDebug(updatedContext, "nse-register", in) - } - - rv, err := t.debugged.Register(updatedContext, in, opts...) - if err != nil { - if updatedContext.Value(nseClientRegisterLoggedKey) == t { - return nil, logError(updatedContext, err, operation) - } - return nil, err - } - - if updatedContext.Value(nseClientRegisterLoggedKey) == t { - logObjectDebug(updatedContext, "nse-register-response", rv) - } - return rv, nil -} -func (t *debugNetworkServiceEndpointRegistryClient) Find(ctx context.Context, in *registry.NetworkServiceEndpointQuery, opts ...grpc.CallOption) (registry.NetworkServiceEndpointRegistry_FindClient, error) { - operation := typeutils.GetFuncName(t.debugged, methodNameFind) - updatedContext := withLog(ctx) - - if updatedContext.Value(nseClientFindLoggedKey) == nil { - updatedContext = context.WithValue(updatedContext, nseClientFindLoggedKey, t) - logObjectDebug(updatedContext, "nse-find", in) - } - - // Actually call the next - rv, err := t.debugged.Find(updatedContext, in, opts...) - if err != nil { - if updatedContext.Value(nseClientFindLoggedKey) == t { - return nil, logError(updatedContext, err, operation) - } - return nil, err - } - - if updatedContext.Value(nseClientFindLoggedKey) == t { - logObjectDebug(updatedContext, "nse-find-response", rv) - } - return &debugNetworkServiceEndpointRegistryFindClient{NetworkServiceEndpointRegistry_FindClient: rv}, nil -} - -func (t *debugNetworkServiceEndpointRegistryClient) Unregister(ctx context.Context, in *registry.NetworkServiceEndpoint, opts ...grpc.CallOption) (*empty.Empty, error) { - operation := typeutils.GetFuncName(t.debugged, methodNameUnregister) - updatedContext := withLog(ctx) - - if updatedContext.Value(nseClientUnregisterLoggedKey) == nil { - updatedContext = context.WithValue(updatedContext, nseClientUnregisterLoggedKey, t) - logObjectDebug(updatedContext, "nse-unregister", in) - } - - // Actually call the next - rv, err := t.debugged.Unregister(updatedContext, in, opts...) - if err != nil { - if updatedContext.Value(nseClientUnregisterLoggedKey) == t { - return nil, logError(updatedContext, err, operation) - } - return nil, err - } - - if updatedContext.Value(nseClientUnregisterLoggedKey) == t { - logObjectDebug(updatedContext, "nse-unregister-response", rv) - } - return rv, nil -} - -// NewNetworkServiceEndpointRegistryClient - wraps registry.NetworkServiceEndpointRegistryClient with tracing -func NewNetworkServiceEndpointRegistryClient(debugged registry.NetworkServiceEndpointRegistryClient) registry.NetworkServiceEndpointRegistryClient { - return &debugNetworkServiceEndpointRegistryClient{debugged: debugged} -} - -type debugNetworkServiceEndpointRegistryServer struct { - debugged registry.NetworkServiceEndpointRegistryServer -} - -func (t *debugNetworkServiceEndpointRegistryServer) Register(ctx context.Context, in *registry.NetworkServiceEndpoint) (*registry.NetworkServiceEndpoint, error) { - operation := typeutils.GetFuncName(t.debugged, methodNameRegister) - updatedContext := withLog(ctx) - - if updatedContext.Value(nseServerRegisterLoggedKey) == nil { - updatedContext = context.WithValue(updatedContext, nseServerRegisterLoggedKey, t) - logObjectDebug(updatedContext, "nse-server-register", in) - } - - rv, err := t.debugged.Register(updatedContext, in) - if err != nil { - if updatedContext.Value(nseServerRegisterLoggedKey) == t { - return nil, logError(updatedContext, err, operation) - } - return nil, err - } - - if updatedContext.Value(nseServerRegisterLoggedKey) == t { - logObjectDebug(updatedContext, "nse-server-register-response", rv) - } - return rv, nil -} - -func (t *debugNetworkServiceEndpointRegistryServer) Find(in *registry.NetworkServiceEndpointQuery, s registry.NetworkServiceEndpointRegistry_FindServer) error { - operation := typeutils.GetFuncName(t.debugged, methodNameFind) - updatedContext := withLog(s.Context()) - - if updatedContext.Value(nseServerFindLoggedKey) == nil { - updatedContext = context.WithValue(updatedContext, nseServerFindLoggedKey, t) - logObjectDebug(updatedContext, "nse-server-find", in) - } - - s = &debugNetworkServiceEndpointRegistryFindServer{ - NetworkServiceEndpointRegistry_FindServer: streamcontext.NetworkServiceEndpointRegistryFindServer(updatedContext, s), - } - - // Actually call the next - err := t.debugged.Find(in, s) - if err != nil { - if updatedContext.Value(nseServerRegisterLoggedKey) == t { - return logError(updatedContext, err, operation) - } - return err - } - - if updatedContext.Value(nseServerRegisterLoggedKey) == t { - logObjectDebug(updatedContext, "nse-server-find-response", in) - } - - return nil -} - -func (t *debugNetworkServiceEndpointRegistryServer) Unregister(ctx context.Context, in *registry.NetworkServiceEndpoint) (*empty.Empty, error) { - operation := typeutils.GetFuncName(t.debugged, methodNameUnregister) - updatedContext := withLog(ctx) - - if updatedContext.Value(nseServerUnregisterLoggedKey) == nil { - updatedContext = context.WithValue(updatedContext, nseServerUnregisterLoggedKey, t) - logObjectDebug(updatedContext, "nse-server-unregister", in) - } - - // Actually call the next - rv, err := t.debugged.Unregister(updatedContext, in) - if err != nil { - if updatedContext.Value(nseServerUnregisterLoggedKey) == t { - return nil, logError(updatedContext, err, operation) - } - return nil, err - } - - if updatedContext.Value(nseServerUnregisterLoggedKey) == t { - logObjectDebug(updatedContext, "nse-server-unregister-response", rv) - } - return rv, nil -} - -// NewNetworkServiceEndpointRegistryServer - wraps registry.NetworkServiceEndpointRegistryServer with tracing -func NewNetworkServiceEndpointRegistryServer(debugged registry.NetworkServiceEndpointRegistryServer) registry.NetworkServiceEndpointRegistryServer { - return &debugNetworkServiceEndpointRegistryServer{debugged: debugged} -} - -type debugNetworkServiceEndpointRegistryFindServer struct { - registry.NetworkServiceEndpointRegistry_FindServer -} - -func (t *debugNetworkServiceEndpointRegistryFindServer) Send(nseResp *registry.NetworkServiceEndpointResponse) error { - operation := typeutils.GetFuncName(t.NetworkServiceEndpointRegistry_FindServer, methodNameSend) - updatedContext := withLog(t.Context()) - - if isReadyForLogging(updatedContext, false) && storeNSEServerSendLogged(updatedContext) { - logObjectDebug(updatedContext, "network service endpoint", nseResp.NetworkServiceEndpoint) - } - - s := streamcontext.NetworkServiceEndpointRegistryFindServer(updatedContext, t.NetworkServiceEndpointRegistry_FindServer) - err := s.Send(nseResp) - if err != nil { - if isReadyForLogging(updatedContext, false) && storeNSEServerSendErrorLogged(updatedContext) { - return logError(updatedContext, err, operation) - } - - return err - } - return nil -} diff --git a/pkg/registry/core/trace/ns_registry.go b/pkg/registry/core/trace/ns_registry.go index fea56d645..ee355b046 100644 --- a/pkg/registry/core/trace/ns_registry.go +++ b/pkg/registry/core/trace/ns_registry.go @@ -1,5 +1,3 @@ -// Copyright (c) 2020-2022 Doc.ai and/or its affiliates. -// // Copyright (c) 2023 Cisco and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 @@ -16,179 +14,104 @@ // See the License for the specific language governing permissions and // limitations under the License. -// Package trace provides a wrapper for tracing around a registry.{Registry,Discovery}{Server,Client} +// Package trace provides wrappers for tracing around a registry.{Registry,Discovery}{Server,Client} package trace import ( "context" - "io" - "github.com/networkservicemesh/sdk/pkg/registry/core/streamcontext" - "github.com/networkservicemesh/sdk/pkg/tools/typeutils" + "github.com/sirupsen/logrus" "github.com/golang/protobuf/ptypes/empty" - "github.com/pkg/errors" + "github.com/networkservicemesh/api/pkg/api/registry" "google.golang.org/grpc" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" - "github.com/networkservicemesh/api/pkg/api/registry" + "github.com/networkservicemesh/sdk/pkg/registry/core/next" + "github.com/networkservicemesh/sdk/pkg/registry/core/trace/traceconcise" + "github.com/networkservicemesh/sdk/pkg/registry/core/trace/traceverbose" ) type traceNetworkServiceRegistryClient struct { - traced registry.NetworkServiceRegistryClient + verbose registry.NetworkServiceRegistryClient + concise registry.NetworkServiceRegistryClient } -type traceNetworkServiceRegistryFindClient struct { - registry.NetworkServiceRegistry_FindClient -} - -func (t *traceNetworkServiceRegistryFindClient) Recv() (*registry.NetworkServiceResponse, error) { - operation := typeutils.GetFuncName(t.NetworkServiceRegistry_FindClient, methodNameRecv) - ctx, finish := withLog(t.Context(), operation, methodNameRecv) - defer finish() - - s := streamcontext.NetworkServiceRegistryFindClient(ctx, t.NetworkServiceRegistry_FindClient) - rv, err := s.Recv() - - if err != nil { - if errors.Is(err, io.EOF) { - return nil, errors.WithStack(err) - } - if status.Code(err) == codes.Canceled { - return nil, errors.WithStack(err) - } - return nil, logError(ctx, err, operation) +// NewNetworkServiceRegistryClient - wraps registry.NetworkServiceRegistryClient with tracing +func NewNetworkServiceRegistryClient(traced registry.NetworkServiceRegistryClient) registry.NetworkServiceRegistryClient { + return &traceNetworkServiceRegistryClient{ + verbose: traceverbose.NewNetworkServiceRegistryClient(traced), + concise: traceconcise.NewNetworkServiceRegistryClient(traced), } - logObjectTrace(ctx, "recv-response", rv.NetworkService) - return rv, nil } func (t *traceNetworkServiceRegistryClient) Register(ctx context.Context, in *registry.NetworkService, opts ...grpc.CallOption) (*registry.NetworkService, error) { - operation := typeutils.GetFuncName(t.traced, methodNameRegister) - ctx, finish := withLog(ctx, operation, methodNameRegister) - defer finish() - - logObjectTrace(ctx, "register", in) - - rv, err := t.traced.Register(ctx, in, opts...) - if err != nil { - return nil, logError(ctx, err, operation) + switch logrus.GetLevel() { + case logrus.TraceLevel: + return t.verbose.Register(ctx, in, opts...) + case logrus.InfoLevel, logrus.DebugLevel: + return t.concise.Register(ctx, in, opts...) } - logObjectTrace(ctx, "register-response", rv) - return rv, nil + return next.NetworkServiceRegistryClient(ctx).Register(ctx, in, opts...) } func (t *traceNetworkServiceRegistryClient) Find(ctx context.Context, in *registry.NetworkServiceQuery, opts ...grpc.CallOption) (registry.NetworkServiceRegistry_FindClient, error) { - operation := typeutils.GetFuncName(t.traced, methodNameFind) - ctx, finish := withLog(ctx, operation, methodNameFind) - defer finish() - - logObjectTrace(ctx, "find", in) - - // Actually call the next - rv, err := t.traced.Find(ctx, in, opts...) - if err != nil { - return nil, logError(ctx, err, operation) + switch logrus.GetLevel() { + case logrus.TraceLevel: + return t.verbose.Find(ctx, in, opts...) + case logrus.InfoLevel, logrus.DebugLevel: + return t.concise.Find(ctx, in, opts...) } - logObjectTrace(ctx, "find-response", rv) - - return &traceNetworkServiceRegistryFindClient{NetworkServiceRegistry_FindClient: rv}, nil + return next.NetworkServiceRegistryClient(ctx).Find(ctx, in, opts...) } func (t *traceNetworkServiceRegistryClient) Unregister(ctx context.Context, in *registry.NetworkService, opts ...grpc.CallOption) (*empty.Empty, error) { - operation := typeutils.GetFuncName(t.traced, methodNameUnregister) - ctx, finish := withLog(ctx, operation, methodNameUnregister) - defer finish() - - logObjectTrace(ctx, "unregister", in) - - // Actually call the next - rv, err := t.traced.Unregister(ctx, in, opts...) - if err != nil { - return nil, logError(ctx, err, operation) + switch logrus.GetLevel() { + case logrus.TraceLevel: + return t.verbose.Unregister(ctx, in, opts...) + case logrus.InfoLevel, logrus.DebugLevel: + return t.concise.Unregister(ctx, in, opts...) } - logObjectTrace(ctx, "unregister-response", rv) - return rv, nil + return next.NetworkServiceRegistryClient(ctx).Unregister(ctx, in, opts...) } -// NewNetworkServiceRegistryClient - wraps registry.NetworkServiceRegistryClient with tracing -func NewNetworkServiceRegistryClient(traced registry.NetworkServiceRegistryClient) registry.NetworkServiceRegistryClient { - return &traceNetworkServiceRegistryClient{traced: traced} +type traceNetworkServiceRegistryServer struct { + verbose registry.NetworkServiceRegistryServer + concise registry.NetworkServiceRegistryServer } -type traceNetworkServiceRegistryServer struct { - traced registry.NetworkServiceRegistryServer +// NewNetworkServiceRegistryServer - wraps registry.NetworkServiceRegistryServer with tracing +func NewNetworkServiceRegistryServer(traced registry.NetworkServiceRegistryServer) registry.NetworkServiceRegistryServer { + return &traceNetworkServiceRegistryServer{ + verbose: traceverbose.NewNetworkServiceRegistryServer(traced), + concise: traceconcise.NewNetworkServiceRegistryServer(traced), + } } func (t *traceNetworkServiceRegistryServer) Register(ctx context.Context, in *registry.NetworkService) (*registry.NetworkService, error) { - operation := typeutils.GetFuncName(t.traced, methodNameRegister) - ctx, finish := withLog(ctx, operation, methodNameRegister) - defer finish() - - logObjectTrace(ctx, "register", in) - - rv, err := t.traced.Register(ctx, in) - if err != nil { - return nil, logError(ctx, err, operation) + switch logrus.GetLevel() { + case logrus.TraceLevel: + return t.verbose.Register(ctx, in) + case logrus.InfoLevel, logrus.DebugLevel: + return t.concise.Register(ctx, in) } - logObjectTrace(ctx, "register-response", rv) - return rv, nil + return next.NetworkServiceRegistryServer(ctx).Register(ctx, in) } func (t *traceNetworkServiceRegistryServer) Find(in *registry.NetworkServiceQuery, s registry.NetworkServiceRegistry_FindServer) error { - operation := typeutils.GetFuncName(t.traced, methodNameFind) - ctx, finish := withLog(s.Context(), operation, methodNameFind) - defer finish() - - s = &traceNetworkServiceRegistryFindServer{ - NetworkServiceRegistry_FindServer: streamcontext.NetworkServiceRegistryFindServer(ctx, s), + switch logrus.GetLevel() { + case logrus.TraceLevel: + return t.verbose.Find(in, s) + case logrus.InfoLevel, logrus.DebugLevel: + return t.concise.Find(in, s) } - logObjectTrace(ctx, "find", in) - - // Actually call the next - err := t.traced.Find(in, s) - if err != nil { - return logError(ctx, err, operation) - } - return nil + return next.NetworkServiceRegistryServer(s.Context()).Find(in, s) } func (t *traceNetworkServiceRegistryServer) Unregister(ctx context.Context, in *registry.NetworkService) (*empty.Empty, error) { - operation := typeutils.GetFuncName(t.traced, methodNameUnregister) - ctx, finish := withLog(ctx, operation, methodNameUnregister) - defer finish() - - logObjectTrace(ctx, "unregister", in) - - // Actually call the next - rv, err := t.traced.Unregister(ctx, in) - if err != nil { - return nil, logError(ctx, err, operation) - } - logObjectTrace(ctx, "unregister-response", rv) - return rv, nil -} - -// NewNetworkServiceRegistryServer - wraps registry.NetworkServiceRegistryServer with tracing -func NewNetworkServiceRegistryServer(traced registry.NetworkServiceRegistryServer) registry.NetworkServiceRegistryServer { - return &traceNetworkServiceRegistryServer{traced: traced} -} - -type traceNetworkServiceRegistryFindServer struct { - registry.NetworkServiceRegistry_FindServer -} - -func (t *traceNetworkServiceRegistryFindServer) Send(nsResp *registry.NetworkServiceResponse) error { - operation := typeutils.GetFuncName(t.NetworkServiceRegistry_FindServer, methodNameSend) - ctx, finish := withLog(t.Context(), operation, methodNameSend) - defer finish() - - logObjectTrace(ctx, "network service", nsResp.NetworkService) - - s := streamcontext.NetworkServiceRegistryFindServer(ctx, t.NetworkServiceRegistry_FindServer) - err := s.Send(nsResp) - if err != nil { - return logError(ctx, err, operation) + switch logrus.GetLevel() { + case logrus.TraceLevel: + return t.verbose.Unregister(ctx, in) + case logrus.InfoLevel, logrus.DebugLevel: + return t.concise.Unregister(ctx, in) } - return nil + return next.NetworkServiceRegistryServer(ctx).Unregister(ctx, in) } diff --git a/pkg/registry/core/trace/nse_registry.go b/pkg/registry/core/trace/nse_registry.go index fb97c132c..6b5065078 100644 --- a/pkg/registry/core/trace/nse_registry.go +++ b/pkg/registry/core/trace/nse_registry.go @@ -1,5 +1,3 @@ -// Copyright (c) 2020-2022 Doc.ai and/or its affiliates. -// // Copyright (c) 2023 Cisco and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 @@ -20,174 +18,99 @@ package trace import ( "context" - "io" - "github.com/networkservicemesh/sdk/pkg/registry/core/streamcontext" - "github.com/networkservicemesh/sdk/pkg/tools/typeutils" + "github.com/sirupsen/logrus" - "github.com/golang/protobuf/ptypes/empty" - "github.com/pkg/errors" - "google.golang.org/grpc" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" + "github.com/networkservicemesh/sdk/pkg/registry/core/next" + "github.com/networkservicemesh/sdk/pkg/registry/core/trace/traceconcise" + "github.com/networkservicemesh/sdk/pkg/registry/core/trace/traceverbose" + "github.com/golang/protobuf/ptypes/empty" "github.com/networkservicemesh/api/pkg/api/registry" + "google.golang.org/grpc" ) type traceNetworkServiceEndpointRegistryClient struct { - traced registry.NetworkServiceEndpointRegistryClient + verbose registry.NetworkServiceEndpointRegistryClient + concise registry.NetworkServiceEndpointRegistryClient } -type traceNetworkServiceEndpointRegistryFindClient struct { - registry.NetworkServiceEndpointRegistry_FindClient -} - -func (t *traceNetworkServiceEndpointRegistryFindClient) Recv() (*registry.NetworkServiceEndpointResponse, error) { - operation := typeutils.GetFuncName(t.NetworkServiceEndpointRegistry_FindClient, methodNameRecv) - ctx, finish := withLog(t.Context(), operation, methodNameRecv) - defer finish() - - s := streamcontext.NetworkServiceEndpointRegistryFindClient(ctx, t.NetworkServiceEndpointRegistry_FindClient) - rv, err := s.Recv() - - if err != nil { - if errors.Is(err, io.EOF) { - return nil, errors.WithStack(err) - } - if status.Code(err) == codes.Canceled { - return nil, errors.WithStack(err) - } - return nil, logError(ctx, err, operation) +// NewNetworkServiceEndpointRegistryClient - wraps registry.NetworkServiceEndpointRegistryClient with tracing +func NewNetworkServiceEndpointRegistryClient(traced registry.NetworkServiceEndpointRegistryClient) registry.NetworkServiceEndpointRegistryClient { + return &traceNetworkServiceEndpointRegistryClient{ + verbose: traceverbose.NewNetworkServiceEndpointRegistryClient(traced), + concise: traceconcise.NewNetworkServiceEndpointRegistryClient(traced), } - logObjectTrace(ctx, "recv-response", rv) - return rv, nil } func (t *traceNetworkServiceEndpointRegistryClient) Register(ctx context.Context, in *registry.NetworkServiceEndpoint, opts ...grpc.CallOption) (*registry.NetworkServiceEndpoint, error) { - operation := typeutils.GetFuncName(t.traced, methodNameRegister) - ctx, finish := withLog(ctx, operation, methodNameRegister) - defer finish() - - logObjectTrace(ctx, "register", in) - rv, err := t.traced.Register(ctx, in, opts...) - if err != nil { - return nil, logError(ctx, err, operation) + switch logrus.GetLevel() { + case logrus.TraceLevel: + return t.verbose.Register(ctx, in, opts...) + case logrus.InfoLevel, logrus.DebugLevel: + return t.concise.Register(ctx, in, opts...) } - logObjectTrace(ctx, "register-response", rv) - return rv, nil + return next.NetworkServiceEndpointRegistryClient(ctx).Register(ctx, in, opts...) } func (t *traceNetworkServiceEndpointRegistryClient) Find(ctx context.Context, in *registry.NetworkServiceEndpointQuery, opts ...grpc.CallOption) (registry.NetworkServiceEndpointRegistry_FindClient, error) { - operation := typeutils.GetFuncName(t.traced, methodNameFind) - ctx, finish := withLog(ctx, operation, methodNameFind) - defer finish() - - logObjectTrace(ctx, "find", in) - - // Actually call the next - rv, err := t.traced.Find(ctx, in, opts...) - if err != nil { - return nil, logError(ctx, err, operation) + switch logrus.GetLevel() { + case logrus.TraceLevel: + return t.verbose.Find(ctx, in, opts...) + case logrus.InfoLevel, logrus.DebugLevel: + return t.concise.Find(ctx, in, opts...) } - logObjectTrace(ctx, "find-response", rv) - - return &traceNetworkServiceEndpointRegistryFindClient{NetworkServiceEndpointRegistry_FindClient: rv}, nil + return next.NetworkServiceEndpointRegistryClient(ctx).Find(ctx, in, opts...) } func (t *traceNetworkServiceEndpointRegistryClient) Unregister(ctx context.Context, in *registry.NetworkServiceEndpoint, opts ...grpc.CallOption) (*empty.Empty, error) { - operation := typeutils.GetFuncName(t.traced, methodNameUnregister) - ctx, finish := withLog(ctx, operation, methodNameUnregister) - defer finish() - - logObjectTrace(ctx, "unregister", in) - - // Actually call the next - rv, err := t.traced.Unregister(ctx, in, opts...) - if err != nil { - return nil, logError(ctx, err, operation) + switch logrus.GetLevel() { + case logrus.TraceLevel: + return t.verbose.Unregister(ctx, in, opts...) + case logrus.InfoLevel, logrus.DebugLevel: + return t.concise.Unregister(ctx, in, opts...) } - logObjectTrace(ctx, "unregister-response", rv) - return rv, nil + return next.NetworkServiceEndpointRegistryClient(ctx).Unregister(ctx, in, opts...) } -// NewNetworkServiceEndpointRegistryClient - wraps registry.NetworkServiceEndpointRegistryClient with tracing -func NewNetworkServiceEndpointRegistryClient(traced registry.NetworkServiceEndpointRegistryClient) registry.NetworkServiceEndpointRegistryClient { - return &traceNetworkServiceEndpointRegistryClient{traced: traced} +type traceNetworkServiceEndpointRegistryServer struct { + verbose registry.NetworkServiceEndpointRegistryServer + concise registry.NetworkServiceEndpointRegistryServer } -type traceNetworkServiceEndpointRegistryServer struct { - traced registry.NetworkServiceEndpointRegistryServer +// NewNetworkServiceEndpointRegistryServer - wraps registry.NetworkServiceEndpointRegistryServer with tracing +func NewNetworkServiceEndpointRegistryServer(traced registry.NetworkServiceEndpointRegistryServer) registry.NetworkServiceEndpointRegistryServer { + return &traceNetworkServiceEndpointRegistryServer{ + verbose: traceverbose.NewNetworkServiceEndpointRegistryServer(traced), + concise: traceconcise.NewNetworkServiceEndpointRegistryServer(traced), + } } func (t *traceNetworkServiceEndpointRegistryServer) Register(ctx context.Context, in *registry.NetworkServiceEndpoint) (*registry.NetworkServiceEndpoint, error) { - operation := typeutils.GetFuncName(t.traced, methodNameRegister) - ctx, finish := withLog(ctx, operation, methodNameRegister) - defer finish() - - logObjectTrace(ctx, "register", in) - - rv, err := t.traced.Register(ctx, in) - if err != nil { - return nil, logError(ctx, err, operation) + switch logrus.GetLevel() { + case logrus.TraceLevel: + return t.verbose.Register(ctx, in) + case logrus.InfoLevel, logrus.DebugLevel: + return t.concise.Register(ctx, in) } - logObjectTrace(ctx, "register-response", rv) - return rv, nil + return next.NetworkServiceEndpointRegistryServer(ctx).Register(ctx, in) } func (t *traceNetworkServiceEndpointRegistryServer) Find(in *registry.NetworkServiceEndpointQuery, s registry.NetworkServiceEndpointRegistry_FindServer) error { - operation := typeutils.GetFuncName(t.traced, methodNameFind) - ctx, finish := withLog(s.Context(), operation, methodNameFind) - defer finish() - - s = &traceNetworkServiceEndpointRegistryFindServer{ - NetworkServiceEndpointRegistry_FindServer: streamcontext.NetworkServiceEndpointRegistryFindServer(ctx, s), + switch logrus.GetLevel() { + case logrus.TraceLevel: + return t.verbose.Find(in, s) + case logrus.InfoLevel, logrus.DebugLevel: + return t.concise.Find(in, s) } - logObjectTrace(ctx, "find", in) - - // Actually call the next - err := t.traced.Find(in, s) - if err != nil { - return logError(ctx, err, operation) - } - logObjectTrace(ctx, "find-response", in) - - return nil + return next.NetworkServiceEndpointRegistryServer(s.Context()).Find(in, s) } func (t *traceNetworkServiceEndpointRegistryServer) Unregister(ctx context.Context, in *registry.NetworkServiceEndpoint) (*empty.Empty, error) { - operation := typeutils.GetFuncName(t.traced, methodNameUnregister) - ctx, finish := withLog(ctx, operation, methodNameUnregister) - defer finish() - - logObjectTrace(ctx, "unregister", in) - - // Actually call the next - rv, err := t.traced.Unregister(ctx, in) - if err != nil { - return nil, logError(ctx, err, operation) - } - logObjectTrace(ctx, "unregister-response", rv) - return rv, nil -} - -// NewNetworkServiceEndpointRegistryServer - wraps registry.NetworkServiceEndpointRegistryServer with tracing -func NewNetworkServiceEndpointRegistryServer(traced registry.NetworkServiceEndpointRegistryServer) registry.NetworkServiceEndpointRegistryServer { - return &traceNetworkServiceEndpointRegistryServer{traced: traced} -} - -type traceNetworkServiceEndpointRegistryFindServer struct { - registry.NetworkServiceEndpointRegistry_FindServer -} - -func (t *traceNetworkServiceEndpointRegistryFindServer) Send(nseResp *registry.NetworkServiceEndpointResponse) error { - operation := typeutils.GetFuncName(t.NetworkServiceEndpointRegistry_FindServer, methodNameSend) - ctx, finish := withLog(t.Context(), operation, methodNameSend) - defer finish() - - logObjectTrace(ctx, "network service endpoint", nseResp.NetworkServiceEndpoint) - s := streamcontext.NetworkServiceEndpointRegistryFindServer(ctx, t.NetworkServiceEndpointRegistry_FindServer) - err := s.Send(nseResp) - if err != nil { - return logError(ctx, err, operation) + switch logrus.GetLevel() { + case logrus.TraceLevel: + return t.verbose.Unregister(ctx, in) + case logrus.InfoLevel, logrus.DebugLevel: + return t.concise.Unregister(ctx, in) } - return nil + return next.NetworkServiceEndpointRegistryServer(ctx).Unregister(ctx, in) } diff --git a/pkg/registry/core/trace/testutil/testutil.go b/pkg/registry/core/trace/testutil/testutil.go new file mode 100644 index 000000000..9ff72ac02 --- /dev/null +++ b/pkg/registry/core/trace/testutil/testutil.go @@ -0,0 +1,185 @@ +// Copyright (c) 2023 Doc.ai and/or its affiliates. +// +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at: +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package testutil has few util functions for testing +package testutil + +import ( + "context" + "fmt" + "strings" + + "github.com/pkg/errors" + + "github.com/golang/protobuf/ptypes/empty" + "github.com/networkservicemesh/api/pkg/api/networkservice" + "github.com/networkservicemesh/api/pkg/api/networkservice/mechanisms/cls" + + "github.com/networkservicemesh/sdk/pkg/networkservice/core/next" +) + +// NewConnection - create connection for testing +func NewConnection() *networkservice.NetworkServiceRequest { + return &networkservice.NetworkServiceRequest{ + Connection: &networkservice.Connection{ + Id: "conn-1", + Context: &networkservice.ConnectionContext{ + IpContext: &networkservice.IPContext{ + SrcIpRequired: true, + }, + }, + }, + MechanismPreferences: []*networkservice.Mechanism{ + { + Type: "KERNEL", + Cls: cls.LOCAL, + }, + { + Type: "KERNEL", + Cls: cls.LOCAL, + Parameters: map[string]string{ + "label": "v2", + }, + }, + }, + } +} + +// LabelChangerFirstServer - common server for testing +type LabelChangerFirstServer struct{} + +// Request - test request +func (c *LabelChangerFirstServer) Request(ctx context.Context, request *networkservice.NetworkServiceRequest) (*networkservice.Connection, error) { + request.Connection.Labels = map[string]string{ + "Label": "A", + } + rv, err := next.Server(ctx).Request(ctx, request) + if err != nil { + return nil, err + } + rv.Labels = map[string]string{ + "Label": "D", + } + return rv, err +} + +// Close - test request +func (c *LabelChangerFirstServer) Close(ctx context.Context, connection *networkservice.Connection) (*empty.Empty, error) { + connection.Labels = map[string]string{ + "Label": "W", + } + r, err := next.Server(ctx).Close(ctx, connection) + connection.Labels = map[string]string{ + "Label": "Z", + } + return r, err +} + +// LabelChangerSecondServer - common server for testing +type LabelChangerSecondServer struct{} + +// Request - test request +func (c *LabelChangerSecondServer) Request(ctx context.Context, request *networkservice.NetworkServiceRequest) (*networkservice.Connection, error) { + request.Connection.Labels = map[string]string{ + "Label": "B", + } + rv, err := next.Server(ctx).Request(ctx, request) + if err != nil { + return nil, err + } + rv.Labels = map[string]string{ + "Label": "C", + } + return rv, err +} + +// Close - test request +func (c *LabelChangerSecondServer) Close(ctx context.Context, connection *networkservice.Connection) (*empty.Empty, error) { + connection.Labels = map[string]string{ + "Label": "X", + } + r, err := next.Server(ctx).Close(ctx, connection) + connection.Labels = map[string]string{ + "Label": "Y", + } + return r, err +} + +// CustomError - custom error for testing +type CustomError struct{} + +// Error - error message example +func (*CustomError) Error() string { + return `Error returned from api/pkg/api/networkservice/networkServiceClient.Close +github.com/networkservicemesh/sdk/pkg/networkservice/core/trace.(*beginTraceClient).Close + /root/go/pkg/mod/github.com/networkservicemesh/sdk@v0.5.1-0.20210929180427-ec235de055f1/pkg/networkservice/core/trace/client.go:85 +github.com/networkservicemesh/sdk/pkg/networkservice/core/next.(*nextClient).Close + /root/go/pkg/mod/github.com/networkservicemesh/sdk@v0.5.1-0.20210929180427-ec235de055f1/pkg/networkservice/core/next/client.go:65 +github.com/networkservicemesh/sdk/pkg/networkservice/core/next.(*nextClient).Close + /root/go/pkg/mod/github.com/networkservicemesh/sdk@v0.5.1-0.20210929180427-ec235de055f1/pkg/networkservice/core/next/client.go:65 +github.com/networkservicemesh/sdk/pkg/networkservice/core/trace.(*endTraceClient).Close + /root/go/pkg/mod/github.com/networkservicemesh/sdk@v0.5.1-0.20210929180427-ec235de055f1/pkg/networkservice/core/trace/client.go:106 +github.com/networkservicemesh/sdk/pkg/networkservice/core/next.(*nextClient).Close + /root/go/pkg/mod/github.com/networkservicemesh/sdk@v0.5.1-0.20210929180427-ec235de055f1/pkg/networkservice/core/next/client.go:65` +} + +// StackTrace - testing errors utility +func (*CustomError) StackTrace() errors.StackTrace { + return []errors.Frame{} +} + +// ErrorServer - error server for testing +type ErrorServer struct{} + +// Request - test request +func (c *ErrorServer) Request(ctx context.Context, request *networkservice.NetworkServiceRequest) (*networkservice.Connection, error) { + request.Connection.Labels = map[string]string{ + "Label": "B", + } + + _, _ = next.Server(ctx).Request(ctx, request) + + return nil, &CustomError{} +} + +// Close - test request +func (c *ErrorServer) Close(ctx context.Context, connection *networkservice.Connection) (*empty.Empty, error) { + return next.Server(ctx).Close(ctx, connection) +} + +// TrimLogTime - to format logs +func TrimLogTime(buff fmt.Stringer) string { + // Logger created by the trace chain element uses custom formatter, which prints date and time info in each line + // To check if output matches our expectations, we need to somehow get rid of this info. + // We have the following options: + // 1. Configure formatter options on logger creation in trace element + // 2. Use some global configuration (either set global default formatter + // instead of creating it in trace element or use global config for our formatter) + // 3. Remove datetime information from the output + // Since we are unlikely to need to remove date in any case except these tests, + // it seems like the third option would be the most convenient. + result := "" + datetimeLength := 19 + for _, line := range strings.Split(buff.String(), "\n") { + if len(line) > datetimeLength { + result += line[datetimeLength:] + "\n" + } else { + result += line + } + } + + return result +} diff --git a/pkg/registry/core/debug/common.go b/pkg/registry/core/trace/traceconcise/common.go similarity index 77% rename from pkg/registry/core/debug/common.go rename to pkg/registry/core/trace/traceconcise/common.go index f1e657e5a..8a01a41b6 100644 --- a/pkg/registry/core/debug/common.go +++ b/pkg/registry/core/trace/traceconcise/common.go @@ -1,4 +1,4 @@ -// Copyright (c) 2023 Doc.ai and/or its affiliates. +// Copyright (c) 2023 Cisco and/or its affiliates. // // SPDX-License-Identifier: Apache-2.0 // @@ -14,7 +14,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -package debug +package traceconcise import ( "context" @@ -35,11 +35,16 @@ const ( ) func logError(ctx context.Context, err error, operation string) error { - log.FromContext(ctx).Errorf("%v", errors.Wrapf(err, "Error returned from %s", operation)) + if log.IsTracingEnabled() { + log.FromContext(ctx).Errorf("%v", errors.Wrapf(err, "Error returned from %s", operation)) + } return err } -func logObjectDebug(ctx context.Context, k, v interface{}) { +func logObject(ctx context.Context, k, v interface{}) { + if !log.IsTracingEnabled() { + return + } s := log.FromContext(ctx) msg := "" cc, err := json.Marshal(v) @@ -48,5 +53,5 @@ func logObjectDebug(ctx context.Context, k, v interface{}) { } else { msg = fmt.Sprint(v) } - s.Debugf("%v=%s", k, msg) + s.Infof("%v=%s", k, msg) } diff --git a/pkg/registry/core/trace/traceconcise/context_ns.go b/pkg/registry/core/trace/traceconcise/context_ns.go new file mode 100644 index 000000000..dd5b5e01e --- /dev/null +++ b/pkg/registry/core/trace/traceconcise/context_ns.go @@ -0,0 +1,235 @@ +// Copyright (c) 2023 Cisco and/or its affiliates. +// +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at: +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package traceconcise + +import ( + "context" + + "github.com/networkservicemesh/api/pkg/api/registry" + + "github.com/networkservicemesh/sdk/pkg/tools/grpcutils" + "github.com/networkservicemesh/sdk/pkg/tools/log" + "github.com/networkservicemesh/sdk/pkg/tools/log/logruslogger" + "github.com/networkservicemesh/sdk/pkg/tools/log/spanlogger" +) + +type contextKeyType string + +const ( + conciseNsInfoKey contextKeyType = "conciseNsInfoLogRegistry" + loggedType string = "registry" +) + +type conciseNsInfo struct { + nsClientRegisterTail registry.NetworkServiceRegistryClient + nsClientFindHead registry.NetworkServiceRegistry_FindClient + nsClientFindTail registry.NetworkServiceRegistry_FindClient + nsClientUnregisterTail registry.NetworkServiceRegistryClient + + nsClientRegisterError error + nsClientFindError error + nsClientUnregisterError error + nsClientRecvError error + + nsServerRegisterTail registry.NetworkServiceRegistryServer + nsServerFindHead registry.NetworkServiceRegistry_FindServer + nsServerFindTail registry.NetworkServiceRegistry_FindServer + nsServerUnregisterTail registry.NetworkServiceRegistryServer + + nsServerRegisterError error + nsServerFindError error + nsServerUnregisterError error + nsServerSendError error +} + +// withLog - provides corresponding logger in context +func withLog(parent context.Context, methodName string) (c context.Context, f func()) { + if parent == nil { + panic("cannot create context from nil parent") + } + + // Update outgoing grpc context + parent = grpcutils.PassTraceToOutgoing(parent) + + fields := []*log.Field{log.NewField("type", loggedType)} + + ctx, sLogger, span, sFinish := spanlogger.FromContext(parent, "", methodName, fields) + ctx, lLogger, lFinish := logruslogger.FromSpan(ctx, span, "", fields) + ctx = log.WithLog(ctx, sLogger, lLogger) + + return ctx, func() { + sFinish() + lFinish() + } +} + +func conciseNsInfoFromCtx(ctx context.Context) (context.Context, *conciseNsInfo) { + if ctx == nil { + panic("cannot create context from nil parent") + } + + v, ok := ctx.Value(conciseNsInfoKey).(*conciseNsInfo) + if ok { + return ctx, v + } + v = new(conciseNsInfo) + return context.WithValue(ctx, conciseNsInfoKey, v), v +} + +func withNsClientRegisterTail(ctx context.Context, client registry.NetworkServiceRegistryClient) context.Context { + c, d := conciseNsInfoFromCtx(ctx) + d.nsClientRegisterTail = client + return c +} + +func nsClientRegisterTail(ctx context.Context) (context.Context, registry.NetworkServiceRegistryClient) { + c, d := conciseNsInfoFromCtx(ctx) + return c, d.nsClientRegisterTail +} + +func loadAndStoreNsClientRegisterError(ctx context.Context, err error) (prevErr error) { + _, d := conciseNsInfoFromCtx(ctx) + prevErr = d.nsClientRegisterError + d.nsClientRegisterError = err + return prevErr +} + +func withNsClientFindHead(ctx context.Context, client registry.NetworkServiceRegistry_FindClient) context.Context { + c, d := conciseNsInfoFromCtx(ctx) + d.nsClientFindHead = client + return c +} + +func nsClientFindHead(ctx context.Context) (context.Context, registry.NetworkServiceRegistry_FindClient) { + c, d := conciseNsInfoFromCtx(ctx) + return c, d.nsClientFindHead +} + +func withNsClientFindTail(ctx context.Context, client registry.NetworkServiceRegistry_FindClient) context.Context { + c, d := conciseNsInfoFromCtx(ctx) + d.nsClientFindTail = client + return c +} + +func nsClientFindTail(ctx context.Context) (context.Context, registry.NetworkServiceRegistry_FindClient) { + c, d := conciseNsInfoFromCtx(ctx) + return c, d.nsClientFindTail +} + +func loadAndStoreNsClientFindError(ctx context.Context, err error) (prevErr error) { + _, d := conciseNsInfoFromCtx(ctx) + prevErr = d.nsClientFindError + d.nsClientFindError = err + return prevErr +} + +func withNsClientUnregisterTail(ctx context.Context, client registry.NetworkServiceRegistryClient) context.Context { + c, d := conciseNsInfoFromCtx(ctx) + d.nsClientUnregisterTail = client + return c +} + +func nsClientUnregisterTail(ctx context.Context) (context.Context, registry.NetworkServiceRegistryClient) { + c, d := conciseNsInfoFromCtx(ctx) + return c, d.nsClientUnregisterTail +} + +func loadAndStoreNsClientUnregisterError(ctx context.Context, err error) (prevErr error) { + _, d := conciseNsInfoFromCtx(ctx) + prevErr = d.nsClientUnregisterError + d.nsClientUnregisterError = err + return prevErr +} + +func loadAndStoreNsClientRecvError(ctx context.Context, err error) (prevErr error) { + _, d := conciseNsInfoFromCtx(ctx) + prevErr = d.nsClientRecvError + d.nsClientRecvError = err + return prevErr +} + +func withNsServerRegisterTail(ctx context.Context, server registry.NetworkServiceRegistryServer) context.Context { + c, d := conciseNsInfoFromCtx(ctx) + d.nsServerRegisterTail = server + return c +} + +func nsServerRegisterTail(ctx context.Context) (context.Context, registry.NetworkServiceRegistryServer) { + c, d := conciseNsInfoFromCtx(ctx) + return c, d.nsServerRegisterTail +} + +func loadAndStoreNsServerRegisterError(ctx context.Context, err error) (prevErr error) { + _, d := conciseNsInfoFromCtx(ctx) + prevErr = d.nsServerRegisterError + d.nsServerRegisterError = err + return prevErr +} + +func withNsServerFindHead(ctx context.Context, server registry.NetworkServiceRegistry_FindServer) context.Context { + c, d := conciseNsInfoFromCtx(ctx) + d.nsServerFindHead = server + return c +} + +func nsServerFindHead(ctx context.Context) (context.Context, registry.NetworkServiceRegistry_FindServer) { + c, d := conciseNsInfoFromCtx(ctx) + return c, d.nsServerFindHead +} + +func withNsServerFindTail(ctx context.Context, server registry.NetworkServiceRegistry_FindServer) context.Context { + c, d := conciseNsInfoFromCtx(ctx) + d.nsServerFindTail = server + return c +} + +func nsServerFindTail(ctx context.Context) (context.Context, registry.NetworkServiceRegistry_FindServer) { + c, d := conciseNsInfoFromCtx(ctx) + return c, d.nsServerFindTail +} + +func loadAndStoreNsServerFindError(ctx context.Context, err error) (prevErr error) { + _, d := conciseNsInfoFromCtx(ctx) + prevErr = d.nsServerFindError + d.nsServerFindError = err + return prevErr +} + +func withNsServerUnregisterTail(ctx context.Context, server registry.NetworkServiceRegistryServer) context.Context { + c, d := conciseNsInfoFromCtx(ctx) + d.nsServerUnregisterTail = server + return c +} + +func nsServerUnregisterTail(ctx context.Context) (context.Context, registry.NetworkServiceRegistryServer) { + c, d := conciseNsInfoFromCtx(ctx) + return c, d.nsServerUnregisterTail +} + +func loadAndStoreNsServerUnregisterError(ctx context.Context, err error) (prevErr error) { + _, d := conciseNsInfoFromCtx(ctx) + prevErr = d.nsServerUnregisterError + d.nsServerUnregisterError = err + return prevErr +} + +func loadAndStoreNsServerSendError(ctx context.Context, err error) (prevErr error) { + _, d := conciseNsInfoFromCtx(ctx) + prevErr = d.nsServerSendError + d.nsServerSendError = err + return prevErr +} diff --git a/pkg/registry/core/trace/traceconcise/context_nse.go b/pkg/registry/core/trace/traceconcise/context_nse.go new file mode 100644 index 000000000..a45190bf7 --- /dev/null +++ b/pkg/registry/core/trace/traceconcise/context_nse.go @@ -0,0 +1,206 @@ +// Copyright (c) 2023 Cisco and/or its affiliates. +// +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at: +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package traceconcise + +import ( + "context" + + "github.com/networkservicemesh/api/pkg/api/registry" +) + +const ( + conciseNseInfoKey contextKeyType = "conciseNseInfoLogRegistry" +) + +type conciseNseInfo struct { + nseClientRegisterTail registry.NetworkServiceEndpointRegistryClient + nseClientFindHead registry.NetworkServiceEndpointRegistry_FindClient + nseClientFindTail registry.NetworkServiceEndpointRegistry_FindClient + nseClientUnregisterTail registry.NetworkServiceEndpointRegistryClient + + nseClientRegisterError error + nseClientFindError error + nseClientUnregisterError error + nseClientRecvError error + + nseServerRegisterTail registry.NetworkServiceEndpointRegistryServer + nseServerFindHead registry.NetworkServiceEndpointRegistry_FindServer + nseServerFindTail registry.NetworkServiceEndpointRegistry_FindServer + nseServerUnregisterTail registry.NetworkServiceEndpointRegistryServer + + nseServerRegisterError error + nseServerFindError error + nseServerUnregisterError error + nseServerSendError error +} + +func conciseNseInfoFromCtx(ctx context.Context) (context.Context, *conciseNseInfo) { + if ctx == nil { + panic("cannot create context from nil parent") + } + + v, ok := ctx.Value(conciseNseInfoKey).(*conciseNseInfo) + if ok { + return ctx, v + } + v = new(conciseNseInfo) + return context.WithValue(ctx, conciseNseInfoKey, v), v +} + +func withNseClientRegisterTail(ctx context.Context, client registry.NetworkServiceEndpointRegistryClient) context.Context { + c, d := conciseNseInfoFromCtx(ctx) + d.nseClientRegisterTail = client + return c +} + +func nseClientRegisterTail(ctx context.Context) (context.Context, registry.NetworkServiceEndpointRegistryClient) { + c, d := conciseNseInfoFromCtx(ctx) + return c, d.nseClientRegisterTail +} + +func loadAndStoreNseClientRegisterError(ctx context.Context, err error) (prevErr error) { + _, d := conciseNseInfoFromCtx(ctx) + prevErr = d.nseClientRegisterError + d.nseClientRegisterError = err + return prevErr +} + +func withNseClientFindHead(ctx context.Context, client registry.NetworkServiceEndpointRegistry_FindClient) context.Context { + c, d := conciseNseInfoFromCtx(ctx) + d.nseClientFindHead = client + return c +} + +func nseClientFindHead(ctx context.Context) (context.Context, registry.NetworkServiceEndpointRegistry_FindClient) { + c, d := conciseNseInfoFromCtx(ctx) + return c, d.nseClientFindHead +} + +func withNseClientFindTail(ctx context.Context, client registry.NetworkServiceEndpointRegistry_FindClient) context.Context { + c, d := conciseNseInfoFromCtx(ctx) + d.nseClientFindTail = client + return c +} + +func nseClientFindTail(ctx context.Context) (context.Context, registry.NetworkServiceEndpointRegistry_FindClient) { + c, d := conciseNseInfoFromCtx(ctx) + return c, d.nseClientFindTail +} + +func loadAndStoreNseClientFindError(ctx context.Context, err error) (prevErr error) { + _, d := conciseNseInfoFromCtx(ctx) + prevErr = d.nseClientFindError + d.nseClientFindError = err + return prevErr +} + +func withNseClientUnregisterTail(ctx context.Context, client registry.NetworkServiceEndpointRegistryClient) context.Context { + c, d := conciseNseInfoFromCtx(ctx) + d.nseClientUnregisterTail = client + return c +} + +func nseClientUnregisterTail(ctx context.Context) (context.Context, registry.NetworkServiceEndpointRegistryClient) { + c, d := conciseNseInfoFromCtx(ctx) + return c, d.nseClientUnregisterTail +} + +func loadAndStoreNseClientUnregisterError(ctx context.Context, err error) (prevErr error) { + _, d := conciseNseInfoFromCtx(ctx) + prevErr = d.nseClientUnregisterError + d.nseClientUnregisterError = err + return prevErr +} + +func loadAndStoreNseClientRecvError(ctx context.Context, err error) (prevErr error) { + _, d := conciseNseInfoFromCtx(ctx) + prevErr = d.nseClientRecvError + d.nseClientRecvError = err + return prevErr +} + +func withNseServerRegisterTail(ctx context.Context, server registry.NetworkServiceEndpointRegistryServer) context.Context { + c, d := conciseNseInfoFromCtx(ctx) + d.nseServerRegisterTail = server + return c +} + +func nseServerRegisterTail(ctx context.Context) (context.Context, registry.NetworkServiceEndpointRegistryServer) { + c, d := conciseNseInfoFromCtx(ctx) + return c, d.nseServerRegisterTail +} + +func loadAndStoreNseServerRegisterError(ctx context.Context, err error) (prevErr error) { + _, d := conciseNseInfoFromCtx(ctx) + prevErr = d.nseServerRegisterError + d.nseServerRegisterError = err + return prevErr +} + +func withNseServerFindHead(ctx context.Context, server registry.NetworkServiceEndpointRegistry_FindServer) context.Context { + c, d := conciseNseInfoFromCtx(ctx) + d.nseServerFindHead = server + return c +} + +func nseServerFindHead(ctx context.Context) (context.Context, registry.NetworkServiceEndpointRegistry_FindServer) { + c, d := conciseNseInfoFromCtx(ctx) + return c, d.nseServerFindHead +} + +func withNseServerFindTail(ctx context.Context, server registry.NetworkServiceEndpointRegistry_FindServer) context.Context { + c, d := conciseNseInfoFromCtx(ctx) + d.nseServerFindTail = server + return c +} + +func nseServerFindTail(ctx context.Context) (context.Context, registry.NetworkServiceEndpointRegistry_FindServer) { + c, d := conciseNseInfoFromCtx(ctx) + return c, d.nseServerFindTail +} + +func loadAndStoreNseServerFindError(ctx context.Context, err error) (prevErr error) { + _, d := conciseNseInfoFromCtx(ctx) + prevErr = d.nseServerFindError + d.nseServerFindError = err + return prevErr +} + +func withNseServerUnregisterTail(ctx context.Context, server registry.NetworkServiceEndpointRegistryServer) context.Context { + c, d := conciseNseInfoFromCtx(ctx) + d.nseServerUnregisterTail = server + return c +} + +func nseServerUnregisterTail(ctx context.Context) (context.Context, registry.NetworkServiceEndpointRegistryServer) { + c, d := conciseNseInfoFromCtx(ctx) + return c, d.nseServerUnregisterTail +} + +func loadAndStoreNseServerUnregisterError(ctx context.Context, err error) (prevErr error) { + _, d := conciseNseInfoFromCtx(ctx) + prevErr = d.nseServerUnregisterError + d.nseServerUnregisterError = err + return prevErr +} + +func loadAndStoreNseServerSendError(ctx context.Context, err error) (prevErr error) { + _, d := conciseNseInfoFromCtx(ctx) + prevErr = d.nseServerSendError + d.nseServerSendError = err + return prevErr +} diff --git a/pkg/registry/core/trace/traceconcise/ns_registry.go b/pkg/registry/core/trace/traceconcise/ns_registry.go new file mode 100644 index 000000000..560d25337 --- /dev/null +++ b/pkg/registry/core/trace/traceconcise/ns_registry.go @@ -0,0 +1,303 @@ +// Copyright (c) 2023 Cisco and/or its affiliates. +// +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at: +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package traceconcise provides a wrapper for concise tracing around a registry.{Registry,Discovery}{Server,Client} +package traceconcise + +import ( + "context" + "io" + + "github.com/golang/protobuf/ptypes/empty" + "github.com/pkg/errors" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "github.com/networkservicemesh/api/pkg/api/registry" + + "github.com/networkservicemesh/sdk/pkg/registry/core/streamcontext" + "github.com/networkservicemesh/sdk/pkg/tools/typeutils" +) + +type conciseNetworkServiceRegistryClient struct { + traced registry.NetworkServiceRegistryClient +} + +type conciseNetworkServiceRegistryFindClient struct { + registry.NetworkServiceRegistry_FindClient + operation string +} + +func (t *conciseNetworkServiceRegistryFindClient) Recv() (*registry.NetworkServiceResponse, error) { + ctx, finish := withLog(t.Context(), methodNameRecv) + defer finish() + + s := streamcontext.NetworkServiceRegistryFindClient(ctx, t.NetworkServiceRegistry_FindClient) + rv, err := s.Recv() + if err != nil { + if errors.Is(err, io.EOF) { + return nil, errors.WithStack(err) + } + if status.Code(err) == codes.Canceled { + return nil, errors.WithStack(err) + } + + lastError := loadAndStoreNsClientRecvError(ctx, err) + if lastError == nil || err.Error() != (lastError).Error() { + return nil, logError(ctx, err, t.operation) + } + return nil, err + } + + ctx, head := nsClientFindHead(ctx) + if head == t { + logObject(ctx, "ns-client-recv", rv) + } + + ctx, tail := nsClientFindTail(ctx) + if tail == t { + logObject(ctx, "ns-client-recv-response", rv) + } + return rv, nil +} + +func (t *conciseNetworkServiceRegistryClient) Register(ctx context.Context, in *registry.NetworkService, opts ...grpc.CallOption) (*registry.NetworkService, error) { + var finish func() + ctx, finish = withLog(ctx, methodNameRegister) + defer finish() + + ctx, tail := nsClientRegisterTail(ctx) + if tail == nil { + logObject(ctx, "ns-client-register", in) + } + ctx = withNsClientRegisterTail(ctx, t.traced) + + rv, err := t.traced.Register(ctx, in, opts...) + if err != nil { + lastError := loadAndStoreNsClientRegisterError(ctx, err) + if lastError == nil || err.Error() != (lastError).Error() { + operation := typeutils.GetFuncName(t.traced, methodNameRegister) + return nil, logError(ctx, err, operation) + } + return nil, err + } + + ctx, tail = nsClientRegisterTail(ctx) + if tail == t.traced { + logObject(ctx, "ns-client-register-response", rv) + } + return rv, nil +} + +func (t *conciseNetworkServiceRegistryClient) Find(ctx context.Context, in *registry.NetworkServiceQuery, opts ...grpc.CallOption) (registry.NetworkServiceRegistry_FindClient, error) { + var finish func() + ctx, finish = withLog(ctx, methodNameFind) + defer finish() + conciseFindClient := &conciseNetworkServiceRegistryFindClient{ + operation: typeutils.GetFuncName(t.traced, methodNameRecv), + } + + ctx, tail := nsClientFindTail(ctx) + if tail == nil { + logObject(ctx, "ns-client-find", in) + ctx = withNsClientFindHead(ctx, conciseFindClient) + } + ctx = withNsClientFindTail(ctx, conciseFindClient) + + // Actually call the next + rv, err := t.traced.Find(ctx, in, opts...) + if err != nil { + lastError := loadAndStoreNsClientFindError(ctx, err) + if lastError == nil || err.Error() != (lastError).Error() { + operation := typeutils.GetFuncName(t.traced, methodNameFind) + return nil, logError(ctx, err, operation) + } + return nil, err + } + + ctx, tail = nsClientFindTail(ctx) + if tail == conciseFindClient { + logObject(ctx, "ns-client-find-response", rv) + } + + conciseFindClient.NetworkServiceRegistry_FindClient = rv + return conciseFindClient, nil +} + +func (t *conciseNetworkServiceRegistryClient) Unregister(ctx context.Context, in *registry.NetworkService, opts ...grpc.CallOption) (*empty.Empty, error) { + var finish func() + ctx, finish = withLog(ctx, methodNameUnregister) + defer finish() + + ctx, tail := nsClientUnregisterTail(ctx) + if tail == nil { + logObject(ctx, "ns-client-unregister", in) + } + ctx = withNsClientUnregisterTail(ctx, t.traced) + + // Actually call the next + rv, err := t.traced.Unregister(ctx, in, opts...) + if err != nil { + lastError := loadAndStoreNsClientUnregisterError(ctx, err) + if lastError == nil || err.Error() != (lastError).Error() { + operation := typeutils.GetFuncName(t.traced, methodNameUnregister) + return nil, logError(ctx, err, operation) + } + return nil, err + } + ctx, tail = nsClientUnregisterTail(ctx) + if tail == t.traced { + logObject(ctx, "ns-client-unregister-response", in) + } + + return rv, nil +} + +// NewNetworkServiceRegistryClient - wraps registry.NetworkServiceRegistryClient with tracing +func NewNetworkServiceRegistryClient(traced registry.NetworkServiceRegistryClient) registry.NetworkServiceRegistryClient { + return &conciseNetworkServiceRegistryClient{traced: traced} +} + +type conciseNetworkServiceRegistryServer struct { + traced registry.NetworkServiceRegistryServer +} + +func (t *conciseNetworkServiceRegistryServer) Register(ctx context.Context, in *registry.NetworkService) (*registry.NetworkService, error) { + var finish func() + ctx, finish = withLog(ctx, methodNameRegister) + defer finish() + + ctx, tail := nsServerRegisterTail(ctx) + if tail == nil { + logObject(ctx, "ns-server-register", in) + } + ctx = withNsServerRegisterTail(ctx, t.traced) + + rv, err := t.traced.Register(ctx, in) + if err != nil { + lastError := loadAndStoreNsServerRegisterError(ctx, err) + if lastError == nil || err.Error() != (lastError).Error() { + operation := typeutils.GetFuncName(t.traced, methodNameRegister) + return nil, logError(ctx, err, operation) + } + return nil, err + } + + ctx, tail = nsServerRegisterTail(ctx) + if tail == t.traced { + logObject(ctx, "ns-server-register-response", rv) + } + return rv, nil +} + +func (t *conciseNetworkServiceRegistryServer) Find(in *registry.NetworkServiceQuery, s registry.NetworkServiceRegistry_FindServer) error { + ctx, finish := withLog(s.Context(), methodNameFind) + defer finish() + conciseFindServer := &conciseNetworkServiceRegistryFindServer{ + operation: typeutils.GetFuncName(t.traced, methodNameSend), + } + + ctx, tail := nsServerFindTail(ctx) + if tail == nil { + logObject(ctx, "ns-server-find", in) + ctx = withNsServerFindHead(ctx, conciseFindServer) + } + ctx = withNsServerFindTail(ctx, conciseFindServer) + + conciseFindServer.NetworkServiceRegistry_FindServer = streamcontext.NetworkServiceRegistryFindServer(ctx, s) + + // Actually call the next + err := t.traced.Find(in, conciseFindServer) + if err != nil { + lastError := loadAndStoreNsServerFindError(ctx, err) + if lastError == nil || err.Error() != (lastError).Error() { + operation := typeutils.GetFuncName(t.traced, methodNameFind) + return logError(ctx, err, operation) + } + return err + } + + ctx, tail = nsServerFindTail(ctx) + if tail == conciseFindServer { + logObject(ctx, "ns-server-find-response", in) + } + return nil +} + +func (t *conciseNetworkServiceRegistryServer) Unregister(ctx context.Context, in *registry.NetworkService) (*empty.Empty, error) { + var finish func() + ctx, finish = withLog(ctx, methodNameUnregister) + defer finish() + + ctx, tail := nsServerUnregisterTail(ctx) + if tail == nil { + logObject(ctx, "ns-server-unregister", in) + } + ctx = withNsServerUnregisterTail(ctx, t.traced) + + // Actually call the next + rv, err := t.traced.Unregister(ctx, in) + if err != nil { + lastError := loadAndStoreNsServerUnregisterError(ctx, err) + if lastError == nil || err.Error() != (lastError).Error() { + operation := typeutils.GetFuncName(t.traced, methodNameUnregister) + return nil, logError(ctx, err, operation) + } + return nil, err + } + + ctx, tail = nsServerUnregisterTail(ctx) + if tail == t.traced { + logObject(ctx, "ns-server-unregister-response", in) + } + return rv, nil +} + +// NewNetworkServiceRegistryServer - wraps registry.NetworkServiceRegistryServer with tracing +func NewNetworkServiceRegistryServer(traced registry.NetworkServiceRegistryServer) registry.NetworkServiceRegistryServer { + return &conciseNetworkServiceRegistryServer{traced: traced} +} + +type conciseNetworkServiceRegistryFindServer struct { + registry.NetworkServiceRegistry_FindServer + operation string +} + +func (t *conciseNetworkServiceRegistryFindServer) Send(nsResp *registry.NetworkServiceResponse) error { + ctx, finish := withLog(t.Context(), methodNameSend) + defer finish() + + ctx, tail := nsServerFindTail(ctx) + if tail == t { + logObject(ctx, "ns-server-send", nsResp) + } + + s := streamcontext.NetworkServiceRegistryFindServer(ctx, t.NetworkServiceRegistry_FindServer) + err := s.Send(nsResp) + if err != nil { + lastError := loadAndStoreNsServerSendError(ctx, err) + if lastError == nil || err.Error() != (lastError).Error() { + return logError(ctx, err, t.operation) + } + } + + ctx, head := nsServerFindHead(ctx) + if head == t { + logObject(ctx, "ns-server-send-response", nsResp) + } + return err +} diff --git a/pkg/registry/core/trace/traceconcise/nse_registry.go b/pkg/registry/core/trace/traceconcise/nse_registry.go new file mode 100644 index 000000000..204346521 --- /dev/null +++ b/pkg/registry/core/trace/traceconcise/nse_registry.go @@ -0,0 +1,301 @@ +// Copyright (c) 2023 Cisco and/or its affiliates. +// +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at: +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package traceconcise + +import ( + "context" + "io" + + "github.com/networkservicemesh/sdk/pkg/registry/core/streamcontext" + "github.com/networkservicemesh/sdk/pkg/tools/typeutils" + + "github.com/golang/protobuf/ptypes/empty" + "github.com/pkg/errors" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "github.com/networkservicemesh/api/pkg/api/registry" +) + +type conciseNetworkServiceEndpointRegistryClient struct { + traced registry.NetworkServiceEndpointRegistryClient +} + +type conciseNetworkServiceEndpointRegistryFindClient struct { + registry.NetworkServiceEndpointRegistry_FindClient + operation string +} + +func (t *conciseNetworkServiceEndpointRegistryFindClient) Recv() (*registry.NetworkServiceEndpointResponse, error) { + ctx, finish := withLog(t.Context(), methodNameRecv) + defer finish() + + s := streamcontext.NetworkServiceEndpointRegistryFindClient(ctx, t.NetworkServiceEndpointRegistry_FindClient) + rv, err := s.Recv() + if err != nil { + if errors.Is(err, io.EOF) { + return nil, errors.WithStack(err) + } + if status.Code(err) == codes.Canceled { + return nil, errors.WithStack(err) + } + + lastError := loadAndStoreNseClientRecvError(ctx, err) + if lastError == nil || err.Error() != (lastError).Error() { + return nil, logError(ctx, err, t.operation) + } + return nil, err + } + + ctx, tail := nseClientFindTail(ctx) + if tail == t { + logObject(ctx, "nse-client-recv-response", rv) + } + + ctx, head := nseClientFindHead(ctx) + if head == t { + logObject(ctx, "nse-client-recv", rv) + } + return rv, nil +} + +func (t *conciseNetworkServiceEndpointRegistryClient) Register(ctx context.Context, in *registry.NetworkServiceEndpoint, opts ...grpc.CallOption) (*registry.NetworkServiceEndpoint, error) { + var finish func() + ctx, finish = withLog(ctx, methodNameRegister) + defer finish() + + ctx, tail := nseClientRegisterTail(ctx) + if tail == nil { + logObject(ctx, "nse-client-register", in) + } + ctx = withNseClientRegisterTail(ctx, t.traced) + + rv, err := t.traced.Register(ctx, in, opts...) + if err != nil { + lastError := loadAndStoreNseClientRegisterError(ctx, err) + if lastError == nil || err.Error() != (lastError).Error() { + operation := typeutils.GetFuncName(t.traced, methodNameRegister) + return nil, logError(ctx, err, operation) + } + return nil, err + } + + ctx, tail = nseClientRegisterTail(ctx) + if tail == t.traced { + logObject(ctx, "nse-client-register-response", rv) + } + return rv, nil +} +func (t *conciseNetworkServiceEndpointRegistryClient) Find(ctx context.Context, in *registry.NetworkServiceEndpointQuery, opts ...grpc.CallOption) (registry.NetworkServiceEndpointRegistry_FindClient, error) { + var finish func() + ctx, finish = withLog(ctx, methodNameFind) + defer finish() + conciseFindClient := &conciseNetworkServiceEndpointRegistryFindClient{ + operation: typeutils.GetFuncName(t.traced, methodNameRecv), + } + + ctx, tail := nseClientFindTail(ctx) + if tail == nil { + logObject(ctx, "nse-client-find", in) + ctx = withNseClientFindHead(ctx, conciseFindClient) + } + ctx = withNseClientFindTail(ctx, conciseFindClient) + + // Actually call the next + rv, err := t.traced.Find(ctx, in, opts...) + if err != nil { + lastError := loadAndStoreNseClientFindError(ctx, err) + if lastError == nil || err.Error() != (lastError).Error() { + operation := typeutils.GetFuncName(t.traced, methodNameFind) + return nil, logError(ctx, err, operation) + } + return nil, err + } + + ctx, tail = nseClientFindTail(ctx) + if tail == conciseFindClient { + logObject(ctx, "nse-client-find-response", rv) + } + + conciseFindClient.NetworkServiceEndpointRegistry_FindClient = rv + return conciseFindClient, nil +} + +func (t *conciseNetworkServiceEndpointRegistryClient) Unregister(ctx context.Context, in *registry.NetworkServiceEndpoint, opts ...grpc.CallOption) (*empty.Empty, error) { + var finish func() + ctx, finish = withLog(ctx, methodNameUnregister) + defer finish() + + ctx, tail := nseClientUnregisterTail(ctx) + if tail == nil { + logObject(ctx, "nse-client-unregister", in) + } + ctx = withNseClientUnregisterTail(ctx, t.traced) + + // Actually call the next + rv, err := t.traced.Unregister(ctx, in, opts...) + if err != nil { + lastError := loadAndStoreNseClientUnregisterError(ctx, err) + if lastError == nil || err.Error() != (lastError).Error() { + operation := typeutils.GetFuncName(t.traced, methodNameUnregister) + return nil, logError(ctx, err, operation) + } + return nil, err + } + ctx, tail = nseClientUnregisterTail(ctx) + if tail == t.traced { + logObject(ctx, "nse-client-unregister-response", in) + } + + return rv, nil +} + +// NewNetworkServiceEndpointRegistryClient - wraps registry.NetworkServiceEndpointRegistryClient with tracing +func NewNetworkServiceEndpointRegistryClient(traced registry.NetworkServiceEndpointRegistryClient) registry.NetworkServiceEndpointRegistryClient { + return &conciseNetworkServiceEndpointRegistryClient{traced: traced} +} + +type conciseNetworkServiceEndpointRegistryServer struct { + traced registry.NetworkServiceEndpointRegistryServer +} + +func (t *conciseNetworkServiceEndpointRegistryServer) Register(ctx context.Context, in *registry.NetworkServiceEndpoint) (*registry.NetworkServiceEndpoint, error) { + var finish func() + ctx, finish = withLog(ctx, methodNameRegister) + defer finish() + + ctx, tail := nseServerRegisterTail(ctx) + if tail == nil { + logObject(ctx, "nse-server-register", in) + } + ctx = withNseServerRegisterTail(ctx, t.traced) + + rv, err := t.traced.Register(ctx, in) + if err != nil { + lastError := loadAndStoreNseServerRegisterError(ctx, err) + if lastError == nil || err.Error() != (lastError).Error() { + operation := typeutils.GetFuncName(t.traced, methodNameRegister) + return nil, logError(ctx, err, operation) + } + return nil, err + } + + ctx, tail = nseServerRegisterTail(ctx) + if tail == t.traced { + logObject(ctx, "nse-server-register-response", rv) + } + return rv, nil +} + +func (t *conciseNetworkServiceEndpointRegistryServer) Find(in *registry.NetworkServiceEndpointQuery, s registry.NetworkServiceEndpointRegistry_FindServer) error { + ctx, finish := withLog(s.Context(), methodNameFind) + defer finish() + conciseFindServer := &conciseNetworkServiceEndpointRegistryFindServer{ + operation: typeutils.GetFuncName(t.traced, methodNameSend), + } + + ctx, tail := nseServerFindTail(ctx) + if tail == nil { + logObject(ctx, "nse-server-find", in) + ctx = withNseServerFindHead(ctx, conciseFindServer) + } + ctx = withNseServerFindTail(ctx, conciseFindServer) + + conciseFindServer.NetworkServiceEndpointRegistry_FindServer = streamcontext.NetworkServiceEndpointRegistryFindServer(ctx, s) + + // Actually call the next + err := t.traced.Find(in, conciseFindServer) + if err != nil { + lastError := loadAndStoreNseServerFindError(ctx, err) + if lastError == nil || err.Error() != (lastError).Error() { + operation := typeutils.GetFuncName(t.traced, methodNameFind) + return logError(ctx, err, operation) + } + return err + } + + ctx, tail = nseServerFindTail(ctx) + if tail == conciseFindServer { + logObject(ctx, "nse-server-find-response", in) + } + return nil +} + +func (t *conciseNetworkServiceEndpointRegistryServer) Unregister(ctx context.Context, in *registry.NetworkServiceEndpoint) (*empty.Empty, error) { + var finish func() + ctx, finish = withLog(ctx, methodNameUnregister) + defer finish() + + ctx, tail := nseServerUnregisterTail(ctx) + if tail == nil { + logObject(ctx, "nse-server-unregister", in) + } + ctx = withNseServerUnregisterTail(ctx, t.traced) + + // Actually call the next + rv, err := t.traced.Unregister(ctx, in) + if err != nil { + lastError := loadAndStoreNseServerUnregisterError(ctx, err) + if lastError == nil || err.Error() != (lastError).Error() { + operation := typeutils.GetFuncName(t.traced, methodNameUnregister) + return nil, logError(ctx, err, operation) + } + return nil, err + } + + ctx, tail = nseServerUnregisterTail(ctx) + if tail == t.traced { + logObject(ctx, "nse-server-unregister-response", in) + } + return rv, nil +} + +// NewNetworkServiceEndpointRegistryServer - wraps registry.NetworkServiceEndpointRegistryServer with tracing +func NewNetworkServiceEndpointRegistryServer(traced registry.NetworkServiceEndpointRegistryServer) registry.NetworkServiceEndpointRegistryServer { + return &conciseNetworkServiceEndpointRegistryServer{traced: traced} +} + +type conciseNetworkServiceEndpointRegistryFindServer struct { + registry.NetworkServiceEndpointRegistry_FindServer + operation string +} + +func (t *conciseNetworkServiceEndpointRegistryFindServer) Send(nseResp *registry.NetworkServiceEndpointResponse) error { + ctx, finish := withLog(t.Context(), methodNameSend) + defer finish() + + ctx, tail := nseServerFindTail(ctx) + if tail == t { + logObject(ctx, "nse-server-send", nseResp) + } + + s := streamcontext.NetworkServiceEndpointRegistryFindServer(ctx, t.NetworkServiceEndpointRegistry_FindServer) + err := s.Send(nseResp) + if err != nil { + lastError := loadAndStoreNseServerSendError(ctx, err) + if lastError == nil || err.Error() != (lastError).Error() { + return logError(ctx, err, t.operation) + } + } + + ctx, head := nseServerFindHead(ctx) + if head == t { + logObject(ctx, "nse-server-send-response", nseResp) + } + return err +} diff --git a/pkg/registry/core/trace/traceconcise/traceconcise_test.go b/pkg/registry/core/trace/traceconcise/traceconcise_test.go new file mode 100644 index 000000000..fa5d48996 --- /dev/null +++ b/pkg/registry/core/trace/traceconcise/traceconcise_test.go @@ -0,0 +1,139 @@ +// Copyright (c) 2023 Cisco and/or its affiliates. +// +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at: +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package traceconcise_test has few tests for logs in concise mode +package traceconcise_test + +import ( + "bytes" + "context" + "testing" + + "github.com/networkservicemesh/api/pkg/api/registry" + "github.com/pkg/errors" + "github.com/sirupsen/logrus" + "go.uber.org/goleak" + + "github.com/networkservicemesh/sdk/pkg/networkservice/core/trace/testutil" + "github.com/networkservicemesh/sdk/pkg/registry/common/memory" + "github.com/networkservicemesh/sdk/pkg/registry/common/null" + "github.com/networkservicemesh/sdk/pkg/registry/core/chain" + "github.com/networkservicemesh/sdk/pkg/registry/core/streamchannel" + "github.com/networkservicemesh/sdk/pkg/registry/utils/inject/injecterror" + "github.com/networkservicemesh/sdk/pkg/tools/log" + + "github.com/stretchr/testify/require" +) + +func TestOutput(t *testing.T) { + t.Cleanup(func() { goleak.VerifyNone(t) }) + + var buff bytes.Buffer + logrus.SetOutput(&buff) + logrus.SetFormatter(&logrus.TextFormatter{ + DisableTimestamp: true, + }) + log.EnableTracing(true) + logrus.SetLevel(logrus.InfoLevel) + + s := chain.NewNetworkServiceEndpointRegistryServer( + memory.NewNetworkServiceEndpointRegistryServer(), + null.NewNetworkServiceEndpointRegistryServer(), + ) + + nse, err := s.Register(context.Background(), ®istry.NetworkServiceEndpoint{ + Name: "a", + }) + require.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + ch := make(chan *registry.NetworkServiceEndpointResponse, 1) + defer close(ch) + _ = s.Find(®istry.NetworkServiceEndpointQuery{ + NetworkServiceEndpoint: ®istry.NetworkServiceEndpoint{ + Name: "a", + }, + }, streamchannel.NewNetworkServiceEndpointFindServer(ctx, ch)) + + _, err = s.Unregister(context.Background(), nse) + require.NoError(t, err) + + expectedOutput := + "\x1b[36m [INFO] [type:registry] \x1b[0mnse-server-register={\"name\":\"a\"}\n" + + "\x1b[36m [INFO] [type:registry] \x1b[0mnse-server-register-response={\"name\":\"a\"}\n" + + "\x1b[36m [INFO] [type:registry] \x1b[0mnse-server-find={\"network_service_endpoint\":{\"name\":\"a\"}}\n" + + "\x1b[36m [INFO] [type:registry] \x1b[0mnse-server-send={\"network_service_endpoint\":{\"name\":\"a\"}}\n" + + "\x1b[36m [INFO] [type:registry] \x1b[0mnse-server-send-response={\"network_service_endpoint\":{\"name\":\"a\"}}\n" + + "\x1b[36m [INFO] [type:registry] \x1b[0mnse-server-find-response={\"network_service_endpoint\":{\"name\":\"a\"}}\n" + + "\x1b[36m [INFO] [type:registry] \x1b[0mnse-server-unregister={\"name\":\"a\"}\n" + + "\x1b[36m [INFO] [type:registry] \x1b[0mnse-server-unregister-response={\"name\":\"a\"}\n" + + result := testutil.TrimLogTime(&buff) + require.Equal(t, expectedOutput, result) +} + +func TestErrorOutput(t *testing.T) { + t.Cleanup(func() { goleak.VerifyNone(t) }) + + var buff bytes.Buffer + logrus.SetOutput(&buff) + logrus.SetFormatter(&logrus.TextFormatter{ + DisableTimestamp: true, + }) + log.EnableTracing(true) + logrus.SetLevel(logrus.InfoLevel) + + s := chain.NewNetworkServiceEndpointRegistryServer( + memory.NewNetworkServiceEndpointRegistryServer(), + injecterror.NewNetworkServiceEndpointRegistryServer( + injecterror.WithError(errors.New("test error")), + injecterror.WithRegisterErrorTimes(0), + injecterror.WithFindErrorTimes(0), + injecterror.WithUnregisterErrorTimes(0), + ), + ) + + nse, err := s.Register(context.Background(), ®istry.NetworkServiceEndpoint{ + Name: "a", + }) + require.Error(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + ch := make(chan *registry.NetworkServiceEndpointResponse, 1) + defer close(ch) + err = s.Find(®istry.NetworkServiceEndpointQuery{ + NetworkServiceEndpoint: ®istry.NetworkServiceEndpoint{ + Name: "a", + }, + }, streamchannel.NewNetworkServiceEndpointFindServer(ctx, ch)) + require.Error(t, err) + + _, err = s.Unregister(context.Background(), nse) + require.Error(t, err) + + expectedOutput := + "\x1b[36m [INFO] [type:registry] \x1b[0mnse-server-register={\"name\":\"a\"}\n" + + "\x1b[31m [ERRO] [type:registry] \x1b[0mError returned from sdk/pkg/registry/utils/inject/injecterror/injectErrorNSEServer.Register: test error\n" + + "\x1b[36m [INFO] [type:registry] \x1b[0mnse-server-find={\"network_service_endpoint\":{\"name\":\"a\"}}\n" + + "\x1b[31m [ERRO] [type:registry] \x1b[0mError returned from sdk/pkg/registry/utils/inject/injecterror/injectErrorNSEServer.Find: test error\n" + + "\x1b[36m [INFO] [type:registry] \x1b[0mnse-server-unregister=null\n" + + "\x1b[31m [ERRO] [type:registry] \x1b[0mError returned from sdk/pkg/registry/utils/inject/injecterror/injectErrorNSEServer.Unregister: test error\n" + + result := testutil.TrimLogTime(&buff) + require.Equal(t, expectedOutput, result) +} diff --git a/pkg/registry/core/trace/common.go b/pkg/registry/core/trace/traceverbose/common.go similarity index 98% rename from pkg/registry/core/trace/common.go rename to pkg/registry/core/trace/traceverbose/common.go index d0eafd91d..ee96d7c71 100644 --- a/pkg/registry/core/trace/common.go +++ b/pkg/registry/core/trace/traceverbose/common.go @@ -16,7 +16,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -package trace +package traceverbose import ( "context" diff --git a/pkg/registry/core/trace/context.go b/pkg/registry/core/trace/traceverbose/context.go similarity index 99% rename from pkg/registry/core/trace/context.go rename to pkg/registry/core/trace/traceverbose/context.go index 47ef2f1f5..fe6e6121a 100644 --- a/pkg/registry/core/trace/context.go +++ b/pkg/registry/core/trace/traceverbose/context.go @@ -16,7 +16,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -package trace +package traceverbose import ( "context" diff --git a/pkg/registry/core/trace/traceverbose/ns_registry.go b/pkg/registry/core/trace/traceverbose/ns_registry.go new file mode 100644 index 000000000..232c13745 --- /dev/null +++ b/pkg/registry/core/trace/traceverbose/ns_registry.go @@ -0,0 +1,195 @@ +// Copyright (c) 2020-2022 Doc.ai and/or its affiliates. +// +// Copyright (c) 2023 Cisco and/or its affiliates. +// +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at: +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package traceverbose provides a wrapper for tracing around a registry.{Registry,Discovery}{Server,Client} +package traceverbose + +import ( + "context" + "io" + + "github.com/networkservicemesh/sdk/pkg/registry/core/streamcontext" + "github.com/networkservicemesh/sdk/pkg/tools/typeutils" + + "github.com/golang/protobuf/ptypes/empty" + "github.com/pkg/errors" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "github.com/networkservicemesh/api/pkg/api/registry" +) + +type traceNetworkServiceRegistryClient struct { + traced registry.NetworkServiceRegistryClient +} + +type traceNetworkServiceRegistryFindClient struct { + registry.NetworkServiceRegistry_FindClient + operation string +} + +func (t *traceNetworkServiceRegistryFindClient) Recv() (*registry.NetworkServiceResponse, error) { + ctx, finish := withLog(t.Context(), t.operation, methodNameRecv) + defer finish() + + s := streamcontext.NetworkServiceRegistryFindClient(ctx, t.NetworkServiceRegistry_FindClient) + rv, err := s.Recv() + + if err != nil { + if errors.Is(err, io.EOF) { + return nil, errors.WithStack(err) + } + if status.Code(err) == codes.Canceled { + return nil, errors.WithStack(err) + } + return nil, logError(ctx, err, t.operation) + } + logObjectTrace(ctx, "recv-response", rv.NetworkService) + return rv, nil +} + +func (t *traceNetworkServiceRegistryClient) Register(ctx context.Context, in *registry.NetworkService, opts ...grpc.CallOption) (*registry.NetworkService, error) { + operation := typeutils.GetFuncName(t.traced, methodNameRegister) + ctx, finish := withLog(ctx, operation, methodNameRegister) + defer finish() + + logObjectTrace(ctx, "register", in) + + rv, err := t.traced.Register(ctx, in, opts...) + if err != nil { + return nil, logError(ctx, err, operation) + } + logObjectTrace(ctx, "register-response", rv) + return rv, nil +} +func (t *traceNetworkServiceRegistryClient) Find(ctx context.Context, in *registry.NetworkServiceQuery, opts ...grpc.CallOption) (registry.NetworkServiceRegistry_FindClient, error) { + operation := typeutils.GetFuncName(t.traced, methodNameFind) + ctx, finish := withLog(ctx, operation, methodNameFind) + defer finish() + + logObjectTrace(ctx, "find", in) + + // Actually call the next + rv, err := t.traced.Find(ctx, in, opts...) + if err != nil { + return nil, logError(ctx, err, operation) + } + logObjectTrace(ctx, "find-response", rv) + + return &traceNetworkServiceRegistryFindClient{NetworkServiceRegistry_FindClient: rv, operation: typeutils.GetFuncName(t.traced, methodNameRecv)}, nil +} + +func (t *traceNetworkServiceRegistryClient) Unregister(ctx context.Context, in *registry.NetworkService, opts ...grpc.CallOption) (*empty.Empty, error) { + operation := typeutils.GetFuncName(t.traced, methodNameUnregister) + ctx, finish := withLog(ctx, operation, methodNameUnregister) + defer finish() + + logObjectTrace(ctx, "unregister", in) + + // Actually call the next + rv, err := t.traced.Unregister(ctx, in, opts...) + if err != nil { + return nil, logError(ctx, err, operation) + } + logObjectTrace(ctx, "unregister-response", rv) + return rv, nil +} + +// NewNetworkServiceRegistryClient - wraps registry.NetworkServiceRegistryClient with tracing +func NewNetworkServiceRegistryClient(traced registry.NetworkServiceRegistryClient) registry.NetworkServiceRegistryClient { + return &traceNetworkServiceRegistryClient{traced: traced} +} + +type traceNetworkServiceRegistryServer struct { + traced registry.NetworkServiceRegistryServer +} + +func (t *traceNetworkServiceRegistryServer) Register(ctx context.Context, in *registry.NetworkService) (*registry.NetworkService, error) { + operation := typeutils.GetFuncName(t.traced, methodNameRegister) + ctx, finish := withLog(ctx, operation, methodNameRegister) + defer finish() + + logObjectTrace(ctx, "register", in) + + rv, err := t.traced.Register(ctx, in) + if err != nil { + return nil, logError(ctx, err, operation) + } + logObjectTrace(ctx, "register-response", rv) + return rv, nil +} + +func (t *traceNetworkServiceRegistryServer) Find(in *registry.NetworkServiceQuery, s registry.NetworkServiceRegistry_FindServer) error { + operation := typeutils.GetFuncName(t.traced, methodNameFind) + ctx, finish := withLog(s.Context(), operation, methodNameFind) + defer finish() + + s = &traceNetworkServiceRegistryFindServer{ + NetworkServiceRegistry_FindServer: streamcontext.NetworkServiceRegistryFindServer(ctx, s), + operation: typeutils.GetFuncName(t.traced, methodNameSend), + } + logObjectTrace(ctx, "find", in) + + // Actually call the next + err := t.traced.Find(in, s) + if err != nil { + return logError(ctx, err, operation) + } + return nil +} + +func (t *traceNetworkServiceRegistryServer) Unregister(ctx context.Context, in *registry.NetworkService) (*empty.Empty, error) { + operation := typeutils.GetFuncName(t.traced, methodNameUnregister) + ctx, finish := withLog(ctx, operation, methodNameUnregister) + defer finish() + + logObjectTrace(ctx, "unregister", in) + + // Actually call the next + rv, err := t.traced.Unregister(ctx, in) + if err != nil { + return nil, logError(ctx, err, operation) + } + logObjectTrace(ctx, "unregister-response", rv) + return rv, nil +} + +// NewNetworkServiceRegistryServer - wraps registry.NetworkServiceRegistryServer with tracing +func NewNetworkServiceRegistryServer(traced registry.NetworkServiceRegistryServer) registry.NetworkServiceRegistryServer { + return &traceNetworkServiceRegistryServer{traced: traced} +} + +type traceNetworkServiceRegistryFindServer struct { + registry.NetworkServiceRegistry_FindServer + operation string +} + +func (t *traceNetworkServiceRegistryFindServer) Send(nsResp *registry.NetworkServiceResponse) error { + ctx, finish := withLog(t.Context(), t.operation, methodNameSend) + defer finish() + + logObjectTrace(ctx, "network service", nsResp.NetworkService) + + s := streamcontext.NetworkServiceRegistryFindServer(ctx, t.NetworkServiceRegistry_FindServer) + err := s.Send(nsResp) + if err != nil { + return logError(ctx, err, t.operation) + } + return nil +} diff --git a/pkg/registry/core/trace/traceverbose/nse_registry.go b/pkg/registry/core/trace/traceverbose/nse_registry.go new file mode 100644 index 000000000..e44fa298a --- /dev/null +++ b/pkg/registry/core/trace/traceverbose/nse_registry.go @@ -0,0 +1,194 @@ +// Copyright (c) 2020-2022 Doc.ai and/or its affiliates. +// +// Copyright (c) 2023 Cisco and/or its affiliates. +// +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at: +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package traceverbose + +import ( + "context" + "io" + + "github.com/networkservicemesh/sdk/pkg/registry/core/streamcontext" + "github.com/networkservicemesh/sdk/pkg/tools/typeutils" + + "github.com/golang/protobuf/ptypes/empty" + "github.com/pkg/errors" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "github.com/networkservicemesh/api/pkg/api/registry" +) + +type traceNetworkServiceEndpointRegistryClient struct { + traced registry.NetworkServiceEndpointRegistryClient +} + +type traceNetworkServiceEndpointRegistryFindClient struct { + registry.NetworkServiceEndpointRegistry_FindClient + operation string +} + +func (t *traceNetworkServiceEndpointRegistryFindClient) Recv() (*registry.NetworkServiceEndpointResponse, error) { + ctx, finish := withLog(t.Context(), t.operation, methodNameRecv) + defer finish() + + s := streamcontext.NetworkServiceEndpointRegistryFindClient(ctx, t.NetworkServiceEndpointRegistry_FindClient) + rv, err := s.Recv() + + if err != nil { + if errors.Is(err, io.EOF) { + return nil, errors.WithStack(err) + } + if status.Code(err) == codes.Canceled { + return nil, errors.WithStack(err) + } + return nil, logError(ctx, err, t.operation) + } + logObjectTrace(ctx, "recv-response", rv) + return rv, nil +} + +func (t *traceNetworkServiceEndpointRegistryClient) Register(ctx context.Context, in *registry.NetworkServiceEndpoint, opts ...grpc.CallOption) (*registry.NetworkServiceEndpoint, error) { + operation := typeutils.GetFuncName(t.traced, methodNameRegister) + ctx, finish := withLog(ctx, operation, methodNameRegister) + defer finish() + + logObjectTrace(ctx, "register", in) + rv, err := t.traced.Register(ctx, in, opts...) + if err != nil { + return nil, logError(ctx, err, operation) + } + logObjectTrace(ctx, "register-response", rv) + return rv, nil +} +func (t *traceNetworkServiceEndpointRegistryClient) Find(ctx context.Context, in *registry.NetworkServiceEndpointQuery, opts ...grpc.CallOption) (registry.NetworkServiceEndpointRegistry_FindClient, error) { + operation := typeutils.GetFuncName(t.traced, methodNameFind) + ctx, finish := withLog(ctx, operation, methodNameFind) + defer finish() + + logObjectTrace(ctx, "find", in) + + // Actually call the next + rv, err := t.traced.Find(ctx, in, opts...) + if err != nil { + return nil, logError(ctx, err, operation) + } + logObjectTrace(ctx, "find-response", rv) + + return &traceNetworkServiceEndpointRegistryFindClient{NetworkServiceEndpointRegistry_FindClient: rv, operation: typeutils.GetFuncName(t.traced, methodNameRecv)}, nil +} + +func (t *traceNetworkServiceEndpointRegistryClient) Unregister(ctx context.Context, in *registry.NetworkServiceEndpoint, opts ...grpc.CallOption) (*empty.Empty, error) { + operation := typeutils.GetFuncName(t.traced, methodNameUnregister) + ctx, finish := withLog(ctx, operation, methodNameUnregister) + defer finish() + + logObjectTrace(ctx, "unregister", in) + + // Actually call the next + rv, err := t.traced.Unregister(ctx, in, opts...) + if err != nil { + return nil, logError(ctx, err, operation) + } + logObjectTrace(ctx, "unregister-response", rv) + return rv, nil +} + +// NewNetworkServiceEndpointRegistryClient - wraps registry.NetworkServiceEndpointRegistryClient with tracing +func NewNetworkServiceEndpointRegistryClient(traced registry.NetworkServiceEndpointRegistryClient) registry.NetworkServiceEndpointRegistryClient { + return &traceNetworkServiceEndpointRegistryClient{traced: traced} +} + +type traceNetworkServiceEndpointRegistryServer struct { + traced registry.NetworkServiceEndpointRegistryServer +} + +func (t *traceNetworkServiceEndpointRegistryServer) Register(ctx context.Context, in *registry.NetworkServiceEndpoint) (*registry.NetworkServiceEndpoint, error) { + operation := typeutils.GetFuncName(t.traced, methodNameRegister) + ctx, finish := withLog(ctx, operation, methodNameRegister) + defer finish() + + logObjectTrace(ctx, "register", in) + + rv, err := t.traced.Register(ctx, in) + if err != nil { + return nil, logError(ctx, err, operation) + } + logObjectTrace(ctx, "register-response", rv) + return rv, nil +} + +func (t *traceNetworkServiceEndpointRegistryServer) Find(in *registry.NetworkServiceEndpointQuery, s registry.NetworkServiceEndpointRegistry_FindServer) error { + operation := typeutils.GetFuncName(t.traced, methodNameFind) + ctx, finish := withLog(s.Context(), operation, methodNameFind) + defer finish() + + s = &traceNetworkServiceEndpointRegistryFindServer{ + NetworkServiceEndpointRegistry_FindServer: streamcontext.NetworkServiceEndpointRegistryFindServer(ctx, s), + operation: typeutils.GetFuncName(t.traced, methodNameSend), + } + logObjectTrace(ctx, "find", in) + + // Actually call the next + err := t.traced.Find(in, s) + if err != nil { + return logError(ctx, err, operation) + } + logObjectTrace(ctx, "find-response", in) + + return nil +} + +func (t *traceNetworkServiceEndpointRegistryServer) Unregister(ctx context.Context, in *registry.NetworkServiceEndpoint) (*empty.Empty, error) { + operation := typeutils.GetFuncName(t.traced, methodNameUnregister) + ctx, finish := withLog(ctx, operation, methodNameUnregister) + defer finish() + + logObjectTrace(ctx, "unregister", in) + + // Actually call the next + rv, err := t.traced.Unregister(ctx, in) + if err != nil { + return nil, logError(ctx, err, operation) + } + logObjectTrace(ctx, "unregister-response", rv) + return rv, nil +} + +// NewNetworkServiceEndpointRegistryServer - wraps registry.NetworkServiceEndpointRegistryServer with tracing +func NewNetworkServiceEndpointRegistryServer(traced registry.NetworkServiceEndpointRegistryServer) registry.NetworkServiceEndpointRegistryServer { + return &traceNetworkServiceEndpointRegistryServer{traced: traced} +} + +type traceNetworkServiceEndpointRegistryFindServer struct { + registry.NetworkServiceEndpointRegistry_FindServer + operation string +} + +func (t *traceNetworkServiceEndpointRegistryFindServer) Send(nseResp *registry.NetworkServiceEndpointResponse) error { + ctx, finish := withLog(t.Context(), t.operation, methodNameSend) + defer finish() + + logObjectTrace(ctx, "network service endpoint", nseResp.NetworkServiceEndpoint) + s := streamcontext.NetworkServiceEndpointRegistryFindServer(ctx, t.NetworkServiceEndpointRegistry_FindServer) + err := s.Send(nseResp) + if err != nil { + return logError(ctx, err, t.operation) + } + return nil +} diff --git a/pkg/tools/log/logruslogger/logruslogger.go b/pkg/tools/log/logruslogger/logruslogger.go index 82f8168d8..d7f1c5b88 100644 --- a/pkg/tools/log/logruslogger/logruslogger.go +++ b/pkg/tools/log/logruslogger/logruslogger.go @@ -120,27 +120,6 @@ func New(ctx context.Context, fields ...logrus.Fields) log.Logger { } } -// LoggerWithFields - creates a new logruslogger with fields -func LoggerWithFields(fields []*log.Field) log.Logger { - logger := log.L() - if log.IsDefault(logger) { - fieldsMap := make(map[string]interface{}, len(fields)) - for _, field := range fields { - fieldsMap[field.Key()] = field.Val() - } - entry := logrus.WithFields(fieldsMap) - entry.Logger.SetFormatter(newFormatter()) - logger = &logrusLogger{ - entry: entry, - } - } else { - for _, field := range fields { - logger = logger.WithField(field.Key(), field.Val()) - } - } - return logger -} - // ---------------------------------------------------------------------- type traceLogger struct { @@ -298,7 +277,7 @@ func FromSpan( ctx context.Context, span spanlogger.Span, operation string, fields []*log.Field) (context.Context, log.Logger, func()) { var info *traceCtxInfo deleteFunc := func() {} - if log.IsTracingEnabled() { + if log.IsTracingEnabled() && logrus.GetLevel() == logrus.TraceLevel { ctx, info = withTraceInfo(ctx) localTraceInfo.Store(info.id, info) deleteFunc = func() { localTraceInfo.Delete(info.id) }