code: func (c *realRecyclerClient) WatchPod(name, namespace string, stopChannel chan struct{}) (<-chan watch.Event, error) {
  	podSelector, err := fields.ParseSelector("metadata.name=" + name)
  	if err != nil {
  		return nil, err
  	}
  	options := metav1.ListOptions{
  		FieldSelector: podSelector.String(),
  		Watch:         true,
  	}
  
  	podWatch, err := c.client.CoreV1().Pods(namespace).Watch(options)
  	if err != nil {
  		return nil, err
  	}
  
  	eventSelector, _ := fields.ParseSelector("involvedObject.name=" + name)
  	eventWatch, err := c.client.CoreV1().Events(namespace).Watch(metav1.ListOptions{
  		FieldSelector: eventSelector.String(),
  		Watch:         true,
  	})
  	if err != nil {
  		podWatch.Stop()
  		return nil, err
  	}
  
  	eventCh := make(chan watch.Event, 30)
  	var wg sync.WaitGroup
  	wg.Add(2)
  
  	go func() {
  		defer close(eventCh)
  		wg.Wait()
  	}()
  
  	go func() {
  		defer eventWatch.Stop()
  		defer wg.Done()
  		for {
  			select {
  			case _ = <-stopChannel:
  				return
  			case eventEvent, ok := <-eventWatch.ResultChan():
  				if !ok {
  					return
  				}
  				eventCh <- eventEvent
  			}
  		}
  	}()
  
  	go func() {
  		defer podWatch.Stop()
  		defer wg.Done()
  		for {
  			select {
  			case <-stopChannel:
  				return
  
  			case podEvent, ok := <-podWatch.ResultChan():
  				if !ok {
  					return
  				}
  				eventCh <- podEvent
  			}
  		}
  	}()
  
  	return eventCh, nil
  }
docs: // WatchPod watches a pod and events related to it. It sends pod updates and events over the returned channel
  // It will continue until stopChannel is closed