Merge branch 'main' into docs-mongo

cli/provider/cmd.go

@@ -189,6 +189,7 @@ func (c *CmdConfigurator) AddFlags(cmd *cobra.Command) error {
 		cmd.Flags().Uint32("proxyPort", c.cfg.ProxyPort, "Port used by the Keploy proxy server to intercept the outgoing dependency calls")
 		cmd.Flags().Uint32("dnsPort", c.cfg.DNSPort, "Port used by the Keploy DNS server to intercept the DNS queries")
 		cmd.Flags().StringP("command", "c", c.cfg.Command, "Command to start the user application")
+		cmd.Flags().String("cmdType", c.cfg.CommandType, "Type of command to start the user application (native/docker/docker-compose)")
 		cmd.Flags().DurationP("buildDelay", "b", c.cfg.BuildDelay, "User provided time to wait docker container build")
 		cmd.Flags().String("containerName", c.cfg.ContainerName, "Name of the application's docker container")
 		cmd.Flags().StringP("networkName", "n", c.cfg.NetworkName, "Name of the application's docker network")
@@ -323,6 +324,10 @@ func (c CmdConfigurator) ValidateFlags(ctx context.Context, cmd *cobra.Command)
 			}
 			return errors.New("missing required -c flag or appCmd in config file")
 		}
+
+		// set the command type
+		c.cfg.CommandType = string(utils.FindDockerCmd(c.cfg.Command))
+
 		if c.cfg.GenerateGithubActions {
 			defer utils.GenerateGithubActions(c.logger, c.cfg.Command)
 		}
@@ -336,12 +341,12 @@ func (c CmdConfigurator) ValidateFlags(ctx context.Context, cmd *cobra.Command)
 					return errors.New(errMsg)
 				}
 				if strings.Contains(c.cfg.Path, "..") {
-					c.cfg.Path, err = filepath.Abs(filepath.Clean(c.cfg.Path))
+
+					c.cfg.Path, err = utils.GetAbsPath(filepath.Clean(c.cfg.Path))
 					if err != nil {
-						errMsg := "failed to get the absolute path from relative path"
-						utils.LogError(c.logger, err, errMsg)
-						return errors.New(errMsg)
+						return fmt.Errorf("failed to get the absolute path from relative path: %w", err)
 					}
+
 					relativePath, err := filepath.Rel(curDir, c.cfg.Path)
 					if err != nil {
 						errMsg := "failed to get the relative path from absolute path"
@@ -374,12 +379,12 @@ func (c CmdConfigurator) ValidateFlags(ctx context.Context, cmd *cobra.Command)
 			return err
 		}
 
-		absPath, err := filepath.Abs(c.cfg.Path)
+		absPath, err := utils.GetAbsPath(c.cfg.Path)
 		if err != nil {
-			errMsg := "failed to get the absolute path from relative path"
-			utils.LogError(c.logger, err, errMsg)
-			return errors.New(errMsg)
+			utils.LogError(c.logger, err, "error while getting absolute path")
+			return errors.New("failed to get the absolute path")
 		}
+
 		c.cfg.Path = absPath + "/keploy"
 		if cmd.Name() == "test" {
 			testSets, err := cmd.Flags().GetStringSlice("testsets")
@@ -389,6 +394,16 @@ func (c CmdConfigurator) ValidateFlags(ctx context.Context, cmd *cobra.Command)
 				return errors.New(errMsg)
 			}
 			config.SetSelectedTests(c.cfg, testSets)
+
+			if utils.CmdType(c.cfg.CommandType) == utils.Native && c.cfg.Test.GoCoverage {
+				goCovPath, err := utils.SetCoveragePath(c.logger, c.cfg.Test.CoverageReportPath)
+				if err != nil {
+					utils.LogError(c.logger, err, "failed to set go coverage path")
+					return errors.New("failed to set go coverage path")
+				}
+				c.cfg.Test.CoverageReportPath = goCovPath
+			}
+
 			if c.cfg.Test.Delay <= 5 {
 				c.logger.Warn(fmt.Sprintf("Delay is set to %d seconds, incase your app takes more time to start use --delay to set custom delay", c.cfg.Test.Delay))
 				if c.cfg.InDocker {

cli/test.go

@@ -2,6 +2,7 @@ package cli
 
 import (
 	"context"
+	"os"
 
 	"go.keploy.io/server/v2/pkg/graph"
 	"go.keploy.io/server/v2/utils"
@@ -44,6 +45,15 @@ func Test(ctx context.Context, logger *zap.Logger, cfg *config.Config, serviceFa
 					return nil
 				}
 			}
+
+			cmdType := utils.FindDockerCmd(cfg.Command)
+			if cmdType == utils.Native && cfg.Test.GoCoverage {
+				err := os.Setenv("GOCOVERDIR", cfg.Test.CoverageReportPath)
+				if err != nil {
+					utils.LogError(logger, err, "failed to set GOCOVERDIR")
+					return nil
+				}
+			}
 			err = replay.Start(ctx)
 			if err != nil {
 				utils.LogError(logger, err, "failed to replay")

config/config.go

@@ -1,7 +1,9 @@
 // Package config provides configuration structures for the application.
 package config
 
-import "time"
+import (
+	"time"
+)
 
 type Config struct {
 	Path                  string        `json:"path" yaml:"path" mapstructure:"path" `
@@ -23,6 +25,7 @@ type Config struct {
 	GenerateGithubActions bool          `json:"generateGithubActions" yaml:"generateGithubActions" mapstructure:"generateGithubActions"`
 	KeployContainer       string        `json:"keployContainer" yaml:"keployContainer" mapstructure:"keployContainer"`
 	KeployNetwork         string        `json:"keployNetwork" yaml:"keployNetwork" mapstructure:"keployNetwork"`
+	CommandType           string        `json:"cmdType" yaml:"cmdType" mapstructure:"cmdType"`
 }
 
 type Record struct {

config/default.go

@@ -55,6 +55,7 @@ enableTesting: false
 keployContainer: "keploy-v2"
 keployNetwork: "keploy-network"
 inDocker: false
+cmdType: "native"
 `
 
 var config = &Config{}

pkg/core/proxy/integrations/generic/decode.go

@@ -20,7 +20,7 @@ func decodeGeneric(ctx context.Context, logger *zap.Logger, reqBuf []byte, clien
 	logger.Debug("Into the generic parser in test mode")
 	errCh := make(chan error, 1)
 	go func(errCh chan error, genericRequests [][]byte) {
-		defer utils.Recover(logger)
+		defer pUtil.Recover(logger, clientConn, nil)
 		defer close(errCh)
 		for {
 			// Since protocol packets have to be parsed for checking stream end,

pkg/core/proxy/integrations/generic/encode.go

@@ -61,14 +61,14 @@ func encodeGeneric(ctx context.Context, logger *zap.Logger, reqBuf []byte, clien
 
 	// read requests from client
 	g.Go(func() error {
-		defer utils.Recover(logger)
+		defer pUtil.Recover(logger, clientConn, nil)
 		defer close(clientBuffChan)
 		pUtil.ReadBuffConn(ctx, logger, clientConn, clientBuffChan, errChan)
 		return nil
 	})
 	// read responses from destination
 	g.Go(func() error {
-		defer utils.Recover(logger)
+		defer pUtil.Recover(logger, nil, destConn)
 		defer close(destBuffChan)
 		pUtil.ReadBuffConn(ctx, logger, destConn, destBuffChan, errChan)
 		return nil

pkg/core/proxy/integrations/grpc/encode.go

@@ -2,12 +2,14 @@ package grpc
 
 import (
 	"context"
+	"io"
+	"net"
+
+	pUtil "go.keploy.io/server/v2/pkg/core/proxy/util"
 	"go.keploy.io/server/v2/pkg/models"
 	"go.keploy.io/server/v2/utils"
 	"go.uber.org/zap"
 	"golang.org/x/sync/errgroup"
-	"io"
-	"net"
 )
 
 func encodeGrpc(ctx context.Context, logger *zap.Logger, reqBuf []byte, clientConn, destConn net.Conn, mocks chan<- *models.Mock, _ models.OutgoingOptions) error {
@@ -35,7 +37,7 @@ func encodeGrpc(ctx context.Context, logger *zap.Logger, reqBuf []byte, clientCo
 
 	// Route requests from the client to the server.
 	g.Go(func() error {
-		defer utils.Recover(logger)
+		defer pUtil.Recover(logger, clientConn, destConn)
 		err := transferFrame(ctx, destConn, clientConn, streamInfoCollection, reqFromClient, serverSideDecoder, mocks)
 		if err != nil {
 			// check for EOF error
@@ -55,7 +57,7 @@ func encodeGrpc(ctx context.Context, logger *zap.Logger, reqBuf []byte, clientCo
 	// Route response from the server to the client.
 	clientSideDecoder := NewDecoder()
 	g.Go(func() error {
-		defer utils.Recover(logger)
+		defer pUtil.Recover(logger, clientConn, destConn)
 		err := transferFrame(ctx, clientConn, destConn, streamInfoCollection, !reqFromClient, clientSideDecoder, mocks)
 		if err != nil {
 			utils.LogError(logger, err, "failed to transfer frame from server to client")

pkg/core/proxy/integrations/http/decode.go

@@ -14,7 +14,7 @@ import (
 
 	"go.keploy.io/server/v2/pkg"
 	"go.keploy.io/server/v2/pkg/core/proxy/integrations"
-	"go.keploy.io/server/v2/pkg/core/proxy/util"
+	pUtil "go.keploy.io/server/v2/pkg/core/proxy/util"
 	"go.keploy.io/server/v2/pkg/models"
 	"go.keploy.io/server/v2/utils"
 	"go.uber.org/zap"
@@ -31,6 +31,7 @@ func decodeHTTP(ctx context.Context, logger *zap.Logger, reqBuf []byte, clientCo
 	errCh := make(chan error, 1)
 
 	go func(errCh chan error, reqBuf []byte, opts models.OutgoingOptions) {
+		defer pUtil.Recover(logger, clientConn, nil)
 		defer close(errCh)
 		for {
 			//Check if the expected header is present
@@ -48,7 +49,7 @@ func decodeHTTP(ctx context.Context, logger *zap.Logger, reqBuf []byte, clientCo
 				}
 				logger.Debug("The 100 continue response has been sent to the user application")
 				//Read the request buffer again
-				newRequest, err := util.ReadBytes(ctx, logger, clientConn)
+				newRequest, err := pUtil.ReadBytes(ctx, logger, clientConn)
 				if err != nil {
 					utils.LogError(logger, err, "failed to read the request buffer from the user application")
 					errCh <- err
@@ -103,12 +104,14 @@ func decodeHTTP(ctx context.Context, logger *zap.Logger, reqBuf []byte, clientCo
 					utils.LogError(logger, nil, "Didn't match any preExisting http mock", zap.Any("metadata", getReqMeta(request)))
 				}
 
-				_, err = util.PassThrough(ctx, logger, clientConn, dstCfg, [][]byte{reqBuf})
+				_, err = pUtil.PassThrough(ctx, logger, clientConn, dstCfg, [][]byte{reqBuf})
 				if err != nil {
 					utils.LogError(logger, err, "failed to passThrough http request", zap.Any("metadata", getReqMeta(request)))
 					errCh <- err
 					return
 				}
+				errCh <- nil
+				return
 			}
 
 			statusLine := fmt.Sprintf("HTTP/%d.%d %d %s\r\n", stub.Spec.HTTPReq.ProtoMajor, stub.Spec.HTTPReq.ProtoMinor, stub.Spec.HTTPResp.StatusCode, http.StatusText(stub.Spec.HTTPResp.StatusCode))
@@ -168,7 +171,7 @@ func decodeHTTP(ctx context.Context, logger *zap.Logger, reqBuf []byte, clientCo
 				return
 			}
 
-			reqBuf, err = util.ReadBytes(ctx, logger, clientConn)
+			reqBuf, err = pUtil.ReadBytes(ctx, logger, clientConn)
 			if err != nil {
 				logger.Debug("failed to read the request buffer from the client", zap.Error(err))
 				logger.Debug("This was the last response from the server:\n" + string(responseString))

pkg/core/proxy/integrations/http/encode.go

@@ -12,6 +12,7 @@ import (
 	"golang.org/x/sync/errgroup"
 
 	"go.keploy.io/server/v2/pkg/core/proxy/util"
+	pUtil "go.keploy.io/server/v2/pkg/core/proxy/util"
 	"go.keploy.io/server/v2/pkg/models"
 	"go.keploy.io/server/v2/utils"
 	"go.uber.org/zap"
@@ -48,7 +49,7 @@ func encodeHTTP(ctx context.Context, logger *zap.Logger, reqBuf []byte, clientCo
 
 	//for keeping conn alive
 	g.Go(func() error {
-		defer utils.Recover(logger)
+		defer pUtil.Recover(logger, clientConn, destConn)
 		defer close(errCh)
 		for {
 			//check if expect : 100-continue header is present

pkg/core/proxy/integrations/mongo/decode.go

@@ -27,7 +27,7 @@ func decodeMongo(ctx context.Context, logger *zap.Logger, reqBuf []byte, clientC
 	errCh := make(chan error, 1)
 
 	go func(errCh chan error, reqBuf []byte, startedDecoding time.Time, requestBuffers [][]byte) {
-		defer utils.Recover(logger)
+		defer util.Recover(logger, clientConn, nil)
 		defer close(errCh)
 		var readRequestDelay time.Duration
 		for {

pkg/core/proxy/integrations/mongo/encode.go

@@ -10,7 +10,7 @@ import (
 
 	"golang.org/x/sync/errgroup"
 
-	"go.keploy.io/server/v2/pkg/core/proxy/util"
+	pUtil "go.keploy.io/server/v2/pkg/core/proxy/util"
 	"go.keploy.io/server/v2/pkg/models"
 	"go.keploy.io/server/v2/utils"
 	"go.uber.org/zap"
@@ -30,7 +30,7 @@ func (m *Mongo) encodeMongo(ctx context.Context, logger *zap.Logger, reqBuf []by
 	}
 
 	g.Go(func() error {
-		defer utils.Recover(logger)
+		defer pUtil.Recover(logger, clientConn, destConn)
 		defer close(errCh)
 		for {
 			var err error
@@ -40,7 +40,7 @@ func (m *Mongo) encodeMongo(ctx context.Context, logger *zap.Logger, reqBuf []by
 			// Since, that is already read in the RecordOutgoing function.
 			if string(reqBuf) == "read form client conn" {
 				started := time.Now()
-				reqBuf, err = util.ReadBytes(ctx, logger, clientConn)
+				reqBuf, err = pUtil.ReadBytes(ctx, logger, clientConn)
 				logger.Debug("reading from the mongo conn", zap.Any("", string(reqBuf)))
 				if err != nil {
 					if err == io.EOF {
@@ -89,8 +89,9 @@ func (m *Mongo) encodeMongo(ctx context.Context, logger *zap.Logger, reqBuf []by
 			// check for the request packet streaming for the mongo wire message
 			if val, ok := mongoRequest.(*models.MongoOpMessage); ok && hasSecondSetBit(val.FlagBits) {
 				for {
-					// read the streaming request packets
-					requestBuffer1, err := util.ReadBytes(ctx, logger, clientConn)
+<
+          // read the streaming request packets
+					requestBuffer1, err := pUtil.ReadBytes(ctx, logger, clientConn)
 					if err != nil {
 						if err == io.EOF {
 							logger.Debug("recieved request buffer is empty in record mode for mongo request")
@@ -139,8 +140,9 @@ func (m *Mongo) encodeMongo(ctx context.Context, logger *zap.Logger, reqBuf []by
 
 			reqTimestampMock := time.Now()
 			started := time.Now()
+
 			// read reply message length from the destination mongo server
-			responsePckLengthBuffer, err := util.ReadRequiredBytes(ctx, logger, destConn, 4)
+			responsePckLengthBuffer, err := pUtil.ReadRequiredBytes(ctx, logger, destConn, 4)
 			if err != nil {
 				if err == io.EOF {
 					logger.Debug("recieved response buffer is empty in record mode for mongo call")
@@ -158,8 +160,9 @@ func (m *Mongo) encodeMongo(ctx context.Context, logger *zap.Logger, reqBuf []by
 			pckLength := getPacketLength(responsePckLengthBuffer)
 			logger.Debug("received pck length ", zap.Any("packet length", pckLength))
 
+
 			// read the entire response packet
-			responsePckDataBuffer, err := util.ReadRequiredBytes(ctx, logger, destConn, int(pckLength)-4)
+			responsePckDataBuffer, err := pUtil.ReadRequiredBytes(ctx, logger, destConn, int(pckLength)-4)
 
 			logger.Debug("recieved these packets", zap.Any("packets", responsePckDataBuffer))
 
@@ -208,8 +211,9 @@ func (m *Mongo) encodeMongo(ctx context.Context, logger *zap.Logger, reqBuf []by
 						m.recordMessage(ctx, logger, mongoRequests, mongoResponses, opReq, reqTimestampMock, mocks)
 					}
 					started = time.Now()
+
 					// read the response packets from the destination server
-					responseBuffer, err = util.ReadBytes(ctx, logger, destConn)
+					responseBuffer, err = pUtil.ReadBytes(ctx, logger, destConn)
 					if err != nil {
 						if err == io.EOF {
 							logger.Debug("recieved response buffer is empty in record mode for mongo call")

pkg/core/proxy/integrations/mysql/decode.go

@@ -6,7 +6,7 @@ import (
 	"time"
 
 	"go.keploy.io/server/v2/pkg/core/proxy/integrations"
-	"go.keploy.io/server/v2/pkg/core/proxy/util"
+	pUtil "go.keploy.io/server/v2/pkg/core/proxy/util"
 	"go.keploy.io/server/v2/pkg/models"
 	"go.keploy.io/server/v2/utils"
 	"go.uber.org/zap"
@@ -33,7 +33,7 @@ func decodeMySQL(ctx context.Context, logger *zap.Logger, clientConn net.Conn, d
 	errCh := make(chan error, 1)
 
 	go func(errCh chan error, configMocks []*models.Mock, tcsMocks []*models.Mock, prevRequest string, requestBuffers [][]byte) {
-		defer utils.Recover(logger)
+		defer pUtil.Recover(logger, clientConn, nil)
 		defer close(errCh)
 		for {
 			//log.Debug("Config and TCS Mocks", zap.Any("configMocks", configMocks), zap.Any("tcsMocks", tcsMocks))
@@ -98,7 +98,7 @@ func decodeMySQL(ctx context.Context, logger *zap.Logger, clientConn net.Conn, d
 				}
 
 				// Attempt to read from the client
-				requestBuffer, err := util.ReadBytes(ctx, logger, clientConn)
+				requestBuffer, err := pUtil.ReadBytes(ctx, logger, clientConn)
 				if err != nil {
 					if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
 						// Timeout occurred, no data received from client
@@ -178,7 +178,7 @@ func decodeMySQL(ctx context.Context, logger *zap.Logger, clientConn net.Conn, d
 				if matchedIndex == -1 {
 					logger.Debug("No matching mock found")
 
-					responseBuffer, err := util.PassThrough(ctx, logger, clientConn, dstCfg, requestBuffers)
+					responseBuffer, err := pUtil.PassThrough(ctx, logger, clientConn, dstCfg, requestBuffers)
 					if err != nil {
 						utils.LogError(logger, err, "Failed to passthrough the mysql request to the actual database server")
 						errCh <- err