Method timers.addOneShot has 5 return statements (exceeds 4 allowed).

Open

func (timers *timers) addOneShot(name, fn string, timeos time.Time, data []byte) error {
    utc := timeos.UTC()

    t, err := timers.newTimer(name, fn, data, &utc, "")
    if err != nil {

Method NamespaceVarPlugin.Execute has 5 return statements (exceeds 4 allowed).

Open

func (tnv *NamespaceVarPlugin) Execute(w http.ResponseWriter, r *http.Request) *http.Request {
    currentNS := gateway.ExtractContextEndpoint(r).Namespace
    if tnv.Namespace == "" {
        tnv.Namespace = currentNS
    }

Function jq has 5 return statements (exceeds 4 allowed).

Open

func jq(input interface{}, command string) ([]interface{}, error) {
    data, err := json.Marshal(input)
    if err != nil {
        return nil, err
    }

Function renderStartEventListener has 5 return statements (exceeds 4 allowed).

Open

func renderStartEventListener(ctx context.Context, nsID uuid.UUID, nsName string, file *filestore.File, ms *muxStart, tx *database.SQLStore) error {
    _, err := tx.DataStore().EventListener().DeleteAllForWorkflow(ctx, file.ID)
    if err != nil {
        return err
    }

Function preprocessRetry has 5 return statements (exceeds 4 allowed).

Open

func preprocessRetry(retry *model.RetryDefinition, attempt int, err error) (time.Duration, error) {
    var d time.Duration

    if retry == nil {
        return d, err

Method engine.handleInstanceMessage has 5 return statements (exceeds 4 allowed).

Open

func (engine *engine) handleInstanceMessage(ctx context.Context, im *instanceMemory, msg *instancestore.InstanceMessageData) *states.Transition {
    instanceCtx := tracing.AddInstanceMemoryAttr(ctx,
        tracing.InstanceAttributes{
            Namespace:    im.Namespace().Name,
            InstanceID:   im.GetInstanceID().String(),

Method generateEventLogic.Run has 5 return statements (exceeds 4 allowed).

Open

func (logic *generateEventLogic) Run(ctx context.Context, wakedata []byte) (*Transition, error) {
    err := scheduleOnce(logic, wakedata)
    if err != nil {
        return nil, err
    }

Method sqlEventListenerStore.Append has 5 return statements (exceeds 4 allowed).

Open

func (s *sqlEventListenerStore) Append(ctx context.Context, listener *datastore.EventListener) error {
    q := `INSERT INTO event_listeners
     (id, namespace_id, namespace, created_at, updated_at, deleted, received_events, trigger_type, events_lifespan, event_types, trigger_info, metadata, event_context_filters) 
      VALUES ( $1 , $2 , $3 , $4 , $5 , $6 , $7 , $8 , $9 , $10 , $11, $12, $13);`

Method Workflow.unmStart has 5 return statements (exceeds 4 allowed).

Open

func (o *Workflow) unmStart(m map[string]interface{}) (err error) {
    // split start out from the rest
    y, startFound := m["start"]
    if startFound {
        // Start

Method secretsController.create has 5 return statements (exceeds 4 allowed).

Open

func (e *secretsController) create(w http.ResponseWriter, r *http.Request) {
    ns := extractContextNamespace(r)

    db, err := e.db.BeginTx(r.Context())
    if err != nil {

Method SubflowFunctionDefinition.Validate has 5 return statements (exceeds 4 allowed).

Open

func (o *SubflowFunctionDefinition) Validate() error {
    if o == nil {
        return nil
    }

Method SwitchState.Validate has 5 return statements (exceeds 4 allowed).

Open

func (o *SwitchState) Validate() error {
    if err := o.commonValidate(); err != nil {
        return err
    }

Method sqlSecretsStore.Set has 5 return statements (exceeds 4 allowed).

Open

func (s sqlSecretsStore) Set(ctx context.Context, secret *datastore.Secret) error {
    var res *gorm.DB
    x, err := s.Get(ctx, secret.Namespace, secret.Name)
    //nolint:nestif
    if errors.Is(err, datastore.ErrNotFound) {

Function renderServiceManager has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func renderServiceManager(db *database.SQLStore, serviceManager core.ServiceManager) {
    ctx := context.Background()
    slog := slog.With("subscriber", "services file watcher")

    fStore, dStore := db.FileStore(), db.DataStore()

• Read up
  Read up

Method NamespacedFunctionDefinition.Validate has 5 return statements (exceeds 4 allowed).

Open

func (o *NamespacedFunctionDefinition) Validate() error {
    if o == nil {
        return nil
    }

Method SetterState.Validate has 5 return statements (exceeds 4 allowed).

Open

func (o *SetterState) Validate() error {
    if err := o.commonValidate(); err != nil {
        return err
    }

Method instController.getPagination has 5 return statements (exceeds 4 allowed).

Open

func (e *instController) getPagination(r *http.Request) (*paginationOptions, error) {
    opts := new(paginationOptions)

    x := r.URL.Query().Get("limit")
    if x != "" {

Function ParseEndpointFile has 5 return statements (exceeds 4 allowed).

Open

func ParseEndpointFile(ns string, filePath string, data []byte) Endpoint {
    res := &EndpointFile{}
    err := yaml.Unmarshal(data, res)
    if err != nil {
        return Endpoint{

Method GetterState.Validate has 5 return statements (exceeds 4 allowed).

Open

func (o *GetterState) Validate() error {
    if err := o.commonValidate(); err != nil {
        return err
    }

Function InitTelemetry has 5 return statements (exceeds 4 allowed).

Open

func InitTelemetry(cirCtx context.Context, addr string, svcName, imName string) (func(), error) {
    slog.Debug("Initializing telemetry.", "instrumentationName", imName)
    instrumentationName = imName

    // Setup context propagation format