[go-nuts] How to properly set an http.Client limits and monitor connection pool

[Javier]

Hi

I am load testing a simple application that calls an echo service with a 
GET.
My application is tested with ab tool and the load is 500 concurrent 
connections with 50000 requests.

The application is failing after a while because i/o errors that I assume 
are related to the client connection pool.
I have set the pool to 10000 after check with netstat the number of 
connections in wait status created by my app. It worked fine at home (in 
windows and in my macbook) but failed in a Linux server at work.

I am wondering how to properly set limits in client to prevent my 
application to stop due to errors or even how to monitor and trace how many 
connections of the pool are used and their status.. (is it possible).

My application is doing this (just relevant parts of the code)



// Handle iterative path and calls iterative calculation service
func echoHandler(calledServiceURL string, netClient *http.Client) func(w 
http.ResponseWriter, r *http.Request) {
    return func(w http.ResponseWriter, r *http.Request) {

        params := mux.Vars(r)

        url := calledServiceURL + "/echo/" + params["message"]

        req, reqErr := http.NewRequest("GET", url, nil)
        if reqErr != nil {
            log.Fatal("Error en response: ", reqErr)
            fmt.Fprintf(w, "Error en response: %s", reqErr)
            return
        }

        req.Header.Set("Connection", "close")
        //req.Header.Set("Connection", "Keep-Alive")

        resp, err := netClient.Do(req)
        if err != nil {
            log.Fatal("Error en response: ", err)
            fmt.Fprintf(w, "Error en response: %s", err)
            return
        }

        respData, errResp := ioutil.ReadAll(resp.Body)
        resp.Body.Close()
        if errResp != nil {
            log.Fatal("Error en RespData", errResp)
            fmt.Fprintf(w, "Error en respData: %s", err)
            return
        }

        fmt.Fprintf(w, "%s", respData)

    }
}


// Define just one transport for all calls
    tr := &http.Transport{
        MaxIdleConns: 10000, // iddle conn pool size
        MaxIdleConnsPerHost: 10000, // iddle conn pool size per host
        DisableKeepAlives: true, // disable keep alive
    }

    netClient := &http.Client{Transport: tr}

    router := mux.NewRouter()

    router.HandleFunc("/", Index).Methods("GET")
    router.HandleFunc("/echo/{message}", echoHandler(viper.GetString(
"calledServiceURL"),
        netClient)).Methods("GET")

    srv := &http.Server{
        Addr: viper.GetString("port"),
        // 
https://stackoverflow.com/questions/29334407/creating-an-idle-timeout-in-go
        //WriteTimeout: time.Second * 60,
        ReadTimeout: time.Second * 15,
        //IdleTimeout: time.Second * 120,
        //Handler: router, // Pass our instance of gorilla/mux in.
        Handler: router,
    }

    // Run our server in a goroutine so that it doesn't block.
    go func() {
        log.Println("Running server....")

        if err := srv.ListenAndServe(); err != nil {
            log.Println(err)
        }
    }()

    c := make(chan os.Signal, 1)
    // We'll accept graceful shutdowns when quit via SIGINT (Ctrl+C)
    // SIGKILL, SIGQUIT or SIGTERM (Ctrl+/) will not be caught.
    signal.Notify(c, os.Interrupt)

    // Block until we receive our signal.
    <-c

   
    ctx, cancel := context.WithTimeout(context.Background(), time.Second*3)
    defer cancel()
   
 srv.Shutdown(ctx)
    fmt.Println("\n\n")
    log.Println("shutting down")
    log.Println("Goddbye!....")
    os.Exit(0)


Thanks in advance
J

-- 
You received this message because you are subscribed to the Google Groups 
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to golang-nuts+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.