Connection Refused

package main

import (
    "database/sql"
    "encoding/json"
    "errors"
    "fmt"
    "io"
    "log"
    "net/http"
    "os"
    "time"
    "github.com/gorilla/mux"
    _ "github.com/lib/pq"
)

type AppLog struct {
    AppId       string `json:"appId"`
    LogTitle    string `json:"logTitle"`
    AppTitle    string `json:"appTitle"`
    LogContent  string `json:"logContent"`
    LogDateTime string `json:"logDateTime"`
}

func main() {
    db, dbErr := sql.Open("postgres", os.Getenv("DATABASE_URL"))
    if dbErr != nil {
        fmt.Println("Database error: ", dbErr);
        log.Fatal(dbErr);
    }

    defer db.Close()

    _, createErr := db.Exec("CREATE TABLE IF NOT EXISTS logs (id SERIAL PRIMARY KEY, appId TEXT NOT NULL, logTitle TEXT NOT NULL, appTitle TEXT, logContent TEXT, logDateTime TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW())")
    if createErr != nil {
        log.Fatal(createErr)
    }

    router := mux.NewRouter().StrictSlash(true)
    router.HandleFunc("/", getRoot)
    router.HandleFunc("/logs", getAllAppLogs(db)).Methods("GET")
    router.HandleFunc("/logs", postAppLogs(db)).Methods("POST")

    err := http.ListenAndServe(":8000", jsonContentTypeMiddleware(router))

    if errors.Is(err, http.ErrServerClosed) {
        fmt.Println("Server is closed.")
    } else if err != nil {
        fmt.Println("Error starting Server.")
    }
}

func jsonContentTypeMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func (w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        next.ServeHTTP(w, r)
    })
}

func getRoot(w http.ResponseWriter, r *http.Request) {
    fmt.Println("Received / request.")
    io.WriteString(w, "This server is an attempt to make and App Log producer and consumer.\n")
}

func getAllAppLogs(db *sql.DB) http.HandlerFunc {
    fmt.Println("Received /logs GET request.")
    return func (w http.ResponseWriter, r *http.Request) {
        rows, err := db.Query("SELECT * FROM logs")
        if err != nil {
            log.Fatal(err)
        }
        defer rows.Close()

        logs := []AppLog{}
        for rows.Next() {
            var alg AppLog
            if err := rows.Scan(&alg.AppId, &alg.LogTitle, &alg.AppTitle, &alg.LogContent, &alg.LogDateTime); err != nil {
                log.Fatal(err)
            }
        }

        if err := rows.Err(); err != nil {
            log.Fatal(err)
        }

        json.NewEncoder(w).Encode(logs)
    }
}

func postAppLogs(db *sql.DB) http.HandlerFunc {
    return func (w http.ResponseWriter, r *http.Request) {
        fmt.Println("Received /logs POST request. Body:", r.Body)
        var alg AppLog
        currentTime := time.Now()
        json.NewDecoder(r.Body).Decode(&alg)
        err := db.QueryRow(
            "INSERT INTO logs (appId, logTitle, appTitle, logContent, logDateTime) VALUES ($1, $2, $3, $4, $5) RETURNING id",
            alg.AppId,
            alg.LogTitle,
            alg.AppTitle,
            alg.LogContent,
            currentTime,
        ).Scan()

        if err != nil {
            log.Fatal(err)
        }
        json.NewEncoder(w).Encode(alg)
    }
}