Method Streamdal.Process has a Cognitive Complexity of 59 (exceeds 20 allowed). Consider refactoring.

Open

func (s *Streamdal) Process(ctx context.Context, req *ProcessRequest) *ProcessResponse {
    resp := &ProcessResponse{
        PipelineStatus: make([]*protos.PipelineStatus, 0),
        Metadata:       make(map[string]string),
    }

• Read up
  Read up

Method Streamdal.Process has 178 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (s *Streamdal) Process(ctx context.Context, req *ProcessRequest) *ProcessResponse {
    resp := &ProcessResponse{
        PipelineStatus: make([]*protos.PipelineStatus, 0),
        Metadata:       make(map[string]string),
    }

File go_sdk.go has 648 lines of code (exceeds 500 allowed). Consider refactoring.

Open

// Package streamdal is a library that allows running of Client data pipelines against data
// This package is designed to be included in golang message bus libraries. The only public
// method is Process() which is used to run pipelines against data.
//
// Use of this package requires a running instance of a streamdal server©.

Method Streamdal.register has 93 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (s *Streamdal) register(looper director.Looper) error {
    req := &protos.RegisterRequest{
        ServiceName: s.config.ServiceName,
        SessionId:   s.sessionID,
        ClientInfo:  s.genClientInfo(),

Method Streamdal.register has a Cognitive Complexity of 33 (exceeds 20 allowed). Consider refactoring.

Open

func (s *Streamdal) register(looper director.Looper) error {
    req := &protos.RegisterRequest{
        ServiceName: s.config.ServiceName,
        SessionId:   s.sessionID,
        ClientInfo:  s.genClientInfo(),

• Read up
  Read up

Function New has 68 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func New(cfg *Config) (*Streamdal, error) {
    if err := validateConfig(cfg); err != nil {
        return nil, errors.Wrap(err, "unable to validate config")
    }

Method Streamdal.register has 12 return statements (exceeds 4 allowed).

Open

func (s *Streamdal) register(looper director.Looper) error {
    req := &protos.RegisterRequest{
        ServiceName: s.config.ServiceName,
        SessionId:   s.sessionID,
        ClientInfo:  s.genClientInfo(),

Method function.Exec has 10 return statements (exceeds 4 allowed).

Open

func (f *function) Exec(ctx context.Context, req []byte) ([]byte, error) {
    ptrLen := uint64(len(req))

    inputPtr, err := f.alloc.Call(ctx, ptrLen)
    if err != nil {

Function New has 9 return statements (exceeds 4 allowed).

Open

func New(cfg *Config) (*Streamdal, error) {
    if err := validateConfig(cfg); err != nil {
        return nil, errors.Wrap(err, "unable to validate config")
    }

Method Streamdal.handleCondition has 7 arguments (exceeds 4 allowed). Consider refactoring.

Open

    ctx context.Context,
    req *ProcessRequest,
    resp *ProcessResponse,
    stepCond *protos.PipelineStepConditions,
    step *protos.PipelineStep,

Function WriteResponseToMemory has 8 return statements (exceeds 4 allowed).

Open

func WriteResponseToMemory(module api.Module, msg proto.Message) (uint64, error) {
    if module == nil {
        return 0, errors.New("module cannot be nil")
    }

Method Tail.startWorker has 7 return statements (exceeds 4 allowed).

Open

func (t *Tail) startWorker(looper director.Looper, stream protos.Internal_SendTailClient) {
    if stream == nil {
        t.log.Error("stream is nil, unable to start tail worker")
        return
    }

Method Streamdal.Process has 7 return statements (exceeds 4 allowed).

Open

func (s *Streamdal) Process(ctx context.Context, req *ProcessRequest) *ProcessResponse {
    resp := &ProcessResponse{
        PipelineStatus: make([]*protos.PipelineStatus, 0),
        Metadata:       make(map[string]string),
    }

Function Audience has 6 return statements (exceeds 4 allowed).

Open

func Audience(aud *protos.Audience) error {
    if aud == nil {
        return ErrNilInput
    }

Method HostFunc.HTTPRequest has 6 return statements (exceeds 4 allowed).

Open

func (h *HostFunc) HTTPRequest(_ context.Context, module api.Module, ptr, length int32) uint64 {
    request := &steps.HttpRequest{}

    if err := helper.ReadRequestFromMemory(module, request, ptr, length); err != nil {
        return httpRequestResponse(module, http.StatusInternalServerError, "unable to read HTTP request params: "+err.Error(), nil)

Function TailRequestStartCommand has 6 return statements (exceeds 4 allowed).

Open

func TailRequestStartCommand(cmd *protos.Command) error {
    if cmd == nil {
        return ErrNilInput
    }

Function ReadRequestFromMemory has 6 return statements (exceeds 4 allowed).

Open

func ReadRequestFromMemory(module api.Module, msg proto.Message, ptr, length int32) error {
    if length <= 0 {
        return errors.New("length must be greater than 0")
    }

Function TailRequestStopCommand has 6 return statements (exceeds 4 allowed).

Open

func TailRequestStopCommand(cmd *protos.Command) error {
    if cmd == nil {
        return ErrNilInput
    }

Function TailRequestPauseCommand has 6 return statements (exceeds 4 allowed).

Open

func TailRequestPauseCommand(cmd *protos.Command) error {
    if cmd == nil {
        return ErrNilInput
    }

Function TailRequestResumeCommand has 6 return statements (exceeds 4 allowed).

Open

func TailRequestResumeCommand(cmd *protos.Command) error {
    if cmd == nil {
        return ErrNilInput
    }