Supported in Go
This page lists the Go libraries, frameworks and build tools Niro was tested against, and whether it recognised each one.
What the marks mean.
- Supported: Niro recognised every way of using it that the test code tries.
- Partly: Niro recognised some of those ways, or recognised one only in part.
- Not yet: Niro did not recognise it in the test code.
The test code is made up for the purpose: one small service per library, with the names invented. So "supported" means Niro recognised it there. It is good evidence, but it is not a promise about every codebase. If Niro misses something in your code, the coverage audit reports the gap on its own (see Coverage audit).
The test catalog also holds 9 look-alike cases for Go: code that Niro must NOT take for a route, a call or a store. They test that Niro ignores the look-alike, so they are left out of this page and its counts.
Web frameworks and HTTP servers (the routes your code serves)
19 supported, 0 partly, 9 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| AWS SAM template.yaml | supported | yes: AWS::Serverless::Function (Runtime provided.al2023, Handler bootstrap, Metadata BuildMethod go1.x) with Events Type HttpApi Path and Method; the handler is the package main under CodeUri |
| encore.dev | not yet | no: //encore:api comment directive above a function |
| github.com/beego/beego/v2 | supported | yes: web.Router with a controller and 'verb:Method' mapping yes: web.Get functional route with a literal yes: NewNamespace with NSRouter |
| github.com/cloudwego/hertz | supported | yes: verbs on server.Default() held in hyes: Group then verb |
| github.com/danielgtaylor/huma/v2 | supported | yes: huma.Get(api, path, handler) package helper yes: huma.Register with an Operation literal naming Method and Path |
| github.com/dapr/go-sdk | not yet | no: service AddServiceInvocationHandler(path, h) |
| github.com/fasthttp/router | supported | yes: fasthttp/router verbs and Group |
| github.com/gin-gonic/gin | supported | yes: engine verb methods with a method-value handler yes: inline function literal handler yes: Handle with the verb as a string yes: Any registers every verb yes: route group with a block yes: *gin.RouterGroup passed to a register function in another file |
| github.com/go-chi/chi/v5 | supported | yes: chi verb methods yes: Route with a function literal, nested twice yes: Method with a verb constant and an http.Handler yes: inline middleware chain before the verb yes: Mount a sub-router returned by a function |
| github.com/go-kit/kit (transport/http) | not yet | no: go-kit httptransport.NewServer mounted on a gorilla route |
| github.com/go-kratos/kratos (HTTP transport) | not yet | no: kratos generated *_http.pb.go registering routes |
| github.com/go-martini/martini | supported | yes: verbs on martini.Classic() held in myes: Group with a function literal |
| github.com/gobuffalo/buffalo | not yet | no: buffalo app verbs |
| github.com/gofiber/fiber/v2 | supported | yes: Fiber verb methods yes: Add with a verb constant yes: Group yes: Route with a function literal |
| github.com/gofiber/fiber/v3 | not yet | no: fiber v3 verbs (handler takes fiber.Ctx interface) |
| github.com/gorilla/mux | supported | yes: HandleFunc(...).Methods(verb) yes: Handle(path, http.HandlerFunc(m)).Methods(verb) yes: chain starting with Methods, then Path, then HandlerFunc yes: PathPrefix(...).Subrouter() |
| github.com/julienschmidt/httprouter | supported | yes: httprouter verb methods yes: Handle with a verb constant yes: HandlerFunc with a plain http.HandlerFunc |
| github.com/kataras/iris/v12 | supported | yes: iris verbs and Party yes: Handle with a verb string |
| github.com/labstack/echo/v4 | supported | yes: Echo verb methods yes: Add with a verb constant yes: Match with a verb list yes: Group with a prefix |
| github.com/oapi-codegen/oapi-codegen (generated server) | not yet | no: generated RegisterHandlers: router.GET(baseURL+path, wrapper.X) inside checked-in generated code |
| github.com/revel/revel | not yet | no: conf/routes file |
| github.com/uptrace/bunrouter | supported | yes: bunrouter verbs yes: WithGroup with a function literal |
| github.com/zeromicro/go-zero | supported | yes: AddRoutes with a []rest.Route literal and rest.WithPrefix yes: AddRoute with one rest.Route literal |
| goa.design/goa/v3 | not yet | no: goa design DSL plus generated server |
| gofr.dev | supported | yes: gofr app verbs |
| Netlify Functions (Go, Lambda compatibility) | supported | yes: netlify/functions/<name>/main.go (or <name>.go) with lambda.Start: served at /.netlify/functions/<name>, every verb; a -background suffix makes a background function yes: netlify.toml [[redirects]] from a path to /.netlify/functions/<name> with status 200 gives the function that path too yes: netlify.toml [functions] directory = "<folder>" moves where function folders are read from |
| Serverless Framework serverless.yml | supported | yes: functions.<name> with handler bootstrap and package.artifact, events httpApi; runtime provided.al2023 |
| Vercel Functions (Go runtime, /api directory) | supported | yes: api/<name>.go with an exported func(http.ResponseWriter, *http.Request): the file path is the route, every verb yes: api/cards/[id].go: a bracketed file name is a dynamic path segment |
The language's own HTTP server
0 supported, 2 partly, 0 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| net/http | partly | yes: http.HandleFunc on the default mux, inline func literal handler yes: http.Handle with a type implementing http.Handler (ServeHTTP) yes: ServeMux.HandleFunc with Go 1.22 pattern 'METHOD /path/{wildcard}' yes: ServeMux.Handle with a method pattern and an http.Handler value yes: http.HandlerFunc(fn) adapter passed to Handle yes: Go 1.22 trailing wildcard {name...} yes: Go 1.22 exact-match marker {$} yes: Go 1.22 host-qualified pattern partly: pre-1.22 single path, verb chosen by switch r.Method in the handler yes: second ServeMux mounted under a prefix with http.StripPrefix |
| net/rpc | partly | yes: rpc.Register + rpc.HandleHTTP: every exported method T.M(args, *reply) error is a procedure yes: rpc.RegisterName with a custom service name no: rpc.NewServer + jsonrpc.NewServerCodec over raw TCP |
HTTP client libraries (the calls your code makes to other services)
2 supported, 5 partly, 8 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| github.com/carlmjohnson/requests | supported | yes: requests.URL(base).Pathf().ToJSON().Fetch(ctx) yes: BodyJSON().Post().Fetch |
| github.com/cloudwego/hertz (client) | partly | yes: hertz client.Get(ctx, dst, url) no: protocol.Request SetMethod/SetRequestURI then client Do |
| github.com/dapr/go-sdk | not yet | no: client.InvokeMethod(ctx, appID, method, verb): service invocation by app name |
| github.com/dghubble/sling | not yet | no: sling.New().Base(url); New().Get(path).ReceiveSuccess no: Post(path).BodyJSON().ReceiveSuccess |
| github.com/go-kit/kit (transport/http client) | not yet | no: httptransport.NewClient(verb, url, enc, dec) |
| github.com/go-resty/resty/v2 | partly | yes: client with SetBaseURL; R().SetPathParam().Get(path) yes: R().SetBody().Post yes: R().SetContext().SetBody().Put no: R().Execute(verb, url) yes: fresh client, full literal URL |
| github.com/gojek/heimdall/v7 | not yet | no: httpclient.NewClient().Get(url, headers) no: Post(url, body, headers) |
| github.com/hashicorp/go-cleanhttp | not yet | no: cleanhttp.DefaultPooledClient() returns *http.Client; then Get |
| github.com/hashicorp/go-retryablehttp | partly | yes: package-level retryablehttp.Get yes: NewClient then Post no: retryablehttp.NewRequest then Do no: StandardClient() gives a plain *http.Client |
| github.com/imroc/req/v3 | partly | no: req.C().SetBaseURL(); R().SetPathParam().Get no: R().SetBody().Post yes: package-level req.Get with a full URL no: fluent client.Delete(url).Do() |
| github.com/parnurzeal/gorequest | supported | yes: gorequest.New().Get(url).End() yes: Post(url).Send(json).End() |
| github.com/valyala/fasthttp (client) | partly | yes: fasthttp.Get(dst, url) no: AcquireRequest, SetRequestURI, SetMethod, Client.Do |
| github.com/zeromicro/go-zero/rest/httpc | not yet | no: httpc.Do(ctx, verb, url-with-:id, reqStruct) |
| gopkg.in/h2non/gentleman.v2 | not yet | no: URL, Request, Method, Path, Send |
| oapi-codegen generated client | not yet | no: generated NewClientWithResponses(server) + GetSupplierWithResponse; generated code calls http.NewRequest |
The language's own HTTP client
0 supported, 2 partly, 0 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| net/http | partly | yes: http.Get with a literal URL yes: http.Get with literal base plus string concatenation no: http.Get with fmt.Sprintf building the URL yes: http.Post with a base held in a package constant partly: http.PostForm yes: http.Head no: http.NewRequest with a verb constant, then a configured http.Client's Do no: http.NewRequestWithContext with a verb literal, then http.DefaultClient.Do, base from os.Getenv no: url.JoinPath builds the URL, http.Client value's Get yes: *http.Client held on a struct field, base on another field set from config no: net/http/httputil reverse proxy to a fixed target yes: plain http.Get to a grpc-gateway REST mapping |
| net/rpc | partly | no: rpc.DialHTTP then client.Call("Type.Method", args, &reply) partly: asynchronous client.Go yes: jsonrpc.Dial then Call |
gRPC
2 supported, 3 partly, 4 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| connectrpc.com/connect (client) | supported | yes: connect-go: {pkg}connect.New{S}Client(http.DefaultClient, baseURL) then client.M(ctx, connect.NewRequest(...)) (plan 8.4) yes: the same client with connect.WithGRPC() |
| connectrpc.com/connect (server) | supported | yes: connect-go: path, h := {pkg}connect.New{S}Handler(&impl{}); mux.Handle(path, h) (plan 8.4) |
| github.com/go-kratos/kratos (gRPC transport) | not yet | no: kratos gRPC transport: pb.Register{S}Server(grpcSrv, svc) via kratos grpc.NewServer |
| github.com/grpc-ecosystem/grpc-gateway/v2 | partly | yes: grpc-gateway REST mapping from option (google.api.http) in the .proto, incl. additional_bindings (plan 8.4) yes: pb.Register{S}HandlerFromEndpoint(ctx, mux, addr, opts) no: pb.Register{S}HandlerServer(ctx, mux, impl) in-process |
| github.com/twitchtv/twirp | not yet | no: twirp New{S}Server(impl) mounted at server.PathPrefix(); path /twirp/{pkg}.{S}/{M} no: twirp New{S}ProtobufClient(baseURL, httpClient) then client.M |
| go-micro.dev/v4 | not yet | no: go-micro service handler registration |
| google.golang.org/grpc (client) | partly | yes: conn from grpc.NewClient(literal target), then pb.New{S}Client(conn) stored on a struct field typed pb.{S}Client yes: server-streaming client call returning a stream yes: deprecated grpc.Dial(os.Getenv(...)) and a local client variable no: grpc.DialContext with a dns:/// target (plan 8.6) yes: conn.Invoke with the full wire path literal (plan 8.3 literal_path) no: dynamic client through grpcreflect (plan 8.3: not covered) |
| google.golang.org/grpc (server) | partly | yes: server struct embedding pb.Unimplemented{S}Server, unary method (plan row grpc-go-unimplemented) no: pb.Register{S}Server(s, impl) registration (plan section 3, go) yes: server-streaming method M(req, stream pb.S_MServer) error (plan 8.2) yes: client-streaming method M(stream pb.S_MServer) error (plan 8.2) yes: bidirectional streaming method (plan 8.2) yes: hand-written grpc.ServiceDesc literal + RegisterService (plan 8.3, keyed-literal reader) no: grpc_health_v1.RegisterHealthServer(s, health.NewServer()) yes: reflection.Register(s) must NOT become a route (plan 8.3) yes: checked-in generated orders_grpc.pb.go: the Unimplemented base's methods and the generated client's c.cc.Invoke must NOT become routes or calls (plan trap T5) |
| storj.io/drpc | not yet | no: storj drpc generated DRPC{S} interfaces |
Databases and data stores
13 supported, 10 partly, 25 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| cloud.google.com/go/bigquery | not yet | no: client.Query(sql).Read no: Dataset().Table().Inserter().Put |
| cloud.google.com/go/firestore | supported | yes: Collection().Doc().Get/Set yes: Collection().Where().Documents().GetAll |
| cloud.google.com/go/spanner | partly | partly: Single().Query(ctx, spanner.Statement{SQL: ...}) yes: spanner.Insert(table, cols, vals) passed to Apply |
| database/sql | partly | yes: sql.Open + QueryContext with the query in a constant yes: ExecContext with an inline INSERT yes: transaction: BeginTx, PrepareContext(DELETE), QueryRowContext(SELECT count) partly: main reads or writes a table or collection that a service also owns (the cross-service data link) |
| entgo.io/ent | not yet | no: client.Review.Query().Where().All / Create().Save |
| github.com/aerospike/aerospike-client-go/v7 | not yet | no: github.com/aerospike/aerospike-client-go/v7 basic read/write |
| github.com/aws/aws-sdk-go (v1 dynamodb, s3) | not yet | no: github.com/aws/aws-sdk-go (v1 dynamodb, s3) basic read/write |
| github.com/aws/aws-sdk-go-v2/service/dynamodb | supported | yes: PutItem with TableName: aws.String(literal) yes: GetItem with TableName from a constant yes: Query |
| github.com/aws/aws-sdk-go-v2/service/s3 | partly | yes: PutObject with Bucket literal no: GetObject with Bucket from os.Getenv yes: manager.NewUploader(client).Upload |
| github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos | not yet | no: github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos basic read/write |
| github.com/Azure/azure-sdk-for-go/sdk/storage/azblob | not yet | no: github.com/Azure/azure-sdk-for-go/sdk/storage/azblob basic read/write |
| github.com/bradfitz/gomemcache | partly | partly: mc.Set(&memcache.Item{Key: k}) and mc.Get(k) |
| github.com/ClickHouse/clickhouse-go/v2 | supported | yes: conn.Query(ctx, sql) yes: PrepareBatch(ctx, "INSERT INTO t") |
| github.com/dgraph-io/badger | not yet | no: github.com/dgraph-io/badger basic read/write |
| github.com/doug-martin/goqu/v9 | supported | yes: goqu From(table).Where().ScanVals yes: Insert(table).Rows().Executor().Exec() |
| github.com/elastic/go-elasticsearch/v8 | partly | partly: es.Index(index, body) yes: es.Search(es.Search.WithIndex(name)) no: typed client Search().Index(name).Do |
| github.com/go-pg/pg/v10 | not yet | no: db.Model(&v).Where().Select() and Insert with pg:"table" tag |
| github.com/go-sql-driver/mysql | supported | yes: sql.Open("mysql", dsn) then Query |
| github.com/gocql/gocql | supported | yes: session.Query(cql).Exec() / .Iter() |
| github.com/gocraft/dbr/v2 | not yet | no: github.com/gocraft/dbr/v2 basic read/write |
| github.com/gomodule/redigo | not yet | no: conn.Do("COMMAND", key, ...) |
| github.com/hashicorp/consul/api (KV) | not yet | no: github.com/hashicorp/consul/api (KV) basic read/write |
| github.com/influxdata/influxdb-client-go/v2 | not yet | no: github.com/influxdata/influxdb-client-go/v2 basic read/write |
| github.com/jackc/pgx/v5 | partly | yes: pgx.Connect then conn.QueryRow yes: pgxpool.New then pool.Exec yes: pool.Query no: pgx.Batch Queue yes: CopyFrom with pgx.Identifier{table} |
| github.com/jmoiron/sqlx | partly | yes: db.Select(&dest, query) no: db.Get with db.Rebind(query) yes: NamedExec INSERT yes: Queryx yes: MustExec |
| github.com/lib/pq | supported | yes: Exec with pq.Array argument yes: COPY with pq.CopyIn(table, cols...) |
| github.com/Masterminds/squirrel | partly | yes: Select().From(table).RunWith(db).Query() no: Insert(table).ToSql() then db.Exec |
| github.com/mattn/go-sqlite3 and modernc.org/sqlite | supported | yes: sql.Open("sqlite3", file) then Exec yes: sql.Open("sqlite", file) then QueryRow |
| github.com/meilisearch/meilisearch-go | not yet | no: github.com/meilisearch/meilisearch-go basic read/write |
| github.com/milvus-io/milvus-sdk-go/v2 | not yet | no: github.com/milvus-io/milvus-sdk-go/v2 basic read/write |
| github.com/minio/minio-go/v7 | supported | yes: minio PutObject/GetObject(ctx, bucket, object, ...) |
| github.com/neo4j/neo4j-go-driver/v5 | supported | yes: neo4j.ExecuteQuery(ctx, driver, cypher) and session.Run(ctx, cypher) |
| github.com/olivere/elastic/v7 | not yet | no: github.com/olivere/elastic/v7 basic read/write |
| github.com/opensearch-project/opensearch-go | not yet | no: github.com/opensearch-project/opensearch-go basic read/write |
| github.com/qdrant/go-client | not yet | no: github.com/qdrant/go-client basic read/write |
| github.com/redis/go-redis/v9 | supported | yes: Set/Get/HSet/LPush with literal or built keys yes: Pipeline commands then Exec yes: NewClusterClient then Del |
| github.com/redis/rueidis | not yet | no: client.Do(ctx, client.B().Set().Key(k).Value(v).Build()) |
| github.com/upper/db/v4 | not yet | no: github.com/upper/db/v4 basic read/write |
| github.com/uptrace/bun | partly | yes: NewSelect().Model(&slice) with bun:"table:..." tag partly: NewInsert().Model(&v).Exec yes: NewSelect().Table(name) yes: NewRaw SQL |
| github.com/volatiletech/sqlboiler/v4 | not yet | no: github.com/volatiletech/sqlboiler/v4 basic read/write |
| go.etcd.io/bbolt | not yet | no: tx.Bucket([]byte(name)).Put/Get inside Update/View closures |
| go.etcd.io/etcd/client/v3 | not yet | no: clientv3 Put/Get with key or prefix |
| go.mongodb.org/mongo-driver | supported | yes: Database().Collection() then FindOne/InsertOne/UpdateOne yes: one-line chain Database().Collection().Aggregate |
| go.mongodb.org/mongo-driver/v2 | supported | yes: mongo-driver v2 (Connect without ctx), Find/DeleteMany |
| gocloud.dev/blob | not yet | no: gocloud.dev/blob basic read/write |
| gorm.io/gorm | partly | yes: model-based queries: First, Where().Order().Find yes: Create(&model) yes: Model(&Order{}).Where().Update yes: Delete(&Order{}, id) yes: Table(name) names the table yes: Raw SQL through GORM yes: Exec SQL through GORM no: model with TableName() override |
| sqlc (generated code) | not yet | no: sqlc generated Queries: SQL in const strings, called through q.db.QueryRow/Exec |
| xorm.io/xorm | not yet | no: engine.Where().Get(&model) with TableName() no: engine.Table(name).Where().Count() |
Messaging and events (queues, topics, streams)
5 supported, 14 partly, 15 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| channels (in-process bus) | not yet | no: in-process event bus on channels shared between packages (Publish/Subscribe by topic string) |
| cloud.google.com/go/pubsub | partly | no: client.Topic(name).Publish(ctx, msg), inline or through a variable partly: client.Subscription(name).Receive(ctx, cb) |
| cloud.google.com/go/pubsub/v2 (Publisher/Subscriber API) | not yet | no: cloud.google.com/go/pubsub/v2 (Publisher/Subscriber API) basic use |
| github.com/apache/pulsar-client-go | supported | yes: CreateProducer(pulsar.ProducerOptions{Topic}) then Send yes: client.Subscribe(pulsar.ConsumerOptions{Topic, SubscriptionName}) then Receive |
| github.com/aws/aws-sdk-go v1 (sqs, sns) | not yet | no: github.com/aws/aws-sdk-go v1 (sqs, sns) basic use |
| github.com/aws/aws-sdk-go-v2 (sqs, sns, eventbridge, kinesis) | partly | yes: SQS SendMessage with QueueUrl literal no: SQS ReceiveMessage with QueueUrl from os.Getenv yes: SNS Publish with TopicArn literal no: EventBridge PutEvents with EventBusName and DetailType yes: Kinesis PutRecord with StreamName |
| github.com/Azure/azure-sdk-for-go/sdk/messaging/azservicebus | partly | yes: client.NewSender(queue).SendMessage no: NewReceiverForQueue(queue).ReceiveMessages |
| github.com/centrifugal/centrifuge | not yet | no: github.com/centrifugal/centrifuge basic use |
| github.com/cloudevents/sdk-go/v2 | not yet | no: cloudevents.NewClientHTTP(WithPort) + StartReceiver(ctx, fn) no: c.Send(cloudevents.ContextWithTarget(ctx, url), event) |
| github.com/confluentinc/confluent-kafka-go/v2 | supported | yes: Produce(&kafka.Message{TopicPartition: kafka.TopicPartition{Topic: &topic}}) yes: SubscribeTopics([]string{...}, nil) yes: Subscribe(topic, nil) |
| github.com/dapr/go-sdk | partly | yes: Dapr client.PublishEvent(ctx, pubsub, topic, data) partly: service AddTopicEventHandler(&common.Subscription{PubsubName, Topic, Route}, h) |
| github.com/eclipse/paho.mqtt.golang | partly | partly: client.Publish(topic, qos, retained, payload) no: client.Subscribe(filter-with-+, qos, cb) |
| github.com/go-co-op/gocron (scheduler) | not yet | no: github.com/go-co-op/gocron (scheduler) basic use |
| github.com/go-redis/redis/v8 | not yet | no: github.com/go-redis/redis/v8 basic use |
| github.com/gocraft/work | not yet | no: github.com/gocraft/work basic use |
| github.com/hibiken/asynq | partly | yes: client.Enqueue(asynq.NewTask(type, payload)) yes: mux.HandleFunc(type, fn) no: mux.Handle(constType, handlerType) |
| github.com/IBM/sarama | partly | yes: SyncProducer.SendMessage(&sarama.ProducerMessage{Topic: ...}) yes: ProducerMessage built in a variable, then SendMessage(msg) no: AsyncProducer.Input() <- msg no: ConsumerGroup.Consume(ctx, []string{topic}, handler) with a ConsumerGroupHandler yes: Consumer.ConsumePartition(topic, partition, offset) |
| github.com/lib/pq (LISTEN/NOTIFY) | supported | yes: pq.NewListener + Listen(channel): Postgres LISTEN/NOTIFY as an event bus |
| github.com/nats-io/nats.go | partly | yes: nc.Publish(subject, data) partly: nc.Subscribe(subject, callback) no: nc.QueueSubscribe(subject, queue, cb) no: nc.Request(subject, data, timeout) and a responder that calls m.Respond yes: nc.JetStream() then js.Publish / js.Subscribe partly: jetstream.New(nc); stream.CreateOrUpdateConsumer(ConsumerConfig{FilterSubject}); cons.Consume(cb); js.Publish(ctx, subj, data) |
| github.com/nsqio/go-nsq | partly | yes: producer.Publish(topic, body) no: nsq.NewConsumer(topic, channel, cfg) + AddHandler(HandleMessage) |
| github.com/rabbitmq/amqp091-go | partly | yes: PublishWithContext(ctx, exchange, routingKey, ...) yes: Consume(queue, ...) no: QueueBind(queue, routingKey, exchange): joins a routing key to a queue |
| github.com/redis/go-redis/v9 (pub/sub, streams) | partly | yes: rdb.Publish(ctx, channel, msg) yes: rdb.Subscribe(ctx, channel) then sub.Channel() yes: XAdd(ctx, &redis.XAddArgs{Stream: ...}) no: XReadGroup(ctx, &redis.XReadGroupArgs{Streams: []string{name, ">"}}) |
| github.com/RichardKnop/machinery/v2 | not yet | no: server.SendTask(&tasks.Signature{Name}) and RegisterTask(name, fn) |
| github.com/riverqueue/river | partly | partly: client.Insert(ctx, args, nil) where args has Kind() string no: river.AddWorker(workers, &Worker{}) with Work(ctx, *river.Job[Args]) |
| github.com/robfig/cron/v3 (scheduler) | not yet | no: github.com/robfig/cron/v3 (scheduler) basic use |
| github.com/segmentio/kafka-go | partly | yes: kafka.NewReader(kafka.ReaderConfig{Topic}) then ReadMessage/FetchMessage partly: kafka.Writer{Topic: ...} then WriteMessages yes: Writer with no topic; Topic on each kafka.Message |
| github.com/Shopify/sarama (old import path) | not yet | no: github.com/Shopify/sarama (old import path) basic use |
| github.com/streadway/amqp | supported | yes: legacy streadway/amqp Consume and Publish (same API as amqp091) |
| github.com/ThreeDotsLabs/watermill | partly | partly: publisher.Publish(topic, msg) partly: router.AddHandler(name, subTopic, sub, pubTopic, pub, fn) no: router.AddNoPublisherHandler(name, topic, sub, fn) |
| github.com/twmb/franz-go | supported | yes: kgo.NewClient(kgo.ConsumeTopics(...)) then PollFetches yes: Produce/ProduceSync(ctx, &kgo.Record{Topic: ...}) |
| go-micro.dev broker | not yet | no: go-micro.dev broker basic use |
| go.etcd.io/etcd/client/v3 (Watch) | not yet | no: clientv3 Watch on a prefix (change notifications) |
| go.temporal.io/sdk (workflows and activities) | not yet | no: go.temporal.io/sdk (workflows and activities) basic use |
| slack-go, twilio-go, sendgrid-go (SaaS API calls) | not yet | no: slack-go, twilio-go, sendgrid-go (SaaS API calls) basic use |
Build tools and package managers
8 supported, 0 partly, 0 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| bazel (rules_go + gazelle) | supported | yes: MODULE.bazel + BUILD.bazel with go_binary / go_library / go_test, one root go.mod |
| bazel (WORKSPACE, legacy) | supported | yes: WORKSPACE + BUILD files and no go.mod at all |
| dep / glide (pre-modules) | supported | yes: Gopkg.toml (dep) and glide.yaml, no go.mod, GOPATH import paths |
| go modules | supported | yes: one go.mod at the root, package main plus one sub-package yes: several go.mod in one repo, joined by one-line replace X => ../pathyes: replace written as a block: replace ( X => ../path )yes: vendored dependencies in vendor/ with vendor/modules.txt |
| go workspaces | supported | yes: go.work with a use ( ... ) block, no replace directivesyes: go.work with one use per line and a workspace-level replace |
| goreleaser | supported | yes: .goreleaser.yaml declaring two builds (main: ./cmd/x) from one module |
| mage | supported | yes: magefile.go (//go:build mage, package main) at the root of a library module |
| make / Task | supported | yes: Makefile and Taskfile.yml that build two binaries from one module |
Project and folder layouts
6 supported, 0 partly, 0 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| go build | supported | yes: bin/ and dist/ build output, and a coverage profile |
| go build (cgo) | supported | yes: Go package with import "C" and .c/.h files beside it |
| go build (tags) | supported | yes: platform files: _windows.go, _linux.go, and //go:build js && wasm |
| go modules | supported | yes: golang-standards layout: cmd/, internal/, pkg/, api/, configs/, scripts/, test/ yes: one go.mod with two programs under cmd/api and cmd/worker sharing internal/ yes: a module nested inside another module's folder (examples/ and tools/ with their own go.mod) yes: tools.go with //go:build tools importing code generatorsyes: major version in a subdirectory: v2/ with its own go.mod (module .../v2) yes: a library with examples/<name>/main.go programs inside the same module |
| go test | supported | yes: _test.go beside code, external test package (package x_test), testdata/ holding .go fixtures |
| protoc / go generate | supported | yes: generated *.pb.go and // Code generated ... DO NOT EDIT. files inside the module, plus a //go:generate line |
Deployment files
17 supported, 0 partly, 0 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| aws sam | supported | yes: template.yaml with AWS::Serverless::Function CodeUri per service |
| docker buildx bake | supported | yes: docker-bake.hcl targets with context |
| docker compose | supported | yes: docker-compose.yml, build: ./services/x string form, plus image-only infrayes: build: {context: ., dockerfile: services/x/Dockerfile}: context is the repo rootyes: deploy/docker-compose.yml with ../services/x contextsyes: compose.yaml plus compose.override.yaml, profiles, extends, and an image: + build: service |
| dockerfile | supported | yes: a Dockerfile in each service folder and nothing else yes: docker/<svc>/Dockerfile kept apart from the code |
| fly.io | supported | yes: fly.toml per service with app = "name" |
| github actions | supported | yes: dorny/paths-filter with one named filter per service yes: a build matrix over services with working-directory: services/${{ matrix.service }} |
| gitlab ci | supported | yes: .gitlab-ci.yml jobs with rules:changes per service |
| google app engine | supported | yes: app.yaml per service (runtime go122, service: name) plus dispatch.yaml |
| helm | supported | yes: charts/<svc>/Chart.yaml type application, one library chart, one umbrella chart with dependencies |
| heroku procfile | supported | yes: Procfile inside each service folder (web and worker process types) |
| kubernetes | supported | yes: multi-document manifest: Deployment shop-orders-api (name differs from folder), Service, CronJob billing |
| kubernetes (kustomize) | supported | yes: kustomize base + overlays; workloads in base, overlays patch them |
| kubernetes + ko | supported | yes: image: ko://example.com/shop/orders naming the Go import path to build |
| render | supported | yes: one render.yaml at the root listing services with rootDir |
| serverless framework | supported | yes: serverless.yml per service, provider.runtime provided.al2, functions with handler bootstrap |
| skaffold | supported | yes: skaffold.yaml build.artifacts with context per service |
| vercel | supported | yes: vercel.json with Go serverless functions in api/*.go |