eventstore / eventstore-client-go

Go Client for Event Store version 20 and above.

EventStoreDB is the event-native database, where business events are immutably stored and streamed. Designed for event-sourced, event-driven, and microservices architectures

• What is EventStoreDB
• What is EventStore Cloud
• Licensing
• Documentation
• Getting started with EventStoreDB
• Getting started with EventStore Cloud
• Client libraries
• Deployment
• Communities
• Contributing
• Building EventStoreDB
• Need help?

What is EventStoreDB

EventStoreDB is a new category of operational database that has evolved from the Event Sourcing community. Powered by the state-transition data model, events are stored with the context of why they have happened. Providing flexible, real-time data insights in the language your business understands.

Download the latest version. For more product information visit the website.

What is Event Store Cloud?

Event Store Cloud is a fully managed cloud offering that's designed to make it easy for developers to build and run highly available and secure applications that incorporate EventStoreDB without having to worry about managing the underlying infrastructure. You can provision EventStoreDB clusters in AWS, Azure, and GCP, and connect these services securely to your own cloud resources.

For more details visit the website.

Licensing

View Event Store Ltd's licensing information.

Docs

For guidance on installation, development, deployment, and administration, see the User Documentation.

Getting started with EventStoreDB

Follow the getting started guide.

Getting started with Event Store Cloud

Event Store can manage EventStoreDB for you, so you don't have to run your own clusters. See the online documentation: Getting started with Event Store Cloud.

Client libraries

This guide shows you how to get started with EventStoreDB by setting up an instance or cluster and configuring it. EventStoreDB supports two protocols: gRPC and TCP(legacy).

EventStoreDB supported gRPC clients

• Python: pyeventsourcing/esdbclient
• Node.js (javascript/typescript): EventStore/EventStore-Client-NodeJS
• Java: (EventStore/EventStoreDB-Client-Java
• .NET: EventStore/EventStore-Client-Dotnet
• Go: EventStore/EventStore-Client-Go
• Rust: EventStore/EventStoreDB-Client-Rust
• Read more in the gRPC clients documentation

Community supported gRPC clients

• Elixir: NFIBrokerage/spear
• Ruby: yousty/event_store_client

Read more in the documentation.

Legacy TCP Clients (support ends with 23.10 LTS)

• .Net: EventStoreDB-Client-Dotnet-Legacy

Deployment

• Event Store Cloud - steps to get started in Cloud.
• Self-managed - steps to host EventStoreDB yourself.

Communities

• Discuss
• Discord (Event Store)
• Discord (ddd-cqrs-es)

Contributing

Development is done on the master branch. We attempt to do our best to ensure that the history remains clean and to do so, we generally ask contributors to squash their commits into a set or single logical commit.

If you want to switch to a particular release, you can check out the release branch for that particular release. For example:
git checkout release/oss-v22.10

• Create an issue
• Documentation
• Contributing guide

Building EventStoreDB

EventStoreDB is written in a mixture of C# and JavaScript. It can run on Windows, Linux and macOS (using Docker) using the .NET Core runtime.

Prerequisites

• .NET Core SDK 8.0

Once you've installed the prerequisites for your system, you can launch a Release build of EventStore as follows:

dotnet build -c Release src

The build scripts: build.sh and build.ps1 are also available for Linux and Windows respectively to simplify the build process.

To start a single node, you can then run:

dotnet ./src/EventStore.ClusterNode/bin/x64/Release/net8.0/EventStore.ClusterNode.dll --dev --db ./tmp/data --index ./tmp/index --log ./tmp/log

Running the tests

You can launch the tests as follows:

dotnet test src/EventStore.sln

Build EventStoreDB Docker image

You can also build a Docker image by running the command:

docker build --tag myeventstore . \
--build-arg CONTAINER_RUNTIME={container-runtime}
--build-arg RUNTIME={runtime}

For instance:

docker build --tag myeventstore . \
--build-arg CONTAINER_RUNTIME=bookworm-slim \
--build-arg RUNTIME=linux-x64

Note: Because of the Docker issue, if you're building a Docker image on Windows, you may need to set the DOCKER_BUILDKIT=0 environment variable. For instance, running in PowerShell:

$env:DOCKER_BUILDKIT=0; docker build --tag myeventstore . `
--build-arg CONTAINER_RUNTIME=bookworm-slim `
--build-arg RUNTIME=linux-x64

Currently, we support the following configurations:

1. Bookworm slim:

• CONTAINER_RUNTIME=bookworm-slim
• RUNTIME=linux-x64

2. Jammy:

• CONTAINER_RUNTIME=Jammy
• RUNTIME=linux-x64

3. Alpine:

• CONTAINER_RUNTIME=alpine
• RUNTIME=linux-musl-x64

You can verify the built image by running:

docker run --rm myeventstore --insecure --what-if

Need help?

• Release notes
• Beginners Guide to Event Sourcing
• Articles
• Webinars
• Contact us

eventstore-client-go's Issues

Add First-class support for obvious grpc status errors

Thinking about Unauthenticated for example

Cluster Discovery with secure connections

Connections to a secure cluster can fail when the cluster is using secure connections.

To reproduce:

1. Start a secure cluster with hostname gossip seeds
2. Create a client with the following settings:

• NodePreference of leader
• GossipSeed of the follower node hostnames

The client will attempt to connect to the leader node (nodec.eventstore.dev) and fail with the following:

Error Failed to construct subscription. Reason: rpc error: code = Unavailable desc = connection error: desc = "transport: authentication handshake failed: x509: certificate is valid for nodeb.eventstore.dev, not nodec.eventstore.dev"

Connection and AppendToStream Examples

It would be helpful to have an example for connecting and AppendingToStream

Go RFC - 021 Projections API Update Operations Implementation

@tambeau commented on Fri Nov 05 2021

Implementation of Update Operations for Go gRPC Projections API

Update

• Projection (Name, Query, EmitEnabled)
• Config (Name, Config)

Go RFC - 021 Projections API Control Operations Implementation

@tambeau commented on Fri Nov 05 2021

Implementation of Control Operations for Go gRPC Projections API

Control

• Restart Projections Subsystem
• Abort (Name) - WriteCheckpoint set to false
• Disable (Name) - WriteCheckpoint set to true
• Enable (Name)
• Reset (Name) - Remove WriteCheckpoint
• Delete (Name, DeleteStateStream, DeleteCheckpointStream, DeleteEmittedStream)

Incorrect Content-Type

I append events with a content type of application/protobuf; proto=my.pkg.messageName; but I always get application/octet-stream back.

Acknowledgements not being recorded [Persistent Subscription]

A persistent subscription on a $by_category stream, with the ResolvedLinkedTos = true does not record the acknowledgement

https://discuss.eventstore.com/t/acknowledgements-not-being-recorded/3405

Move this repo to EventStoreDb-Client-Go

This should be similar to the Java client.

Validate messages.ProposedEvent.EventID uuid internally, so that package consumers can choose their own UUID implementation

Background

There are a number of other popular Go UUID libraries in existence such as https://github.com/google/uuid. Currently, if an org uses a different uuid package they must do something like

ID, err := uuid.FromString(googleuuid.New().String())
if err != nil {
	panic(err)
}

in order to interface with EventStore-Client-Go. This means an additional dependency must be added to the project for a single slim use case.

Proposal

Change the messages.ProposedEvent definition to accept a string as the EventID, then validate the input internally.

type ProposedEvent struct {
	EventID      string
	EventType    string
	ContentType  string
	Data         []byte
	UserMetadata []byte
}

My team has started to use this Go SDK in practice (we understand the API is not stable), so I'd be happy to jump in and make contributions here if needed.

No method to connect to PersistentSubscriptionAll

Hi,

I can successfully create a persistent subscription that listens to specific events by doing:

db.CreatePersistentSubscriptionAll(
	context.Background(),
	"GroupName",
	esdb.PersistentAllSubscriptionOptions{
		Filter: &esdb.SubscriptionFilter{
			Type:     esdb.EventFilterType,
			Prefixes: []string{"EventType-"},
		},
	},
)

But I could not find the method to subscribe to it without passing a stream name:

db.ConnectToPersistentSubscription(
   context.Background(),
   ???, 
   "GroupName", 
   esdb.ConnectToPersistentSubscriptionOptions{}
)

Am I missing something or it's just not implemented yet?

Investigate flakey tests

Events commit position diffs when appended compare to read

The WriteResult response from an append to a stream include the CommitPosition. Ex: 43033
When I later reads one event that was appended with the CommitPosition 43033. The event Position/Commit is 18446744073709551615

Implement persistent subscriptions

• Create/Update/Delete
• Subscribing

Any way I can help?

Hi,

My company is currently looking at eventstore to add event sourcing to our system, I am currently prototyping with one of our microservice and we are a Go shop team.

Is there any plan on making the release of a stable client soon? Is there any way I can help?

Go RFC - 021 Projections API Create Operation Implementation

@tambeau commented on Fri Nov 05 2021

Implementation of Create Operation for Go gRPC Projections API

Create

• Create Projection (Name, Query, EmitEnabled, TrackEmittedStreams) - Enabled parameter remove always set to false

Ensure the position expectations are correct

Ensure commit/prepare values are being handled appropriately.
What does no position mean and show as to the consumer?

Review the API

Need to review the exposed API and the implementation of proto.
Ensure that the API is idiomatic golang

Release data, usable examples ?

Hi there,

I am quite eager to use eventstore with GO but I am not seeing a lot of working being done.

Is the project still being developed or has it stalled ?

I don't mind it not being ready if I could have some examples of its use.

Anybody using this ? Where did you find some help ?

Thanks in advance.

Persistent Subscription Read error

func (persistent.SyncReadConnection).Read() seems to be giving a null pointer exception on reading deleted events on the $by_category stream

https://discuss.eventstore.com/t/persistent-subscription-read-error/3423

Apply Deadlines RFC

Reference: https://github.com/EventStore/architecture-and-planning/blob/main/rfcs/032%20-%20grpc-clients-deadlines.md

Add first-class error support for not leader exception

Currently it returns a generic fmt.Errorf("not leader exception error")

Go gRPC client HTTP Shim for persistent subscriptions

Standardize HTTP Shim across clients

For Persistent Subscription we'll use for now HTTP API then switch to server capabilities when it's available
fully on the database.

We'll need to have a fallback for HTTP API if the database version is below 21.10.1.

Typo in ErrWrongExpectedStreamRevision error message

Should be "WrongExpectedStreamRevision" instead of "WrongExceptedStreamRevision"

var ErrWrongExpectedStreamRevision = errors.New("WrongExceptedStreamRevision")

I can open a PR if you'd like

Ensure multiple subscriptions can be handled

Ensure that multiple subscriptions to the same and different streams are handled independently of each other. e.g. Getting events, stopping the subscription

Review persistent subscription naming when subscribing

Go RFC - 021 Projections API Implementation

@tambeau commented on Fri Nov 05 2021

Implementation of Go gRPC Projections API

State

• Get Query (Name, Config?) blocked - Server Update Required
• Get Config (Name) blocked - Server Update Required
• Get Status (Name) blocked - Server Update Required
• Get State (Name, Partition) missing partition option
• Get Result (Name, Partition) blocked

Control

• Restart Projections Subsystem
• Abort (Name) - WriteCheckpoint set to false
• Disable (Name) - WriteCheckpoint set to true
• Enable (Name)
• Reset (Name) - Remove WriteCheckpoint
• Delete (Name, DeleteStateStream, DeleteCheckpointStream, DeleteEmittedStream)

Statistics

• Get Statistics (name)
• List All
• List

Update

• Projection (Name, Query, EmitEnabled)
• Config (Name, Config)

Create

• Create Projection (Name, Query, EmitEnabled, TrackEmittedStreams) - Enabled parameter remove always set to false

Update to support EventStore version 21.6.0 or greater

Current supported version is 20.6.0-buster-slim which is last year release and it has a set of few bugs, most notably in persistent subscriptions which are resolved in 21.6.0.
What needs to be done

1. Check if streams proto is updated and generate new golang code and update stream implementation.
2. I would suggest that we ditch the grpc Test Data Client and rewrite tests for streams so that they include data setup phase (writing events). That way it would be easier for developers to read tests and understand the behavior of features.

Persistent subscriptions are already up to date with EventStore 21.6.0.

Add gossip-based node discovery

We can currently connect only to a single node.

Handle failure cases such as reconnecting to leader

1. Set up a cluster of 3 nodes.
2. Connect to them with a go client that reads every second and which has a node preference of leader.
3. Kill the leader of the cluster

The client will start failing, and will not attempt to discover the new leader.

Support plaintext gRPC connection (for use with --insecure)

We currently only support TLS connections

Align Persistent Subscription naming and behaviour with RFC-022 - gRPC Persistent Subscriptions

As the next release will be breaking, then we could use it to align the naming and behaviour with what was agreed in the RFC-022 - gRPC Persistent Subscriptions. Current parameters names are not aligned.

RFC-022

Original Issue

We can also consider doing that non-breaking by marking the old names as obsolete and passing the getters and setters to the new options.

Add missing samples for persistent subscription management API

Not all methods included in #87 have samples, see:

• https://developers.eventstore.com/clients/grpc/persistent-subscriptions.html
• https://github.com/EventStore/EventStore-Client-Dotnet/blob/master/samples/persistent-subscriptions/Program.cs

Catch up subscriptions are difficult to use

Hey, I'm trying to create a catch-up subscription for a stream but I'm hitting both #33, and difficulties telling when the subscription has gone "live".

It seems like the tcp API has the liveProcessingStarted call back for this, but there's no equivalent for the gRPC API.

To get the functionality of being able to subscribe to a stream from the start and receive a call back when live, I had to write this:

// SubscribeToStream subscribes from the start of a stream and calls the
// liveness call back when the latest event is reached.
func (sc *StoreClient) SubscribeToStream(
	ctx context.Context,
	stream string,
	eventHandler func(messages.RecordedEvent),
	livenessHandler func(streamrevision.StreamRevision),
) error {
	// Event store handlers.
	var (
		eventAppeared = func(re messages.RecordedEvent) { eventHandler(re) }
		subDropped    = func(reason string) { log.Printf("subscription to %s dropped", stream) } // TODO: handle async dropped subs
		liveOnce      = sync.Once{}
		goLiveOnce    = func(rev streamrevision.StreamRevision) { liveOnce.Do(func() { livenessHandler(rev) }) }
		streamIsEmpty = false
	)

	// If there's a liveness callback then find the position at which we will
	// go live.
	if livenessHandler != nil {
		res, err := sc.esc.ReadStreamEvents(ctx, direction.Backwards, stream, streamrevision.StreamRevisionEnd, 1, false)
		if err != nil && !errors.Is(err, eserrs.ErrStreamNotFound) {
			return fmt.Errorf("reading latest event: %w", err)
		}

		if len(res) == 1 {
			eventAppeared = func(re messages.RecordedEvent) {
				// Have we reached or passed the latest event?
				if re.EventNumber >= res[0].EventNumber {
					goLiveOnce(streamrevision.StreamRevision(re.EventNumber))
				}

				eventHandler(re)
			}
		} else {
			// There are no events in the stream so go live on func return.
			streamIsEmpty = true
			defer goLiveOnce(streamrevision.StreamRevision(streamrevision.StreamRevisionStart))
		}
	}

	if !streamIsEmpty {
		// Read the first event (this is not included in catch up subscriptions).
		// Attempt to read two event so we can tell if the stream size is greater
		// than one.
		res, err := sc.esc.ReadStreamEvents(ctx, direction.Forwards, stream, streamrevision.StreamRevisionStart, 2, false)
		if err != nil && !errors.Is(err, eserrs.ErrStreamNotFound) {
			return fmt.Errorf("reading first event: %w", err)
		}

		// We attempted to read two events but only received one, the stream must
		// only contain one event.
		if len(res) == 1 {
			eventHandler(res[0])

			// There was only one event is the stream, which we've passed to the
			// handler, so go live on func return.
			defer goLiveOnce(streamrevision.StreamRevision(res[0].EventNumber))
		} else {
			eventHandler(res[0])
		}
	}

	// Subscribe to stream.
	sub, err := sc.esc.SubscribeToStream(ctx, stream, streamrevision.StreamRevisionStart, true, eventAppeared, nil, subDropped)
	if err != nil {
		return fmt.Errorf("creating subscription: %w", err)
	}

	// Start the subscription.
	if err := sub.Start(); err != nil {
		return fmt.Errorf("starting subscription: %w", err)
	}

	return nil
}

It seems like the server has a concept of "going live", it would be great if this could be exposed in the gRPC API, possibly as just another content type in the ReadResp: https://github.com/EventStore/EventStore/blob/master/src/Protos/Grpc/streams.proto#L85

esdb-node      | [    1,47,16:07:14.600,INF] Catch-up subscription 1a4ebd24-f9bc-4020-ad69-c4e36e0aec96 to "my-stream"@"1" running...
esdb-node      | [    1,47,16:07:14.600,INF] Live subscription 1a4ebd24-f9bc-4020-ad69-c4e36e0aec96 to "my-stream" running from "1"...

This seems like a very common usage pattern but it's very difficult to implement and easy to do incorrectly and introduce bugs (I'm not 100% the above works for all cases).

Where are the docs?

Am I missing something?

I can't find any docs or any info

Catch-up subscription skiping the first event

Describe the bug
Executing SubscribeToStream (from = streamrevision.StreamRevisionStart) skips the first event from the stream.

Expected behavior
Get all the events from the stream (event number 0 inclusive) and keep listening for new ones.

EventStore details
"ES VERSION:" "20.6.1.0" ("tags/oss-v20.6.1"/"9ea108855", "Unknown")
"OS:" Linux ("Unix 5.4.39.0")
"RUNTIME:" ".NET 3.1.9" (64-bit)
"GC:" "3 GENERATIONS"

EventStore Installation
docker run --rm --name eventstore -p 2113:2113 -p 1113:1113
eventstore/eventstore:latest --insecure --log-level=Verbose --run-projections=All

Logs
[ 1,38,15:42:26.958,INF] Catch-up subscription 9fcd73f2-fc08-41f8-8ee9-30ccb33b174d to "order-stream"@"1" running...
[ 1,38,15:42:26.959,VRB] Catch-up subscription 9fcd73f2-fc08-41f8-8ee9-30ccb33b174d to "order-stream" reading next page starting from "1".
[ 1,35,15:42:26.961,VRB] Catch-up subscription 9fcd73f2-fc08-41f8-8ee9-30ccb33b174d to "order-stream" received event "1".
[ 1,35,15:42:26.962,VRB] Catch-up subscription 9fcd73f2-fc08-41f8-8ee9-30ccb33b174d to "order-stream" reading next page starting from "2".
[ 1,35,15:42:26.963,VRB] Subscription 9fcd73f2-fc08-41f8-8ee9-30ccb33b174d to "order-stream" reached the end at "1", switching...
[ 1,35,15:42:26.963,INF] Live subscription 9fcd73f2-fc08-41f8-8ee9-30ccb33b174d to "order-stream" running from "1"...
[ 1,35,15:42:26.964,VRB] Live subscription 9fcd73f2-fc08-41f8-8ee9-30ccb33b174d to "order-stream" confirmed at "2".
[ 1,35,15:42:26.964,VRB] Live subscription 9fcd73f2-fc08-41f8-8ee9-30ccb33b174d to "order-stream" loading any missed events starting from "1"
[ 1,38,15:42:26.968,VRB] Live subscription 9fcd73f2-fc08-41f8-8ee9-30ccb33b174d to "order-stream" caught up at "1".

Relevant code

subscription, err := client.SubscribeToStream(
		context.Background(),
		"order-stream",
		streamrevision.StreamRevisionStart,
		false,
		func(e messages.RecordedEvent) {
			log.Printf("New event: %v", e)
		},
		nil,
		func(reason string) {
			log.Printf("EventStoreDB subscription dropped. Reason: %s", reason)
			//TODO: handle re-subscription
		})

From Admin UI / Debug

fromStream('order-stream')
.when({
$any: function(s,e){
log(JSON.stringify(e));
}
})

output:

{
    "correlationId": "1dbdfa1c-314a-48ad-b053-41564abb0659",
    "readerPosition": {
        "$s": {
            "order-stream": 1
        }
    },
    "events": [
        {
            "eventStreamId": "order-stream",
            "eventType": "order-released",
            "data": {
                "id": "5fad54bb43c256000184f494",
                "target_qty_bags": 0,
                "product": "opc"
            },
            "isJson": true,
            "readerPosition": {
                "$s": {
                    "order-stream": 0
                }
            }
        },
        {
            "eventStreamId": "order-stream",
            "eventNumber": 1,
            "eventType": "order-released",
            "data": {
                "id": "5fad54ef43c256000184f495",
                "target_qty_bags": 0,
                "product": "opc"
            },
            "isJson": true,
            "readerPosition": {
                "$s": {
                    "order-stream": 1
                }
            }
        }
    ]
}

No Connect() function on client.Client, How to connect?

This API has changed since the last time I used it. But I noticed there is no longer a Connect() function and I am getting a "Connection Closed" error when trying to use. Could you provide an example on how to connect? I'd be happy to contribute to the README file here with an example once I get it working.

Steps:

1. Run docker image eventstore/eventstore:20.6.0-buster-slim in dev mode.
2. Install the go sdk github.com/EventStore/EventStore-Client-Go v0.0.0-20210901083018-267dadb3ad6f
3. Connect with:

	log.Println("starting app")
	config, err := eventClient.ParseConnectionString(connString)
	if err != nil {
		log.Fatalf("could not create client configuration: %s", err.Error())
	}
	log.Printf("Config = %v", config)

	client, err := eventClient.NewClient(config)
	if err != nil {
		log.Fatalf("could not create client: %s", err.Error())
	}
	// client.Connect() ???
	// err = client.CreatePersistentSubscription(context.Background(), persistent.SubscriptionStreamConfig{})
	// if err != nil {
	// 	log.Fatalf("could not connect to client: %s", err.Error())
	// }
	defer client.Close()

4. Make an appendToStreamCall
5. Error returned "Could not construct append operation. Reason: rpc error: code = Unavailable desc = connection closed"

Thanks,
Nolan

Go client version 1

The Go client needs to support the common features between the dotnet, rust, nodejs and java clients in order for the first supported version to be released.

• Streams:
  • Reading
    • ReadStreamEvents
    • ReadAllEvents
  • AppendToStream
  • Deletions:
    • DeleteStream
    • TombstoneStream
  • Subscriptions (streams/$all)
    • SubscribeToStream
    • SubscribeToAll
    • SubscribeToAllFiltered
• Discovery:
  • Gossip Seed
  • Host Names
  • Single Node
  • Node reconnections
• Persistent Subscriptions:
  • Creating/Updating/Deleting
  • Subscribing

Additionally, the client should have:

• Logging
• Connection String support
• Doc samples

Investigate the possible use of channels for subscriptions

This is currently using goroutines, but channels may be a better way of doing this.

Standardize Go gRPC client deadlines

Standardize deadlines across clients

• Use defaultDeadline as a global setting and deadline as an operation-level setting
• Return a DeadlineExceeded error on timeout
• Set stream/$all reads & stream/$all subscriptions timeouts to infinity by default
• Set timeouts for operations that are not stream/$all reads or subscriptions to 10 seconds by default
• Allow specifying deadlines on each operation apart from stream/$all subscription operations
• defaultDeadline only applies to operations that don't have a default timeout of infinity
• Batch Append deadline is 10 seconds

Implement Tombstone (Hard Delete)

(gRpc) Subscription dropped by server

Describe the bug
Executing client.SubscribeToStream immediately calls back the subscriptionDropped function with the following reason: "Subscription dropped by server: rpc error: code = Unavailable desc = transport is closing".

Expected behavior
Get all the events in the stream and keep listening for new ones. If something is wrong with the code/configuration, a more detailed error message would be helpful.

EventStore details
"ES VERSION:" "20.6.1.0" ("tags/oss-v20.6.1"/"9ea108855", "Unknown")
"OS:" Linux ("Unix 5.4.39.0")
"RUNTIME:" ".NET 3.1.9" (64-bit)
"GC:" "3 GENERATIONS"

EventStore Installation
docker run --rm --name eventstore-node -d -p 2113:2113 -p 1113:1113
eventstore/eventstore:latest --insecure --run-projections=All

Logs
docker logs
[ 1,33,15:32:30.371,INF] Catch-up subscription 46890731-7fe8-47cb-a0b3-08436ba7d543 to "order-stream"@"1" running...

/var/log/eventstore/0.0.0.0-2113-cluster-node/log.json
{"@t":"2020-11-03T15:32:30.3715742Z","@mt":"Catch-up subscription {subscriptionId} to {streamName}@{streamRevision} running...","subscriptionId":"46890731-7fe8-47cb-a0b3-08436ba7d543","streamName":"order-stream","streamRevision":"1","SourceContext":"EventStore.Core.Services.Transport.Grpc.Enumerators+StreamSubscription","ProcessId":1,"ThreadId":33,"RequestId":"0HM401KU3FBS7:00000001","RequestPath":"/event_store.client.streams.Streams/Read","SpanId":"|451a9517-42704e67cf6237c1.","TraceId":"451a9517-42704e67cf6237c1","ParentId":""}

Relevant code

func EventStoreDBClient(eventStoreConnString string) *client.Client {
	config, err := client.ParseConnectionString(eventStoreConnString)
	if err != nil {
		log.Fatalf("EventStoreDB client configuration error: %s", err.Error())
	}

	c, err := client.NewClient(config)
	if err != nil {
		log.Fatalf("EventStoreDB client failed setting up the connection: %s", err.Error())
	}
	err = c.Connect()
	if err != nil {
		log.Fatalf("EventStoreDB client cound not connect: %s", err.Error())
	}

	return c
}

func SubscribeToStream(s string) {
	log.Printf("Subscribing to stream %s...", s)
	client := db.EventStoreDBClient("esdb://admin:[email protected]:2113?tls=false")
	defer client.Close()

	subscription, err := client.SubscribeToStream(context.Background(), s, streamrevision.StreamRevisionStart, false,
		func(e messages.RecordedEvent) {
			log.Printf("Subscription event: %v", e)

		}, nil, func(reason string) {
			// EventStoreDB subscription dropped. Reason: Subscription dropped by server: rpc error: code = Unavailable desc = transport is closing
			log.Printf("EventStoreDB subscription dropped. Reason: %s", reason)
		})

	err = subscription.Start()
	if err != nil {
		log.Fatalf("EventStoreDB subscription error %v", err)
	} else {
		log.Printf("Subscribed to stream %s", s)
	}
}

Support godoc documentation

Ah and one thing: it would be nice to have godoc for most important Public APIs.

You can run godoc server locally

go install -u golang.org/x/tools/cmd/godoc@latest
godoc -http=":6060"

Currently is totally empty for the project. This is how it does look like for an example package: https://pkg.go.dev/net/http

This is a standard way to check documentation by Go devs, so it's good to have at least some docs.

Here is a bit more about doc format: https://elliotchance.medium.com/godoc-tips-tricks-cda6571549b

Originally posted by @roblaszczak in #65 (comment)

Setting position for AppendToStream

I need a way of setting the expected position for the events to go in at on the stream.

The func signature of what I am calling from this package:

func (client *Client) AppendToStream(context context.Context, streamID string, streamRevision stream_revision.StreamRevision, events []messages.ProposedEvent) (*WriteResult, error) {

I assumed stream_revision.StreamRevision and tried it like so:

// ...
sr := streamrevision.StreamRevisionNoStream
if expectedPosition > 0 {
	sr = streamrevision.NewStreamRevision(expectedPosition)
}
// ...
_, err := c.AppendToStream(ctx, streamPrefix + "-" + aggregateID.String(), sr, ce)
// ...

However this doesn't work. Any ideas?

Any help is appreciated.

Naming of the client package and class

I believe we should strive for consistent naming and whilst I am very glad the client is not called a connection, don't you think Client is a bit too generic?

I am not doing Go hands-on, so I'm not sure if it should be the package name of the class name, but it would be great to name one of those (or both) EventStoreClient

Look into logging

Either define interface our self or use existing library.

Create gRPC samples for docs

• Appending Events
• Connecting to a cluster
• Connecting to a single node
• Persistent Subscriptions
• Quick Start
• Reading Events
• Secure with TLS
• Server-side Filtering
• Subscribing to Streams

Pass in certificates for the SSL context

This should be similar to what the nodejs client is doing.

Address test flackiness

We need to increase significantly the deadline limit running in GA

Support DNS Discovery

Go RFC - 021 Projections API Statistics Operations Implementation

@tambeau commented on Fri Nov 05 2021

Implementation of Statistics Operations for Go gRPC Projections API

Statistics

• Get Statistics (name)
• List All
• List