func NewProcessorsLogsCommand() *cobra.Command {
	var (
		clusterName, podName, namespace string
		follow                          bool
		lines                           int
	)
	cmd := &cobra.Command{
		Use:              "logs",
		Short:            "Retrieve LSQL Processor logs. Available only in KUBERNETES execution mode",
		Example:          `processors logs --cluster-name=cluster-name --namespace=nameSpace --podName=runnerStateID [--follow --lines=50]`,
		SilenceErrors:    true,
		TraverseChildren: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			if err := bite.CheckRequiredFlags(cmd, bite.FlagPair{"cluster-name": clusterName, "namespace": namespace, "podName": podName}); err != nil {
				return err
			}
			golog.SetTimeFormat("")
			handler := func(level, log string) error {
				log, _ = url.QueryUnescape(log)  
				utils.RichLog(level, log)
				return nil
			}
			if err := config.Client.GetProcessorsLogs(clusterName, namespace, podName, follow, lines, handler); err != nil {
				golog.Errorf("Failed to retrieve logs for pod [%s]. [%s]", podName, err.Error())
				return err
			}
			return nil
		},
	}
	cmd.Flags().StringVar(&clusterName, "cluster-name", "", "Select by cluster name, available only in KUBERNETES mode")
	cmd.Flags().StringVar(&namespace, "namespace", "", "Select by namespace, available only in KUBERNETES mode")
	cmd.Flags().StringVar(&podName, "podName", "", "Kubernetes pod name to view the logs for")
	cmd.Flags().BoolVar(&follow, "follow", false, "Tail the log")
	cmd.Flags().IntVar(&lines, "lines", 100, "View the last n")
	return cmd
}
NewProcessorsLogsCommand creates `processors logs` command
package processor
import (
	"net/url"
	"sort"
	"strings"
	"github.com/kataras/golog"
	"github.com/lensesio/bite"
	"github.com/lensesio/lenses-go/pkg/api"
	config "github.com/lensesio/lenses-go/pkg/configs"
	"github.com/lensesio/lenses-go/pkg/utils"
	"github.com/spf13/cobra"
)
func NewGetProcessorsCommand() *cobra.Command {
	var name, clusterName, namespace string
	cmd := &cobra.Command{
		Use:              "processors",
		Short:            "List of all available processors",
		Example:          `processors`,
		SilenceErrors:    true,
		TraverseChildren: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			result, err := config.Client.GetProcessors()
			if err != nil {
				golog.Errorf("Failed to retrieve processors. [%s]", err.Error())
				return err
			}
			mode, err := config.Client.GetExecutionMode()
			if err != nil {
				return err
			}
			sort.Slice(result.Streams, func(i, j int) bool {
				return result.Streams[i].Name < result.Streams[j].Name
			})
			var final []api.ProcessorStream
			for _, processor := range result.Streams {
				if mode == api.ExecutionModeConnect || mode == api.ExecutionModeKubernetes {
					if name != "" && processor.Name != name {
						continue
					}
				}
				if mode == api.ExecutionModeKubernetes {
					if namespace != "" && processor.Namespace != namespace {
						continue
					}
				}
				if clusterName != "" && clusterName != processor.ClusterName {
					continue
				}
				final = append(final, processor)
			}
			return bite.PrintObject(cmd, final)
		},
	}
	cmd.Flags().StringVar(&name, "name", "", "Select by processor name, available only in CONNECT and KUBERNETES mode")
	cmd.Flags().StringVar(&clusterName, "cluster-name", "", "Select by cluster name, available only in CONNECT and KUBERNETES mode")
	cmd.Flags().StringVar(&namespace, "namespace", "", "Select by namespace, available only in KUBERNETES mode")
	bite.CanPrintJSON(cmd)
	cmd.AddCommand(NewProcessorsLogsCommand())
	cmd.AddCommand(NewListDeploymentTargetsCommand())
	return cmd
}