diff --git a/manager/manifests/fluentd.yaml b/manager/manifests/fluentd.yaml
index d640672b92..f9b16fcac6 100644
--- a/manager/manifests/fluentd.yaml
+++ b/manager/manifests/fluentd.yaml
@@ -69,6 +69,7 @@ data:
       pos_file /var/log/fluentd-containers.log.pos
       tag *
       read_from_head true
+      refresh_interval 1
       <parse>
         @type json
         time_format %Y-%m-%dT%H:%M:%S.%NZ
@@ -81,79 +82,24 @@ data:
         @id filter_kube_metadata
       </filter>
 
-      <match **>
-        @type route
-        <route **>
-          copy
-          @label @by_pod
-        </route>
-        <route **>
-          copy
-          @label @by_endpoint
-        </route>
-      </match>
-    </label>
-
-    <label @by_pod>
-      <filter **>
-        @type record_transformer
-        @id filter_containers_stream_transformer
-        <record>
-          stream_name ${tag_parts[3]}
-        </record>
-        remove_keys kubernetes,docker,stream
-      </filter>
-      <match **>
-        @type cloudwatch_logs
-        region "#{ENV['AWS_REGION']}"
-        log_group_name "#{ENV['LOG_GROUP_NAME']}"
-        log_stream_name_key stream_name
-        remove_log_stream_name_key true
-        auto_create_stream true
-        <buffer>
-          flush_interval 5
-          chunk_limit_size 2m
-          queued_chunks_limit_size 32
-          retry_forever true
-        </buffer>
-      </match>
-    </label>
-
-    <label @by_endpoint>
       <filter **>
         @type record_transformer
         enable_ruby
         <record>
-          workload_type ${record.dig("kubernetes", "labels", "workloadType") || "unknown"}
+          stream_name ${record.dig("kubernetes", "pod_name")}_${record.dig("kubernetes", "container_name")}
+          log ${record.dig("log").rstrip}
         </record>
-        remove_keys docker,stream
-      </filter>
-
-      <filter **>
-        @type grep
-        regexp1 workload_type api
-      </filter>
-      <filter **>
-        @type record_transformer
-        enable_ruby
-        <record>
-          pod_name ${record.dig("kubernetes", "pod_name")}
-          container_name ${record.dig("kubernetes", "container_name")}
-          workload_id ${record.dig("kubernetes", "labels", "workloadID")}
-          stream_name ${record.dig("kubernetes", "labels", "appName")}.${record.dig("kubernetes", "labels", "apiName")}
-        </record>
-        remove_keys kubernetes,api_name,app_name,workload_type
+        remove_keys kubernetes,docker,stream
       </filter>
       <match **>
         @type cloudwatch_logs
-        @id out_cloudwatch_logs_endpoints
         region "#{ENV['AWS_REGION']}"
         log_group_name "#{ENV['LOG_GROUP_NAME']}"
         log_stream_name_key stream_name
         remove_log_stream_name_key true
         auto_create_stream true
         <buffer>
-          flush_interval 5
+          flush_interval 2
           chunk_limit_size 2m
           queued_chunks_limit_size 32
           retry_forever true
diff --git a/pkg/lib/aws/aws.go b/pkg/lib/aws/aws.go
index 9dda79bfd4..47c93c0c89 100644
--- a/pkg/lib/aws/aws.go
+++ b/pkg/lib/aws/aws.go
@@ -33,7 +33,7 @@ type Client struct {
 	Bucket               string
 	S3                   *s3.S3
 	stsClient            *sts.STS
-	cloudWatchLogsClient *cloudwatchlogs.CloudWatchLogs
+	CloudWatchLogsClient *cloudwatchlogs.CloudWatchLogs
 	CloudWatchMetrics    *cloudwatch.CloudWatch
 	awsAccountID         string
 	HashedAccountID      string
@@ -51,7 +51,7 @@ func New(region string, bucket string, withAccountID bool) (*Client, error) {
 		S3:                   s3.New(sess),
 		stsClient:            sts.New(sess),
 		CloudWatchMetrics:    cloudwatch.New(sess),
-		cloudWatchLogsClient: cloudwatchlogs.New(sess),
+		CloudWatchLogsClient: cloudwatchlogs.New(sess),
 	}
 
 	if withAccountID {
diff --git a/pkg/lib/aws/errors.go b/pkg/lib/aws/errors.go
index f9422d2da2..57e0c2343f 100644
--- a/pkg/lib/aws/errors.go
+++ b/pkg/lib/aws/errors.go
@@ -79,14 +79,14 @@ func (t ErrorKind) MarshalBinary() ([]byte, error) {
 }
 
 func IsNoSuchKeyErr(err error) bool {
-	return checkErrCode(err, "NoSuchKey")
+	return CheckErrCode(err, "NoSuchKey")
 }
 
 func IsNotFoundErr(err error) bool {
-	return checkErrCode(err, "NotFound")
+	return CheckErrCode(err, "NotFound")
 }
 
-func checkErrCode(err error, errorCode string) bool {
+func CheckErrCode(err error, errorCode string) bool {
 	awsErr, ok := errors.Cause(err).(awserr.Error)
 	if !ok {
 		return false
diff --git a/pkg/lib/aws/logs.go b/pkg/lib/aws/logs.go
deleted file mode 100644
index a1d04a5cd7..0000000000
--- a/pkg/lib/aws/logs.go
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
-Copyright 2019 Cortex Labs, Inc.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package aws
-
-import (
-	"bytes"
-	"encoding/json"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/cloudwatchlogs"
-
-	"github.com/cortexlabs/cortex/pkg/lib/errors"
-)
-
-type FluentdLog struct {
-	Log    string `json:"log"`
-	Stream string `json:"stream"`
-	Docker struct {
-		ContainerID string `json:"container_id"`
-	} `json:"docker"`
-	Kubernetes struct {
-		ContainerName string `json:"container_name"`
-		NamespaceName string `json:"namespace_name"`
-		PodName       string `json:"pod_name"`
-		OrphanedName  string `json:"orphaned_namespace"`
-		NamespaceID   string `json:"namespace_id"`
-	} `json:"kubernetes"`
-}
-
-func (c *Client) GetLogs(prefix string, logGroup string) (string, error) {
-	logStreamsOut, err := c.cloudWatchLogsClient.DescribeLogStreams(&cloudwatchlogs.DescribeLogStreamsInput{
-		Limit:               aws.Int64(50),
-		LogGroupName:        aws.String(logGroup),
-		LogStreamNamePrefix: aws.String(prefix),
-	})
-	if err != nil {
-		return "", errors.Wrap(err, "cloudwatch logs", prefix)
-	}
-
-	var allLogsBuf bytes.Buffer
-
-	for i, logStream := range logStreamsOut.LogStreams {
-		getLogEventsInput := &cloudwatchlogs.GetLogEventsInput{
-			LogGroupName:  &logGroup,
-			LogStreamName: logStream.LogStreamName,
-			StartFromHead: aws.Bool(true),
-		}
-
-		err := c.cloudWatchLogsClient.GetLogEventsPages(getLogEventsInput, func(logEventsOut *cloudwatchlogs.GetLogEventsOutput, lastPage bool) bool {
-			for _, logEvent := range logEventsOut.Events {
-				var log FluentdLog
-				// millis := *logEvent.Timestamp
-				// timestamp := time.Unix(0, millis*int64(time.Millisecond))
-				json.Unmarshal([]byte(*logEvent.Message), &log)
-				allLogsBuf.WriteString(log.Log)
-			}
-			return true
-		})
-		if err != nil {
-			return "", errors.Wrap(err, "cloudwatch logs", prefix)
-		}
-
-		if i < len(logStreamsOut.LogStreams)-1 {
-			allLogsBuf.WriteString("\n----------\n\n")
-		}
-	}
-
-	return allLogsBuf.String(), nil
-}
diff --git a/pkg/operator/workloads/logs.go b/pkg/operator/workloads/logs.go
index 508ddb7f55..d47adb4e2c 100644
--- a/pkg/operator/workloads/logs.go
+++ b/pkg/operator/workloads/logs.go
@@ -17,21 +17,18 @@ limitations under the License.
 package workloads
 
 import (
-	"bufio"
-	"fmt"
-	"io"
-	"os"
-	"sort"
-	"strings"
+	"encoding/json"
 	"time"
 
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/cloudwatchlogs"
 	"github.com/gorilla/websocket"
-	kcore "k8s.io/api/core/v1"
 
-	"github.com/cortexlabs/cortex/pkg/lib/errors"
+	awslib "github.com/cortexlabs/cortex/pkg/lib/aws"
 	"github.com/cortexlabs/cortex/pkg/lib/k8s"
 	"github.com/cortexlabs/cortex/pkg/lib/sets/strset"
 	s "github.com/cortexlabs/cortex/pkg/lib/strings"
+	"github.com/cortexlabs/cortex/pkg/operator/api/context"
 	"github.com/cortexlabs/cortex/pkg/operator/config"
 )
 
@@ -40,423 +37,189 @@ const (
 	socketCloseGracePeriod  = 10 * time.Second
 	socketMaxMessageSize    = 8192
 
-	pendingPodCheckInterval = 1 * time.Second
-	newPodCheckInterval     = 5 * time.Second
-	firstPodCheckInterval   = 500 * time.Millisecond
-	maxParallelPodLogging   = 5
-	initLogTailLines        = 100
+	maxLogLinesPerRequest = 500
+	pollPeriod            = 250 * time.Millisecond
 )
 
-func ReadLogs(appName string, podSearchLabels map[string]string, socket *websocket.Conn) {
-	wrotePending := false
-
-	for true {
-		pods, err := config.Kubernetes.ListPodsByLabels(podSearchLabels)
-		if err != nil {
-			writeSocket(err.Error(), socket)
-			return
-		}
-
-		if len(pods) > 0 {
-			if len(pods) > maxParallelPodLogging {
-				if !writeSocket(fmt.Sprintf("\n%d pods available, streaming logs for %d of them:", len(pods), maxParallelPodLogging), socket) {
-					return
-				}
-			}
-
-			podMap := make(map[k8s.PodStatus][]kcore.Pod)
-			for _, pod := range pods {
-				podStatus := k8s.GetPodStatus(&pod)
-				if len(podMap[podStatus]) < maxParallelPodLogging {
-					podMap[podStatus] = append(podMap[podStatus], pod)
-				}
-			}
-
-			switch {
-			case len(podMap[k8s.PodStatusSucceeded]) > 0:
-				getKubectlLogs(podMap[k8s.PodStatusSucceeded], wrotePending, socket)
-			case len(podMap[k8s.PodStatusRunning]) > 0:
-				getKubectlLogs(podMap[k8s.PodStatusRunning], wrotePending, socket)
-			case len(podMap[k8s.PodStatusPending]) > 0:
-				getKubectlLogs(podMap[k8s.PodStatusPending], wrotePending, socket)
-			case len(podMap[k8s.PodStatusKilled]) > 0:
-				getKubectlLogs(podMap[k8s.PodStatusKilled], wrotePending, socket)
-			case len(podMap[k8s.PodStatusKilledOOM]) > 0:
-				getKubectlLogs(podMap[k8s.PodStatusKilledOOM], wrotePending, socket)
-			case len(podMap[k8s.PodStatusFailed]) > 0:
-				getKubectlLogs(podMap[k8s.PodStatusFailed], wrotePending, socket)
-			case len(podMap[k8s.PodStatusTerminating]) > 0:
-				getKubectlLogs(podMap[k8s.PodStatusTerminating], wrotePending, socket)
-			case len(podMap[k8s.PodStatusUnknown]) > 0:
-				getKubectlLogs(podMap[k8s.PodStatusUnknown], wrotePending, socket)
-			default: // unexpected
-				if len(pods) > maxParallelPodLogging {
-					pods = pods[:maxParallelPodLogging]
-				}
-				getKubectlLogs(pods, wrotePending, socket)
-			}
-			return
-		}
-
-		// WorkloadID is present when logging job pods and missing for APIs. Only go to cloudwatch for job pods.
-		if workloadID, ok := podSearchLabels["workloadID"]; ok {
-			isEnded, err := IsWorkloadEnded(appName, workloadID)
-			if err != nil {
-				writeSocket(err.Error(), socket)
-				return
-			}
-
-			if isEnded {
-				getCloudWatchLogs(workloadID, socket)
-				return
-			}
-		}
-
-		if !wrotePending {
-			if !writeSocket("\nPending...", socket) {
-				return
-			}
-			wrotePending = true
-		}
-
-		time.Sleep(pendingPodCheckInterval)
-	}
-}
-
-func getKubectlLogs(pods []kcore.Pod, wrotePending bool, socket *websocket.Conn) {
-	if !wrotePending {
-		isAllPending := true
-		for _, pod := range pods {
-			if k8s.GetPodStatus(&pod) != k8s.PodStatusPending {
-				isAllPending = false
-				break
-			}
-		}
-
-		if isAllPending {
-			if !writeSocket("\nPending...", socket) {
-				return
-			}
-			wrotePending = true
-		}
-	}
-
-	inr, inw, err := os.Pipe()
-	if err != nil {
-		errors.Panic(err, "logs", "kubectl", "os.pipe")
-	}
-	defer inw.Close()
-	defer inr.Close()
-
+func ReadLogs(appName string, podLabels map[string]string, socket *websocket.Conn) {
 	podCheckCancel := make(chan struct{})
 	defer close(podCheckCancel)
-
-	go podCheck(podCheckCancel, socket, pods, wrotePending, inr)
-	pumpStdin(socket, inw)
+	go StreamFromCloudWatch(podCheckCancel, appName, podLabels, socket)
+	pumpStdin(socket)
 	podCheckCancel <- struct{}{}
 }
 
-type LogKey struct {
-	PodName       string
-	ContainerName string
-	RestartCount  int32
-}
-
-func (l LogKey) String() string {
-	return fmt.Sprintf("%s,%s,%d", l.PodName, l.ContainerName, l.RestartCount)
-}
-
-func StringToLogKey(str string) LogKey {
-	split := strings.Split(str, ",")
-	restartCount, _ := s.ParseInt32(split[2])
-	return LogKey{PodName: split[0], ContainerName: split[1], RestartCount: restartCount}
-}
-
-func GetLogKey(pod kcore.Pod, status kcore.ContainerStatus) LogKey {
-	return LogKey{PodName: pod.Name, ContainerName: status.Name, RestartCount: status.RestartCount}
-}
-
-func CurrentLoggingProcesses(logProcesses map[string]*os.Process) strset.Set {
-	set := strset.New()
-	for identifier := range logProcesses {
-		set.Add(identifier)
-	}
-	return set
-}
-
-func GetLogKeys(pod kcore.Pod) strset.Set {
-	containerStatuses := append(pod.Status.InitContainerStatuses, pod.Status.ContainerStatuses...)
-	logKeys := strset.New()
-	for _, status := range containerStatuses {
-		if status.State.Terminated != nil || status.State.Running != nil || (status.State.Waiting != nil && status.RestartCount != 0) {
-			logKeys.Add(GetLogKey(pod, status).String())
+func pumpStdin(socket *websocket.Conn) {
+	socket.SetReadLimit(socketMaxMessageSize)
+	for {
+		_, _, err := socket.ReadMessage()
+		if err != nil {
+			break
 		}
 	}
-
-	return logKeys
 }
 
-func createKubectlProcess(logKey LogKey, attrs *os.ProcAttr) (*os.Process, error) {
-	cmdPath := "/usr/local/bin/kubectl"
-
-	kubectlArgs := []string{"kubectl", "-n=" + config.Cortex.Namespace, "logs", "--follow=true", logKey.PodName, logKey.ContainerName, fmt.Sprintf("--tail=%d", initLogTailLines)}
-	process, err := os.StartProcess(cmdPath, kubectlArgs, attrs)
-	if err != nil {
-		return nil, errors.Wrap(err, strings.Join(kubectlArgs, " "))
-	}
-	return process, nil
+type FluentdLog struct {
+	Log string `json:"log"`
 }
 
-func podCheck(podCheckCancel chan struct{}, socket *websocket.Conn, initialPodList []kcore.Pod, wrotePending bool, inr *os.File) {
+func StreamFromCloudWatch(podCheckCancel chan struct{}, appName string, podLabels map[string]string, socket *websocket.Conn) {
 	timer := time.NewTimer(0)
 	defer timer.Stop()
 
-	processMap := make(map[string]*os.Process)
-	defer deleteProcesses(processMap)
-	labels := initialPodList[0].GetLabels()
-	podSearchLabels := map[string]string{
-		"appName":      labels["appName"],
-		"workloadType": labels["workloadType"],
-		"userFacing":   "true",
-	}
-
-	if labels["workloadType"] == workloadTypeAPI {
-		podSearchLabels["apiName"] = labels["apiName"]
-	} else {
-		podSearchLabels["workloadID"] = labels["workloadID"]
-	}
-
-	outr, outw, err := os.Pipe()
-	if err != nil {
-		errors.Panic(err, "logs", "kubectl", "os.pipe")
-	}
-	defer outw.Close()
-	defer outr.Close()
-
-	procAttr := os.ProcAttr{
-		Files: []*os.File{inr, outw, outw},
-	}
-
-	socketWriterError := make(chan error, 1)
-	defer close(socketWriterError)
+	lastTimestamp := int64(0)
+	previousEvents := strset.New()
+	wrotePending := false
 
-	go pumpStdout(socket, socketWriterError, outr)
+	var currentContextID string
+	var prefix string
+	var ctx *context.Context
+	var err error
 
 	for {
 		select {
 		case <-podCheckCancel:
 			return
 		case <-timer.C:
-			pods, err := config.Kubernetes.ListPodsByLabels(podSearchLabels)
-
-			if err != nil {
-				socketWriterError <- errors.Wrap(err, "pod check")
-				return
-			}
-
-			latestRunningPodsMap := make(map[string]kcore.Pod)
-			latestRunningPods := strset.New()
-			for _, pod := range pods {
-				if k8s.GetPodStatus(&pod) != k8s.PodStatusPending {
-					latestRunningPods.Add(pod.GetName())
-					latestRunningPodsMap[pod.GetName()] = pod
+			ctx = CurrentContext(appName)
+
+			if ctx == nil {
+				writeString(socket, "\ndeployment "+appName+" not found")
+				closeSocket(socket)
+				continue
+			}
+
+			if ctx.ID != currentContextID {
+				if len(currentContextID) != 0 {
+					if apiName, ok := podLabels["apiName"]; ok {
+						if _, ok := ctx.APIs[apiName]; !ok {
+							writeString(socket, "\napi "+apiName+" was not found in latest deployment")
+							closeSocket(socket)
+							continue
+						}
+						podLabels["workloadID"] = ctx.APIs[apiName].WorkloadID
+						writeString(socket, "\na new deployment was detected, streaming logs from the latest deployment")
+					} else {
+						writeString(socket, "\nnew deployment detected, shutting down log stream") // unexpected for now, should only occur when logging non api resources
+						closeSocket(socket)
+						continue
+					}
 				}
-			}
 
-			runningLogProcesses := CurrentLoggingProcesses(processMap)
-
-			sortedPods := latestRunningPods.Slice()
-			sort.Slice(sortedPods, func(i, j int) bool {
-				return latestRunningPodsMap[sortedPods[i]].CreationTimestamp.After(latestRunningPodsMap[sortedPods[j]].CreationTimestamp.Time)
-			})
+				currentContextID = ctx.ID
 
-			expectedLogProcesses := strset.New()
-			for i, podName := range sortedPods {
-				if i >= maxParallelPodLogging {
-					break
+				pods, err := config.Kubernetes.ListPodsByLabels(podLabels)
+				if err != nil {
+					writeString(socket, err.Error())
+					closeSocket(socket)
+					continue
 				}
-				expectedLogProcesses.Merge(GetLogKeys(latestRunningPodsMap[podName]))
-			}
 
-			processesToDelete := strset.Difference(runningLogProcesses, expectedLogProcesses)
-			processesToAdd := strset.Difference(expectedLogProcesses, runningLogProcesses)
-
-			if wrotePending && len(latestRunningPods) > 0 {
-				if !writeSocket("Streaming logs:", socket) {
-					return
+				allPodsPending := true
+				for _, pod := range pods {
+					if k8s.GetPodStatus(&pod) != k8s.PodStatusPending {
+						allPodsPending = false
+						break
+					}
 				}
-				wrotePending = false
-			}
 
-			initProcesses := strset.New()
-			tfServingProcesses := strset.New()
-			apiProcesses := strset.New()
-
-			for logProcess := range processesToAdd {
-				logKey := StringToLogKey(logProcess)
-				switch logKey.ContainerName {
-				case downloaderInitContainerName:
-					initProcesses.Add(logProcess)
-				case tfServingContainerName:
-					tfServingProcesses.Add(logProcess)
-				case apiContainerName:
-					apiProcesses.Add(logProcess)
-				default:
-					socketWriterError <- errors.New("unexpected container type encountered " + logKey.ContainerName) // unexpected
-					return
+				if allPodsPending {
+					writeString(socket, "\npending...")
+					wrotePending = true
+				} else {
+					wrotePending = false
 				}
+
+				prefix = ""
 			}
 
-			for logProcess := range initProcesses {
-				process, err := createKubectlProcess(StringToLogKey(logProcess), &procAttr)
+			if len(prefix) == 0 {
+				prefix, err = getPrefix(podLabels)
 				if err != nil {
-					socketWriterError <- err
-					return
+					writeString(socket, err.Error())
+					closeSocket(socket)
+					continue
 				}
-				processMap[logProcess] = process
 			}
 
-			if len(tfServingProcesses) != 0 && len(initProcesses) != 0 {
-				time.Sleep(100 * time.Millisecond)
+			if len(prefix) == 0 {
+				timer.Reset(pollPeriod)
+				continue
 			}
 
-			for logProcess := range tfServingProcesses {
-				process, err := createKubectlProcess(StringToLogKey(logProcess), &procAttr)
-				if err != nil {
-					socketWriterError <- err
-					return
+			logEventsOutput, err := config.AWS.CloudWatchLogsClient.FilterLogEvents(&cloudwatchlogs.FilterLogEventsInput{
+				LogGroupName:        aws.String(config.Cortex.LogGroup),
+				LogStreamNamePrefix: aws.String(prefix),
+				StartTime:           aws.Int64(lastTimestamp),
+				EndTime:             aws.Int64(time.Now().Unix() * 1000), // requires milliseconds
+				Limit:               aws.Int64(int64(maxLogLinesPerRequest)),
+			})
+
+			if err != nil {
+				if awslib.CheckErrCode(err, "ResourceNotFoundException") {
+					if !wrotePending {
+						writeString(socket, "pending...")
+						wrotePending = true
+					}
+				} else {
+					writeString(socket, "error encountered while fetching logs from cloudwatch: "+err.Error())
+					closeSocket(socket)
+					continue
 				}
-				processMap[logProcess] = process
 			}
 
-			if len(apiProcesses) != 0 && (len(tfServingProcesses) != 0 || len(initProcesses) != 0) {
-				time.Sleep(100 * time.Millisecond)
-			}
+			newEvents := strset.New()
+			for _, logEvent := range logEventsOutput.Events {
+				var log FluentdLog
+				json.Unmarshal([]byte(*logEvent.Message), &log)
 
-			for logProcess := range apiProcesses {
-				process, err := createKubectlProcess(StringToLogKey(logProcess), &procAttr)
-				if err != nil {
-					socketWriterError <- err
-					return
+				if !previousEvents.Has(*logEvent.EventId) {
+					socket.WriteMessage(websocket.TextMessage, []byte(log.Log))
+
+					if *logEvent.Timestamp > lastTimestamp {
+						lastTimestamp = *logEvent.Timestamp
+					}
 				}
-				processMap[logProcess] = process
+				newEvents.Add(*logEvent.EventId)
 			}
 
-			deleteMap := make(map[string]*os.Process, len(processesToDelete))
-
-			for podName := range processesToDelete {
-				deleteMap[podName] = processMap[podName]
-				delete(processMap, podName)
+			if len(logEventsOutput.Events) == maxLogLinesPerRequest {
+				socket.WriteMessage(websocket.TextMessage, []byte("---- Showing at most "+s.Int(maxLogLinesPerRequest)+" lines. Visit AWS cloudwatch logs console and search for \""+prefix+"\" in log group \""+config.Cortex.LogGroup+"\" for complete logs ----"))
 			}
 
-			go deleteProcesses(deleteMap)
-
-			if len(processMap) == 0 {
-				timer.Reset(firstPodCheckInterval)
-			} else {
-				timer.Reset(newPodCheckInterval)
-			}
+			previousEvents = newEvents
+			timer.Reset(pollPeriod)
 		}
 	}
 }
 
-func deleteProcesses(processMap map[string]*os.Process) {
-	for _, process := range processMap {
-		process.Signal(os.Interrupt)
-	}
-	time.Sleep(3 * time.Second)
-	for _, process := range processMap {
-		process.Signal(os.Kill)
-	}
-}
-
-func getCloudWatchLogs(prefix string, socket *websocket.Conn) {
-	logs, err := config.AWS.GetLogs(prefix, config.Cortex.LogGroup)
-	if err != nil {
-		config.Telemetry.ReportError(err)
-		errors.PrintError(err)
-	}
-
-	var logsReader *strings.Reader
+func getPrefix(searchLabels map[string]string) (string, error) {
+	pods, err := config.Kubernetes.ListPodsByLabels(searchLabels)
 	if err != nil {
-		logsReader = strings.NewReader(err.Error())
-	} else if logs == "" {
-		logsReader = strings.NewReader(prefix + " not found")
-	} else {
-		logsReader = strings.NewReader(logs)
+		return "", err
 	}
 
-	socketWriterError := make(chan error)
-	defer close(socketWriterError)
-	go pumpStdout(socket, socketWriterError, logsReader)
-
-	inr, inw, err := os.Pipe()
-	if err != nil {
-		errors.Panic(err, "logs", "cloudwatch", "os.pipe")
+	if len(pods) == 0 {
+		return "", nil
 	}
-	defer inr.Close()
-	defer inw.Close()
-
-	pumpStdin(socket, inw)
-}
-
-func pumpStdin(socket *websocket.Conn, writer io.Writer) {
-	socket.SetReadLimit(socketMaxMessageSize)
-	for {
-		_, message, err := socket.ReadMessage()
-		if err != nil {
-			break
-		}
 
-		message = append(message, '\n')
-		_, err = writer.Write(message)
-		if err != nil {
-			break
+	podLabels := pods[0].GetLabels()
+	if apiName, ok := podLabels["apiName"]; ok {
+		if podTemplateHash, ok := podLabels["pod-template-hash"]; ok {
+			return internalAPIName(apiName, podLabels["appName"]) + "-" + podTemplateHash, nil
 		}
+		return "", nil // unexpected, pod template hash not set yet
 	}
+	return pods[0].Name, nil // unexpected, logging non api resources
 }
 
-func pumpStdout(socket *websocket.Conn, socketWriterError chan error, reader io.Reader) {
-	scanner := bufio.NewScanner(reader)
-	for scanner.Scan() {
-		socket.SetWriteDeadline(time.Now().Add(socketWriteDeadlineWait))
-		logBytes := scanner.Bytes()
-
-		if logBytes != nil {
-			if !writeSocketBytes(logBytes, socket) {
-				break
-			}
-		}
-	}
-
-	select {
-	case err := <-socketWriterError:
-		if err != nil {
-			writeSocket(err.Error()+"\n", socket)
-		}
-	default:
-	}
+func writeString(socket *websocket.Conn, message string) {
+	socket.SetWriteDeadline(time.Now().Add(socketWriteDeadlineWait))
+	socket.WriteMessage(websocket.TextMessage, []byte(message))
+}
 
+func closeSocket(socket *websocket.Conn) {
 	socket.SetWriteDeadline(time.Now().Add(socketWriteDeadlineWait))
 	socket.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
 	time.Sleep(socketCloseGracePeriod)
-	socket.Close()
-}
-
-func stopProcess(process *os.Process) {
-	process.Signal(os.Interrupt)
-	time.Sleep(5 * time.Second)
-	process.Signal(os.Kill)
-}
-
-func writeSocket(message string, socket *websocket.Conn) bool {
-	return writeSocketBytes([]byte(message), socket)
-}
-
-func writeSocketBytes(message []byte, socket *websocket.Conn) bool {
-	err := socket.WriteMessage(websocket.TextMessage, message)
-	if err != nil {
-		return false
-	}
-	return true
 }