panic: send on closed channel about go2sky HOT 9 CLOSED

	// Use gRPC reporter for production
	r, err := reporter.NewGRPCReporter()
	if err != nil {
		log.Fatalf("new reporter error %v \n", err)
	}
	tracer, err := go2sky.NewTracer("example", go2sky.WithReporter(r))
	if err != nil {
		log.Fatalf("create tracer error %v \n", err)
	}
	// This for test
	tracer.WaitUntilRegister()
	span, ctx, err := tracer.CreateLocalSpan(context.Background())
	if err != nil {
		log.Fatalf("create new local span error %v \n", err)
	}
        r.Close()
	subSpan.End()

package apm


import (
    "fmt"
    "github.com/SkyAPM/go2sky"
    "github.com/SkyAPM/go2sky/reporter"
)

func GetSkyTracer() *go2sky.Tracer{
    // Use gRPC reporter for production
    re, err := reporter.NewGRPCReporter("10.206.36.156:11800")
    if err != nil {
        fmt.Println("new reporter error %v \n", err)
        return nil
    }
    defer re.Close()

    tracer, err := go2sky.NewTracer("libra", go2sky.WithReporter(re))
    if err != nil {
        fmt.Println("create tracer error %v \n", err)
        return nil
    }
    tracer.WaitUntilRegister()

    return tracer
}

package apm


import (
    "fmt"
    "strconv"
    "sync"
    "time"

    "github.com/SkyAPM/go2sky"
    "github.com/SkyAPM/go2sky/propagation"
    "github.com/SkyAPM/go2sky/reporter/grpc/common"
    "github.com/gin-gonic/gin"
)

const (
    httpServerComponentID int32 = 49
)

type routeInfo struct {
    operationName string
}

type middleware struct {
    routeMap     map[string]map[string]routeInfo
    routeMapOnce sync.Once
}

//Middleware gin middleware return HandlerFunc  with tracing.
func Middleware(engine *gin.Engine, tracer *go2sky.Tracer) gin.HandlerFunc {
    if engine == nil || tracer == nil {
        return func(c *gin.Context) {
            c.Next()
        }
    }
    m := new(middleware)

    return func(c *gin.Context) {
        if c.Request.Method == "OPTIONS" {
            return
        }
        m.routeMapOnce.Do(func() {
            routes := engine.Routes()
            rm := make(map[string]map[string]routeInfo)
            for _, r := range routes {
                mm := rm[r.Method]
                if mm == nil {
                    mm = make(map[string]routeInfo)
                    rm[r.Method] = mm
                }
                mm[r.Handler] = routeInfo{
                    operationName: c.Request.Host + c.Request.URL.Path,
                }
                m.routeMap = rm
            }
        })
        var operationName string
        handlerName := c.HandlerName()
        if routeInfo, ok := m.routeMap[c.Request.Method][handlerName]; ok {
            operationName = routeInfo.operationName
        }
        if operationName == "" {
            operationName = c.Request.Method
        }
        span, ctx, err := tracer.CreateEntrySpan(c.Request.Context(), operationName, func() (string, error) {
            return c.Request.Header.Get(propagation.Header), nil
        })
        if err != nil {
            c.Next()
            return
        }
        span.SetComponent(httpServerComponentID)
        span.Tag(go2sky.TagHTTPMethod, c.Request.Method)
        span.Tag(go2sky.TagURL, c.Request.Host+c.Request.URL.Path)
        span.SetSpanLayer(common.SpanLayer_Http)

        c.Request = c.Request.WithContext(ctx)

        c.Next()

        if len(c.Errors) > 0 {
            span.Error(time.Now(), c.Errors.String())
        }

        span.Tag(go2sky.TagStatusCode, strconv.Itoa(c.Writer.Status()))
        span.End()

    }
}

func main() {
    r := gin.New()
    gin.SetMode("release")
    tracer := apm.GetSkyTracer()
    r.Use(apm.Middleware(r, tracer))
}

func GetSkyTracer() *go2sky.Tracer{
    // Use gRPC reporter for production
    re, err := reporter.NewGRPCReporter("10.206.36.156:11800")
    if err != nil {
        fmt.Println("new reporter error %v \n", err)
        return nil
    }
    defer re.Close()

    tracer, err := go2sky.NewTracer("libra", go2sky.WithReporter(re))
    if err != nil {
        fmt.Println("create tracer error %v \n", err)
        return nil
    }
    tracer.WaitUntilRegister()

    return tracer
}