package main

import (
    "fmt"
    "math/rand"
    "time"
    
    "github.com/influxdata/influxdb-client-go/v2"
)

func main() {
    client := influxdb2.NewClientWithOptions("http://localhost:8086", "${my-token}",
        influxdb2.DefaultOptions().SetBatchSize(20))
    ctx := context.Background()

    bucketsAPI := client.BucketsAPI()
    org, err := client.OrganizationAPI().FindOrganizationByName(ctx, "mobigen")
    if err != nil {
        fmt.Printf("ERROR. Cannot find organization")
    }

    bucket, err := bucketsAPI.CreateBucketWithName(ctx, org, "rand-buck", domain.RetentionRule{EverySeconds: 3600 * 12})
    if err != nil {
        fmt.Printf("Error. Cannot create bucket")
    }

    // Get non-blocking write client
    writeAPI := client.WriteAPI(org.Name, bucket.Name)
    // Read and log errors
    errorsCh := writeAPI.Errors()
    go func(){
        for err := range errorsCh {
            fmt.Printf("write error: %s\n", err.Error())
        }
    }()

    // write some points
    for i := 0; i <100; i++ {
        // create point
        p := influxdb2.NewPoint(
            "rand-buck", 
            map[string]string{
                "contID":   fmt.Sprintf("contID_%v", i),
                "contName": fmt.Sprintf("contName_%v", i),
                "vendor":   "mobigen",
            },
            map[string]interface{}{
                "utime": rand.Float64(),
                "stime": rand.Float64(),
                "cutime": rand.Float64(),
                "cstime": rand.Float64(),
                "rxByte": rand.Float64(),
                "rxPacket": rand.Float64(),
                "txByte": rand.Float64(),
                "txPacket": rand.Float64(),
                "vmsize": rand.Float64(),
                "vmrss": rand.Float64(),
                "rssfile": rand.Float64(),
            },
            time.Now())
        // write asynchronously
        writeAPI.WritePoint(p)
    }
    // Force all unwritten data to be sent
    writeAPI.Flush()
    // Ensures background processes finishes
    client.Close()
}

func NewPoint(
	measurement string,
	tags map[string]string,
	fields map[string]interface{},
	ts time.Time,
)

// Read and log errors
errorsCh := writeAPI.Errors()
go func(){
    for err := range errorsCh {
        fmt.Printf("write error: %s\n", err.Error())
    }
}()

package main

import (
    "context"
    "fmt"
    "math/rand"
    "time"

    "github.com/influxdata/influxdb-client-go/v2"
)

func main() {
    // Create a new client using an InfluxDB server base URL and an authentication token
    client := influxdb2.NewClient("http://localhost:8086", "my-token")
    // Get blocking write client
    writeAPI := client.WriteAPIBlocking("my-org","my-bucket")
    // write some points
    for i := 0; i <100; i++ {
        // create data point
        p := influxdb2.NewPoint(
            "system",
            map[string]string{
                "id":       fmt.Sprintf("rack_%v", i%10),
                "vendor":   "AWS",
                "hostname": fmt.Sprintf("host_%v", i%100),
            },
            map[string]interface{}{
                "temperature": rand.Float64() * 80.0,
                "disk_free":   rand.Float64() * 1000.0,
                "disk_total":  (i/10 + 1) * 1000000,
                "mem_total":   (i/100 + 1) * 10000000,
                "mem_free":    rand.Uint64(),
            },
            time.Now())
        // write synchronously
        err := writeAPI.WritePoint(context.Background(), p)
        if err != nil {
            panic(err)
        }
    }
    // Ensures background processes finishes
    client.Close()
}

package main

import (
    "context"
    "fmt"

    "github.com/influxdata/influxdb-client-go/v2"
)

func main() {
    org := "mobigen"
    token := "${token}"
    url := "http://localhost:8086"

    // Create a new client using an InfluxDB server base URL and an authentication token
    client := influxdb2.NewClient(url, token)
    // Get query client
    queryAPI := client.QueryAPI(org)
    // get QueryTableResult
    result, err := queryAPI.Query(context.Background(), `from(bucket:"rand-buck")
	|> range(start:-8h)
	|> filter(fn:(r) =>
		r._measurement == "rand-buck" and
		r._field == "utime" or r._field == "stime")
    |> pivot(rowKey:["_time"], columnKey:["_field"], valueColumn: "_value")
    |> map(fn: (r) => ({ r with _value: r.utime + r.stime}))
	|> yield(name: "_results")`)

    if err == nil {
        // Iterate over query response
        for result.Next() {
            // Access data
            fmt.Printf("Time: %v\n", result.Record().Time())
            fmt.Printf("ContainerName: %v   |   ", result.Record().ValueByKey("contName"))
            fmt.Printf("utime + stime: %v\n", result.Record().Value())
        }
        // check for an error
        if result.Err() != nil {
            fmt.Printf("query parsing error: %s\n", result.Err().Error())
        }
    } else {
        fmt.Printf("ERROR. Cannot serve qeury result\n")
    }
    // Ensures background processes finishes
    client.Close()
}

result.Record().${아래 요소}