Sign upLogin

streamdal/go-sdk

View on GitHub
Star
go_sdk.go

Summary

Maintainability
D
2 days
Test Coverage
D
66%

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),
    }
Severity: Minor
Found in go_sdk.go - About 6 hrs to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

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),
    }
Severity: Major
Found in go_sdk.go - About 6 hrs to fix

    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©.
    Severity: Minor
    Found in go_sdk.go - About 5 hrs to fix

      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")
    }
      Severity: Minor
      Found in go_sdk.go - About 1 hr to fix

        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")
    }
        Severity: Major
        Found in go_sdk.go - About 55 mins to fix

          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,
          Severity: Major
          Found in go_sdk.go - About 50 mins to fix

            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),
    }
            Severity: Major
            Found in go_sdk.go - About 45 mins to fix

              Function validateConfig has 6 return statements (exceeds 4 allowed).
              Wontfix

              func validateConfig(cfg *Config) error {
    if cfg == nil {
        return ErrEmptyConfig
    }
              Severity: Major
              Found in go_sdk.go - About 40 mins to fix

                Method Streamdal.runStep has 5 arguments (exceeds 4 allowed). Consider refactoring.
                Open

                func (s *Streamdal) runStep(ctx context.Context, aud *protos.Audience, step *protos.PipelineStep, data []byte, isr *protos.InterStepResult) (*protos.WASMResponse, error) {
                Severity: Minor
                Found in go_sdk.go - About 35 mins to fix

                  Function validateProcessRequest has 5 return statements (exceeds 4 allowed).
                  Wontfix

                  func validateProcessRequest(req *ProcessRequest) error {
    if req == nil {
        return ErrEmptyProcessRequest
    }
                  Severity: Major
                  Found in go_sdk.go - About 35 mins to fix

                    Method Streamdal.runStep has 5 return statements (exceeds 4 allowed).
                    Open

                    func (s *Streamdal) runStep(ctx context.Context, aud *protos.Audience, step *protos.PipelineStep, data []byte, isr *protos.InterStepResult) (*protos.WASMResponse, error) {
    s.config.Logger.Debugf("Running step '%s'", step.Name)

    // Get WASM module
    f, err := s.getFunction(ctx, step)
                    Severity: Major
                    Found in go_sdk.go - About 35 mins to fix

                      Function validateConfig has a Cognitive Complexity of 21 (exceeds 20 allowed). Consider refactoring.
                      Wontfix

                      func validateConfig(cfg *Config) error {
    if cfg == nil {
        return ErrEmptyConfig
    }
                      Severity: Minor
                      Found in go_sdk.go - About 25 mins to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      There are no issues that match your filters.

                      Category
                      Status