Golang WaitGroup causing memory leak, what can I do to improve this function

I've been struggling to find a memory leak in our application and have been using the pprof tool to understand what's going on.

When I look at the heap, I constantly see the following function and I don't understand why (or if) it's actually a problem.

func CreateClients(raw []byte) bool {

	macs := []string{}
	conn := FormatConn(raw)

	if conn.Ap_Mac != "" {

		var wg sync.WaitGroup
		var array []Client

		c1 := make(chan Client)

		clients := FormatClients(conn)

		wg.Add(len(clients))

		for _, c := range clients {
			go func(d Client) {
				defer wg.Done()
				c1 <- UpdateClients(d)
			}(c)
		}

		go func() {
            defer wg.Done()
			for {
				select {
				case client := <-c1:
					array = append(array, client)
					macs = append(macs, client.Client_Mac)
				}
			}
		}()

		wg.Wait()
        // Do some other stuff
    ...
}

The UpdateClients function updates the client model in Mongo. When it returns, I need each client - so I can index it with ES plus I need an array of the macs to do some other stuff.

I've gone through the online examples and thought this was the recommended way to loop through a channel.

My pprof heap looks like this, and grows steadily over a few days:

7.53MB of 9.53MB total (79.00%)
Dropped 234 nodes (cum <= 0.05MB)
Showing top 5 nodes out of 28 (cum >= 1MB)
      flat  flat%   sum%        cum   cum%
       2MB 21.00% 21.00%        2MB 21.00%  strings.Replace
    1.51MB 15.89% 36.89%     1.51MB 15.89%  github.com/PolkaSpots/worker/worker.func·006
    1.51MB 15.87% 52.76%     1.51MB 15.87%  github.com/PolkaSpots/worker/worker.func·008
    1.50MB 15.75% 68.51%     1.50MB 15.75%  newproc_m
       1MB 10.50% 79.00%        1MB 10.50%  gopkg.in/mgo.v2/bson.(*decoder).readStr

Is there a more efficient / recommended way to achieve this?

EDIT_

As suggested, I've altered the loop as so

	done := make(chan bool)

	go func() {
		for {
			select {
			case client := <-c1:
				array = append(array, client)
				macs = append(macs, client.Client_Mac)
			case <-done:
				return
			}
		}
	}()

	wg.Wait()
	close(done)

The receive loop never breaks:

  for {
            select {
            case client := <-c1:
            ...
   }

It has no stop condition, no timeout, nothing - so it will just hang there forever - even if your whole function exits. and it will leak both the goroutine and the channel.

On top of that, you're deferring a wg.Done when this loop exits, but you're not doing wg.Add to match it. So if this loop ever exits, you will panic.

What you need to do is find some way to stop the for/select loop. Simplest way IMO - add a second channel that receives data after wg.Wait(), but do not do wg.Done() in that goroutine.