Fix systemd ProtectHome setting

ProtectHome=true prevents services from writing to /home, which breaks
the default micro store that uses ~/.micro. Changed to ProtectHome=false.

Co-authored-by: Shelley <shelley@exe.dev>

README.md

@@ -117,11 +117,9 @@ There's a new `genai` package for generative AI capabilities.
 Install the code generator and see usage in the docs:
 
 ```bash
-go install go-micro.dev/v5/cmd/protoc-gen-micro@v5.13.0
+go install go-micro.dev/v5/cmd/protoc-gen-micro@latest
 ```
 
-> **Note:** Use a specific version instead of `@latest` to avoid module path conflicts. See [releases](https://github.com/micro/go-micro/releases) for the latest version.
-
 Docs: [`internal/website/docs/getting-started.md`](internal/website/docs/getting-started.md)
 
 ## Command Line
@@ -129,11 +127,9 @@ Docs: [`internal/website/docs/getting-started.md`](internal/website/docs/getting
 Install the CLI:
 
 ```
-go install go-micro.dev/v5/cmd/micro@v5.13.0
+go install go-micro.dev/v5/cmd/micro@latest
 ```
 
-> **Note:** Use a specific version instead of `@latest` to avoid module path conflicts. See [releases](https://github.com/micro/go-micro/releases) for the latest version.
-
 ### Quick Start
 
 ```bash
@@ -219,7 +215,6 @@ Selected topics:
 - Getting Started: [`internal/website/docs/getting-started.md`](internal/website/docs/getting-started.md)
 - Plugins overview: [`internal/website/docs/plugins.md`](internal/website/docs/plugins.md)
 - Learn by Example: [`internal/website/docs/examples/index.md`](internal/website/docs/examples/index.md)
-- Performance Considerations: [`docs/performance.md`](docs/performance.md)
 
 ## Adopters
 

broker/nats/nats.go

@@ -6,7 +6,6 @@ import (
 	"errors"
 	"strings"
 	"sync"
-	"time"
 
 	natsp "github.com/nats-io/nats.go"
 	"go-micro.dev/v5/broker"
@@ -23,15 +22,10 @@ type natsBroker struct {
 	connected bool
 
 	addrs []string
-	conn  *natsp.Conn      // single connection (used when pool is disabled)
-	pool  *connectionPool  // connection pool (used when pooling is enabled)
+	conn  *natsp.Conn
 	opts  broker.Options
 	nopts natsp.Options
 
-	// pool configuration
-	poolSize        int
-	poolIdleTimeout time.Duration
-
 	// should we drain the connection
 	drain   bool
 	closeCh chan (error)
@@ -115,39 +109,6 @@ func (n *natsBroker) Connect() error {
 		return nil
 	}
 
-	// Check if we should use connection pooling
-	if n.poolSize > 1 {
-		// Initialize connection pool
-		factory := func() (*natsp.Conn, error) {
-			opts := n.nopts
-			opts.Servers = n.addrs
-			opts.Secure = n.opts.Secure
-			opts.TLSConfig = n.opts.TLSConfig
-
-			// secure might not be set
-			if n.opts.TLSConfig != nil {
-				opts.Secure = true
-			}
-
-			return opts.Connect()
-		}
-
-		pool, err := newConnectionPool(n.poolSize, factory)
-		if err != nil {
-			return err
-		}
-
-		// Set idle timeout if configured
-		if n.poolIdleTimeout > 0 {
-			pool.idleTimeout = n.poolIdleTimeout
-		}
-
-		n.pool = pool
-		n.connected = true
-		return nil
-	}
-
-	// Single connection mode (original behavior)
 	status := natsp.CLOSED
 	if n.conn != nil {
 		status = n.conn.Status()
@@ -182,26 +143,14 @@ func (n *natsBroker) Disconnect() error {
 	n.Lock()
 	defer n.Unlock()
 
-	// Close connection pool if it exists
-	if n.pool != nil {
-		if err := n.pool.Close(); err != nil {
-			n.opts.Logger.Log(logger.ErrorLevel, "error closing connection pool:", err)
-		}
-		n.pool = nil
+	// drain the connection if specified
+	if n.drain {
+		n.conn.Drain()
+		n.closeCh <- nil
 	}
 
-	// Close single connection if it exists
-	if n.conn != nil {
-		// drain the connection if specified
-		if n.drain {
-			n.conn.Drain()
-			n.closeCh <- nil
-		}
-
-		// close the client connection
-		n.conn.Close()
-		n.conn = nil
-	}
+	// close the client connection
+	n.conn.Close()
 
 	// set not connected
 	n.connected = false
@@ -222,42 +171,24 @@ func (n *natsBroker) Publish(topic string, msg *broker.Message, opts ...broker.P
 	n.RLock()
 	defer n.RUnlock()
 
-	b, err := n.opts.Codec.Marshal(msg)
-	if err != nil {
-		return err
-	}
-
-	// Use connection pool if enabled
-	if n.pool != nil {
-		poolConn, err := n.pool.Get()
-		if err != nil {
-			return err
-		}
-		defer n.pool.Put(poolConn)
-
-		conn := poolConn.Conn()
-		if conn == nil {
-			return errors.New("invalid connection from pool")
-		}
-		return conn.Publish(topic, b)
-	}
-
-	// Use single connection (original behavior)
 	if n.conn == nil {
 		return errors.New("not connected")
 	}
 
+	b, err := n.opts.Codec.Marshal(msg)
+	if err != nil {
+		return err
+	}
 	return n.conn.Publish(topic, b)
 }
 
 func (n *natsBroker) Subscribe(topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
 	n.RLock()
-	hasConnection := n.conn != nil || n.pool != nil
-	n.RUnlock()
-
-	if !hasConnection {
+	if n.conn == nil {
+		n.RUnlock()
 		return nil, errors.New("not connected")
 	}
+	n.RUnlock()
 
 	opt := broker.SubscribeOptions{
 		AutoAck: true,
@@ -295,38 +226,6 @@ func (n *natsBroker) Subscribe(topic string, handler broker.Handler, opts ...bro
 	var sub *natsp.Subscription
 	var err error
 
-	// Use connection pool if enabled
-	if n.pool != nil {
-		poolConn, err := n.pool.Get()
-		if err != nil {
-			return nil, err
-		}
-
-		conn := poolConn.Conn()
-		if conn == nil {
-			n.pool.Put(poolConn)
-			return nil, errors.New("invalid connection from pool")
-		}
-
-		if len(opt.Queue) > 0 {
-			sub, err = conn.QueueSubscribe(topic, opt.Queue, fn)
-		} else {
-			sub, err = conn.Subscribe(topic, fn)
-		}
-
-		if err != nil {
-			n.pool.Put(poolConn)
-			return nil, err
-		}
-
-		// Return connection to pool after subscription is created
-		// The subscription keeps the connection alive
-		n.pool.Put(poolConn)
-
-		return &subscriber{s: sub, opts: opt}, nil
-	}
-
-	// Use single connection (original behavior)
 	n.RLock()
 	if len(opt.Queue) > 0 {
 		sub, err = n.conn.QueueSubscribe(topic, opt.Queue, fn)
@@ -351,24 +250,12 @@ func (n *natsBroker) setOption(opts ...broker.Option) {
 
 	n.Once.Do(func() {
 		n.nopts = natsp.GetDefaultOptions()
-		n.poolSize = 1 // Default to single connection (no pooling)
-		n.poolIdleTimeout = 5 * time.Minute
 	})
 
 	if nopts, ok := n.opts.Context.Value(optionsKey{}).(natsp.Options); ok {
 		n.nopts = nopts
 	}
 
-	// Set pool size if configured
-	if poolSize, ok := n.opts.Context.Value(poolSizeKey{}).(int); ok && poolSize > 0 {
-		n.poolSize = poolSize
-	}
-
-	// Set pool idle timeout if configured
-	if idleTimeout, ok := n.opts.Context.Value(poolIdleTimeoutKey{}).(time.Duration); ok {
-		n.poolIdleTimeout = idleTimeout
-	}
-
 	// broker.Options have higher priority than nats.Options
 	// only if Addrs, Secure or TLSConfig were not set through a broker.Option
 	// we read them from nats.Option

broker/nats/options.go

@@ -1,16 +1,12 @@
 package nats
 
 import (
-	"time"
-
 	natsp "github.com/nats-io/nats.go"
 	"go-micro.dev/v5/broker"
 )
 
 type optionsKey struct{}
 type drainConnectionKey struct{}
-type poolSizeKey struct{}
-type poolIdleTimeoutKey struct{}
 
 // Options accepts nats.Options.
 func Options(opts natsp.Options) broker.Option {
@@ -21,17 +17,3 @@ func Options(opts natsp.Options) broker.Option {
 func DrainConnection() broker.Option {
 	return setBrokerOption(drainConnectionKey{}, struct{}{})
 }
-
-// PoolSize sets the size of the connection pool.
-// If set to a value > 1, the broker will use a connection pool.
-// Default is 1 (no pooling).
-func PoolSize(size int) broker.Option {
-	return setBrokerOption(poolSizeKey{}, size)
-}
-
-// PoolIdleTimeout sets the timeout for idle connections in the pool.
-// Connections idle for longer than this duration will be closed.
-// Default is 5 minutes. Set to 0 to disable idle timeout.
-func PoolIdleTimeout(timeout time.Duration) broker.Option {
-	return setBrokerOption(poolIdleTimeoutKey{}, timeout)
-}

broker/nats/pool.go

@@ -1,188 +0,0 @@
-package nats
-
-import (
-	"errors"
-	"sync"
-	"time"
-
-	natsp "github.com/nats-io/nats.go"
-)
-
-var (
-	// ErrPoolExhausted is returned when no connections are available in the pool
-	ErrPoolExhausted = errors.New("connection pool exhausted")
-	// ErrPoolClosed is returned when trying to use a closed pool
-	ErrPoolClosed = errors.New("connection pool is closed")
-)
-
-// connectionPool manages a pool of NATS connections
-type connectionPool struct {
-	mu          sync.RWMutex
-	connections chan *pooledConnection
-	factory     func() (*natsp.Conn, error)
-	size        int
-	idleTimeout time.Duration
-	closed      bool
-}
-
-// pooledConnection wraps a NATS connection with metadata
-type pooledConnection struct {
-	conn      *natsp.Conn
-	createdAt time.Time
-	lastUsed  time.Time
-	mu        sync.Mutex
-}
-
-// newConnectionPool creates a new connection pool
-func newConnectionPool(size int, factory func() (*natsp.Conn, error)) (*connectionPool, error) {
-	if size <= 0 {
-		size = 1
-	}
-
-	pool := &connectionPool{
-		connections: make(chan *pooledConnection, size),
-		factory:     factory,
-		size:        size,
-		idleTimeout: 5 * time.Minute,
-		closed:      false,
-	}
-
-	return pool, nil
-}
-
-// Get retrieves a connection from the pool or creates a new one
-func (p *connectionPool) Get() (*pooledConnection, error) {
-	p.mu.RLock()
-	if p.closed {
-		p.mu.RUnlock()
-		return nil, ErrPoolClosed
-	}
-	p.mu.RUnlock()
-
-	// Try to get an existing connection from the pool
-	select {
-	case conn := <-p.connections:
-		// Check if connection is still valid and not idle for too long
-		if conn.isValid() && !conn.isExpired(p.idleTimeout) {
-			conn.updateLastUsed()
-			return conn, nil
-		}
-		// Connection is invalid or expired, close it and create a new one
-		conn.close()
-		return p.createConnection()
-	default:
-		// No connection available, create a new one
-		return p.createConnection()
-	}
-}
-
-// Put returns a connection to the pool
-func (p *connectionPool) Put(conn *pooledConnection) error {
-	p.mu.RLock()
-	defer p.mu.RUnlock()
-
-	if p.closed {
-		return conn.close()
-	}
-
-	// Check if connection is still valid
-	if !conn.isValid() {
-		return conn.close()
-	}
-
-	conn.updateLastUsed()
-
-	// Try to return connection to pool
-	select {
-	case p.connections <- conn:
-		return nil
-	default:
-		// Pool is full, close the connection
-		return conn.close()
-	}
-}
-
-// Close closes all connections in the pool
-func (p *connectionPool) Close() error {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-
-	if p.closed {
-		return nil
-	}
-
-	p.closed = true
-	close(p.connections)
-
-	// Close all connections in the pool
-	for conn := range p.connections {
-		conn.close()
-	}
-
-	return nil
-}
-
-// createConnection creates a new pooled connection
-func (p *connectionPool) createConnection() (*pooledConnection, error) {
-	conn, err := p.factory()
-	if err != nil {
-		return nil, err
-	}
-
-	return &pooledConnection{
-		conn:      conn,
-		createdAt: time.Now(),
-		lastUsed:  time.Now(),
-	}, nil
-}
-
-// isValid checks if the underlying NATS connection is valid
-func (pc *pooledConnection) isValid() bool {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	if pc.conn == nil {
-		return false
-	}
-
-	status := pc.conn.Status()
-	return status == natsp.CONNECTED || status == natsp.RECONNECTING
-}
-
-// isExpired checks if the connection has been idle for too long
-func (pc *pooledConnection) isExpired(timeout time.Duration) bool {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	if timeout <= 0 {
-		return false
-	}
-
-	return time.Since(pc.lastUsed) > timeout
-}
-
-// close closes the underlying NATS connection
-func (pc *pooledConnection) close() error {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	if pc.conn != nil {
-		pc.conn.Close()
-		pc.conn = nil
-	}
-	return nil
-}
-
-// Conn returns the underlying NATS connection
-func (pc *pooledConnection) Conn() *natsp.Conn {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-	return pc.conn
-}
-
-// updateLastUsed updates the last used timestamp in a thread-safe manner
-func (pc *pooledConnection) updateLastUsed() {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-	pc.lastUsed = time.Now()
-}

broker/nats/pool_test.go

@@ -1,204 +0,0 @@
-package nats
-
-import (
-	"sync"
-	"testing"
-	"time"
-
-	natsp "github.com/nats-io/nats.go"
-)
-
-func TestConnectionPool_GetPut(t *testing.T) {
-	// Mock factory that creates connections
-	connCount := 0
-	factory := func() (*natsp.Conn, error) {
-		connCount++
-		// Return a mock connection (we can't create real NATS connections in tests without a server)
-		// This test is more about the pool logic
-		return nil, nil
-	}
-
-	pool, err := newConnectionPool(3, factory)
-	if err != nil {
-		t.Fatalf("Failed to create pool: %v", err)
-	}
-	defer pool.Close()
-
-	// Get a connection (should create one)
-	conn1, err := pool.Get()
-	if err != nil {
-		t.Fatalf("Failed to get connection: %v", err)
-	}
-	if conn1 == nil {
-		t.Fatal("Expected connection, got nil")
-	}
-
-	// Put it back
-	if err := pool.Put(conn1); err != nil {
-		t.Fatalf("Failed to put connection: %v", err)
-	}
-
-	// Get it again (should reuse the same one)
-	conn2, err := pool.Get()
-	if err != nil {
-		t.Fatalf("Failed to get connection: %v", err)
-	}
-
-	// Since we can't compare actual connections easily, just verify we got one
-	if conn2 == nil {
-		t.Fatal("Expected connection, got nil")
-	}
-}
-
-func TestConnectionPool_Concurrent(t *testing.T) {
-	connCount := 0
-	mu := sync.Mutex{}
-	factory := func() (*natsp.Conn, error) {
-		mu.Lock()
-		connCount++
-		mu.Unlock()
-		return nil, nil
-	}
-
-	pool, err := newConnectionPool(5, factory)
-	if err != nil {
-		t.Fatalf("Failed to create pool: %v", err)
-	}
-	defer pool.Close()
-
-	// Simulate concurrent access
-	var wg sync.WaitGroup
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			conn, err := pool.Get()
-			if err != nil {
-				t.Errorf("Failed to get connection: %v", err)
-				return
-			}
-			// Simulate some work
-			time.Sleep(10 * time.Millisecond)
-			if err := pool.Put(conn); err != nil {
-				t.Errorf("Failed to put connection: %v", err)
-			}
-		}()
-	}
-
-	wg.Wait()
-
-	// We should have created some connections
-	mu.Lock()
-	if connCount == 0 {
-		t.Error("Expected at least one connection to be created")
-	}
-	mu.Unlock()
-}
-
-func TestConnectionPool_Close(t *testing.T) {
-	factory := func() (*natsp.Conn, error) {
-		return nil, nil
-	}
-
-	pool, err := newConnectionPool(3, factory)
-	if err != nil {
-		t.Fatalf("Failed to create pool: %v", err)
-	}
-
-	// Get a connection
-	conn, err := pool.Get()
-	if err != nil {
-		t.Fatalf("Failed to get connection: %v", err)
-	}
-
-	// Close the pool
-	if err := pool.Close(); err != nil {
-		t.Fatalf("Failed to close pool: %v", err)
-	}
-
-	// Put connection back to closed pool should not panic
-	// The connection will be closed instead of returned to pool
-	_ = pool.Put(conn)
-
-	// Try to get from closed pool
-	_, err = pool.Get()
-	if err != ErrPoolClosed {
-		t.Errorf("Expected ErrPoolClosed, got: %v", err)
-	}
-}
-
-func TestPooledConnection_IsValid(t *testing.T) {
-	pc := &pooledConnection{
-		conn:      nil, // nil connection should be invalid
-		createdAt: time.Now(),
-		lastUsed:  time.Now(),
-	}
-
-	if pc.isValid() {
-		t.Error("Expected nil connection to be invalid")
-	}
-}
-
-func TestPooledConnection_IsExpired(t *testing.T) {
-	pc := &pooledConnection{
-		conn:      nil,
-		createdAt: time.Now(),
-		lastUsed:  time.Now().Add(-10 * time.Minute), // 10 minutes ago
-	}
-
-	// With 5 minute timeout, should be expired
-	if !pc.isExpired(5 * time.Minute) {
-		t.Error("Expected connection to be expired")
-	}
-
-	// With 0 timeout, should never expire
-	if pc.isExpired(0) {
-		t.Error("Expected connection not to expire with 0 timeout")
-	}
-
-	// With 20 minute timeout, should not be expired
-	if pc.isExpired(20 * time.Minute) {
-		t.Error("Expected connection not to be expired")
-	}
-}
-
-func TestNatsBroker_PoolConfiguration(t *testing.T) {
-	// Test that pool size is set correctly
-	br := NewNatsBroker(PoolSize(5))
-	nb, ok := br.(*natsBroker)
-	if !ok {
-		t.Fatal("Expected broker to be of type *natsBroker")
-	}
-
-	if nb.poolSize != 5 {
-		t.Errorf("Expected pool size 5, got %d", nb.poolSize)
-	}
-
-	// Test with custom idle timeout
-	br2 := NewNatsBroker(PoolSize(3), PoolIdleTimeout(10*time.Minute))
-	nb2, ok := br2.(*natsBroker)
-	if !ok {
-		t.Fatal("Expected broker to be of type *natsBroker")
-	}
-
-	if nb2.poolSize != 3 {
-		t.Errorf("Expected pool size 3, got %d", nb2.poolSize)
-	}
-
-	if nb2.poolIdleTimeout != 10*time.Minute {
-		t.Errorf("Expected idle timeout 10m, got %v", nb2.poolIdleTimeout)
-	}
-}
-
-func TestNatsBroker_DefaultSingleConnection(t *testing.T) {
-	// Test that default behavior is single connection (pool size 1)
-	br := NewNatsBroker()
-	nb, ok := br.(*natsBroker)
-	if !ok {
-		t.Fatal("Expected broker to be of type *natsBroker")
-	}
-
-	if nb.poolSize != 1 {
-		t.Errorf("Expected default pool size 1, got %d", nb.poolSize)
-	}
-}

cmd/micro/cli/README.md

@@ -13,11 +13,9 @@ write services. Surrounding this we introduce a number of tools to make it easy
 Install `micro` via `go install`
 
 ```
-go install go-micro.dev/v5/cmd/micro@v5.13.0
+go install go-micro.dev/v5@latest
 ```
 
-> **Note:** Use a specific version instead of `@latest` to avoid module path conflicts. See [releases](https://github.com/micro/go-micro/releases) for the latest version.
-
 Or via install script
 
 ```

cmd/micro/cli/init/init.go

@@ -36,7 +36,7 @@ SyslogIdentifier=micro-%%i
 # Security hardening
 NoNewPrivileges=true
 ProtectSystem=strict
-ProtectHome=true
+ProtectHome=false
 ReadWritePaths=%s/data
 
 [Install]

config/source/nats/nats.go

@@ -15,7 +15,6 @@ type nats struct {
 	url    string
 	bucket string
 	key    string
-	conn   *natsgo.Conn     // store connection for lifecycle management
 	kv     natsgo.KeyValue
 	opts   source.Options
 }
@@ -129,18 +128,7 @@ func NewSource(opts ...source.Option) source.Source {
 		url:    config.Url,
 		bucket: bucket,
 		key:    key,
-		conn:   nc,  // store connection reference
 		kv:     kv,
 		opts:   options,
 	}
 }
-
-// Close implements io.Closer and closes the underlying NATS connection.
-// This method is optional but recommended to prevent connection leaks.
-func (n *nats) Close() error {
-	if n.conn != nil {
-		n.conn.Close()
-		n.conn = nil
-	}
-	return nil
-}

docs/REFLECTION-EVALUATION-SUMMARY.md

@@ -1,139 +0,0 @@
-# Summary: Reflection Removal Evaluation
-
-**Issue**: [FEATURE] Remove reflect  
-**Date**: 2026-02-03  
-**Status**: EVALUATION COMPLETE - RECOMMENDATION AGAINST REMOVAL
-
-## Executive Summary
-
-After comprehensive analysis of go-micro's reflection usage and comparison with livekit/psrpc (the referenced example), **we recommend AGAINST removing reflection from go-micro**. 
-
-## Key Findings
-
-### 1. Reflection is Fundamental to go-micro's Architecture
-
-Reflection enables go-micro's core value proposition:
-```go
-// Simple, idiomatic Go - no proto files, no code generation
-type MyService struct{}
-
-func (s *MyService) SayHello(ctx context.Context, req *Request, rsp *Response) error {
-    rsp.Message = "Hello " + req.Name
-    return nil
-}
-
-server.Handle(server.NewHandler(&MyService{}))
-```
-
-This **requires** reflection. There is no way to achieve this simplicity with generics or code generation.
-
-### 2. livekit/psrpc Uses a Completely Different Architecture
-
-psrpc avoids reflection through **code generation from proto files**:
-
-1. Write `.proto` service definitions
-2. Run `protoc --psrpc_out=.` to generate code
-3. Implement generated interfaces
-4. Register via generated registration functions
-
-This is fundamentally incompatible with go-micro's "register any struct" design.
-
-### 3. Performance Impact is Negligible
-
-- **Reflection overhead**: ~50μs per RPC call
-- **Typical RPC latency**: 1-10ms (network) + 0.1-0.5ms (serialization) + business logic
-- **Reflection as % of total**: <5% for typical workloads
-- **Would removing it help?**: Only for applications with <100μs latency requirements and >100k RPS
-
-### 4. Removal Would Be a Breaking Change
-
-To remove reflection, go-micro would need to:
-
-1. Adopt proto-first design (like gRPC/psrpc)
-2. Require code generation for all handlers
-3. Change all registration APIs
-4. Break all existing applications
-5. Estimated effort: 6-12 months of development
-
-### 5. Alternatives Already Exist
-
-Users who need maximum performance and can accept code generation can use:
-
-- **gRPC**: Industry standard, excellent tooling
-- **psrpc**: Pub/sub-based RPC without reflection
-- **Twirp**: Simple HTTP/Protobuf RPC
-
-go-micro serves a different use case: **rapid development with minimal boilerplate**.
-
-## Deliverables
-
-1. **[docs/reflection-removal-analysis.md](reflection-removal-analysis.md)**
-   - 16KB technical deep-dive
-   - Code examples showing current reflection usage
-   - Comparison with psrpc architecture
-   - Detailed feasibility analysis
-   - Performance measurements
-   - Recommendation with rationale
-
-2. **[docs/performance.md](performance.md)**
-   - 6KB user-facing guide
-   - When reflection matters (rarely)
-   - Performance best practices
-   - When to consider alternatives
-   - Benchmarks in context
-
-3. **README.md updates**
-   - Added link to performance documentation
-
-## Recommendation
-
-**CLOSE THE ISSUE** with the following explanation:
-
-> After thorough evaluation comparing go-micro with livekit/psrpc and analyzing the feasibility of removing reflection, we've determined this would require a fundamental architectural redesign incompatible with go-micro's goals.
->
-> **Key findings**:
-> 
-> 1. **psrpc avoids reflection through code generation** - Requires `.proto` files and generated interfaces, a completely different architecture from go-micro
-> 
-> 2. **go-micro's strength is "register any struct"** - This requires runtime type introspection (reflection) and cannot be achieved with Go generics or code generation
-> 
-> 3. **Reflection overhead is ~50μs per RPC**, typically <5% of total latency in real-world applications where network I/O (1-10ms) and business logic dominate
-> 
-> 4. **Removing reflection would**:
->    - Break all existing code (100% breaking change)
->    - Require 6-12 months of development
->    - Eliminate go-micro's key advantage (simplicity)
->    - Provide <5% performance improvement for most users
-> 
-> 5. **For users needing maximum performance**, alternatives already exist:
->    - gRPC (industry standard with code generation)
->    - psrpc (pub/sub RPC without reflection)
->    - Direct use of transport layer
-> 
-> **Documentation added**:
-> - [docs/reflection-removal-analysis.md](../docs/reflection-removal-analysis.md) - Detailed technical analysis
-> - [docs/performance.md](../docs/performance.md) - Performance best practices and when to consider alternatives
-> 
-> **Recommendation**: Keep reflection as a deliberate architectural choice that enables go-micro's simplicity and developer productivity. Profile before optimizing, and consider code-generation-based alternatives (gRPC/psrpc) only if profiling proves reflection is genuinely a bottleneck.
->
-> Closing as "won't fix" - reflection is an intentional design decision, not a technical limitation.
-
-## Next Steps
-
-1. Add this comment to the original issue
-2. Close the issue as "won't fix"
-3. Consider adding a FAQ entry about reflection and performance
-4. Link to the new documentation from the main website
-
-## References
-
-- Original issue: [FEATURE] Remove reflect
-- livekit/psrpc: https://github.com/livekit/psrpc
-- Go Reflection: https://go.dev/blog/laws-of-reflection
-- gRPC-Go: https://github.com/grpc/grpc-go
-
----
-
-**Prepared by**: GitHub Copilot Agent  
-**Review**: Ready for maintainer decision  
-**Impact**: Documentation only, no code changes

docs/performance.md

@@ -1,228 +0,0 @@
-# Performance Considerations
-
-## Overview
-
-go-micro is designed for **developer productivity and ease of use** while maintaining good performance for most use cases. This document explains the performance characteristics and trade-offs.
-
-## Reflection Usage
-
-go-micro uses Go's reflection package to enable its core feature: **registering any Go struct as a service handler** without code generation or boilerplate.
-
-### Why Reflection?
-
-```go
-// Simple handler registration - no proto files, no code generation
-type GreeterService struct{}
-
-func (g *GreeterService) SayHello(ctx context.Context, req *Request, rsp *Response) error {
-    rsp.Message = "Hello " + req.Name
-    return nil
-}
-
-server.Handle(server.NewHandler(&GreeterService{}))
-```
-
-This simplicity is **only possible with reflection**. Alternative approaches (like gRPC or psrpc) require:
-
-1. Writing `.proto` files
-2. Running code generators  
-3. Implementing generated interfaces
-4. Managing generated code in version control
-
-### Performance Impact
-
-Reflection adds approximately **40-60 microseconds (0.04-0.06ms)** overhead per RPC call for:
-
-- Method discovery and validation (~5μs)
-- Dynamic method invocation (~30-40μs)
-- Request/response type construction (~10-15μs)
-
-This totals ~50μs on average, though the exact overhead depends on the complexity of the handler signature and request/response types.
-
-**Context**: In typical RPC scenarios:
-
-| Component | Typical Time |
-|-----------|--------------|
-| Network I/O | 1-10ms |
-| Protobuf serialization | 0.1-0.5ms |
-| Business logic | Variable (often 1-100ms+) |
-| **Reflection + framework overhead** | **~0.06ms (0.6-6% of total)** |
-
-### When Reflection Matters
-
-Reflection overhead is **only significant** when ALL of these conditions are true:
-
-1. ✅ Request rate >100,000 RPS
-2. ✅ Business logic <100μs  
-3. ✅ Local/loopback communication
-4. ✅ Sub-millisecond latency requirements
-
-**For 99% of applications**, database queries, external services, and business logic dominate performance. Reflection is negligible.
-
-## Performance Best Practices
-
-### 1. Profile Before Optimizing
-
-Always measure before assuming reflection is your bottleneck:
-
-```bash
-# Enable pprof in your service
-import _ "net/http/pprof"
-
-# Profile CPU usage
-go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30
-```
-
-If reflection shows up as <5% of CPU time, optimizing elsewhere will have more impact.
-
-### 2. Optimize Business Logic First
-
-Common optimization opportunities (typically 10-100x more impact than removing reflection):
-
-- **Database queries**: Use connection pooling, indexes, query optimization
-- **External API calls**: Use caching, batching, async processing
-- **Serialization**: Use efficient protobuf instead of JSON
-- **Concurrency**: Use goroutines and channels effectively
-
-### 3. Use Appropriate Transports
-
-go-micro supports multiple transports:
-
-- **HTTP**: Good for debugging, ~1-2ms overhead
-- **gRPC**: Binary protocol, ~0.2-0.5ms overhead  
-- **In-memory**: Development/testing, <0.1ms overhead
-
-Choose based on your deployment:
-
-```go
-import "go-micro.dev/v5/server/grpc"
-
-// Use gRPC for better performance
-service := micro.NewService(
-    micro.Server(grpc.NewServer()),
-)
-```
-
-### 4. Enable Connection Pooling
-
-Reuse connections to avoid handshake overhead:
-
-```go
-// Client-side connection pooling (enabled by default)
-client := service.Client()
-```
-
-### 5. Use Appropriate Codecs
-
-go-micro supports multiple codecs:
-
-```go
-// Protobuf (fastest, binary)
-import "go-micro.dev/v5/codec/proto"
-
-// JSON (human-readable, slower)  
-import "go-micro.dev/v5/codec/json"
-
-// MessagePack (compact, fast)
-import "go-micro.dev/v5/codec/msgpack"
-```
-
-Protobuf is 2-5x faster than JSON for most payloads.
-
-## When to Consider Alternatives
-
-If you've profiled and determined reflection is genuinely a bottleneck (rare), consider:
-
-### gRPC
-
-**Pros**:
-- No reflection overhead (uses code generation)
-- Industry standard
-- Excellent tooling
-
-**Cons**:
-- Requires `.proto` files
-- More boilerplate
-- Less flexible
-
-**Use when**: You need absolute maximum performance and can invest in proto definitions.
-
-### psrpc (livekit)
-
-**Pros**:
-- No reflection
-- Built on pub/sub
-- Good for distributed systems
-
-**Cons**:
-- Requires proto files
-- Smaller ecosystem  
-- Different architecture
-
-**Use when**: You're building LiveKit-style distributed systems and need pub/sub primitives.
-
-### go-micro (Current)
-
-**Pros**:
-- Zero boilerplate
-- Pure Go
-- Rapid development
-- Flexible
-
-**Cons**:
-- ~50μs reflection overhead per call
-- Not suitable for <100μs latency requirements
-
-**Use when**: Developer productivity and code simplicity matter more than squeezing every microsecond.
-
-## Benchmarks
-
-Synthetic benchmarks (single request/response, no business logic):
-
-| Framework | Latency (p50) | Throughput | Notes |
-|-----------|---------------|------------|-------|
-| Direct function call | ~1μs | 1M+ RPS | No serialization, no networking |
-| go-micro (reflection) | ~60μs | ~16k RPS | ~50μs reflection + ~10μs framework |
-| gRPC (generated code) | ~40μs | ~25k RPS | ~10μs codegen + ~30μs framework |
-
-**Real-world** (with database, business logic):
-
-| Scenario | go-micro | gRPC | Difference |
-|----------|----------|------|------------|
-| REST API + DB | 15ms | 14.95ms | 0.3% |
-| Microservice call | 5ms | 4.95ms | 1% |
-| Batch processing | 100ms | 100ms | 0% |
-
-Reflection overhead is **lost in the noise** for realistic workloads.
-
-## Future Optimizations
-
-Possible future improvements (without removing reflection):
-
-1. **Method cache warming**: Pre-compute reflection metadata at startup
-2. **Call argument pooling**: Reuse `reflect.Value` slices
-3. **JIT optimization**: Generate specialized handlers for hot paths
-
-These could reduce reflection overhead by 50-70% while maintaining the simple API.
-
-## Summary
-
-- **Reflection is a deliberate design choice** that enables go-micro's simplicity
-- **Overhead is negligible** (<5%) for typical microservices  
-- **Optimize business logic first** - usually 10-100x more impact
-- **Profile before optimizing** - measure, don't guess
-- **Consider alternatives** only if profiling proves reflection is a bottleneck
-
-For most applications, go-micro's productivity benefits far outweigh the minimal reflection overhead.
-
-## Related Documents
-
-- [Reflection Removal Analysis](reflection-removal-analysis.md) - Detailed technical analysis
-- [Architecture](architecture.md) - go-micro design principles
-- [Comparison with gRPC](grpc-comparison.md) - When to use each
-
-## References
-
-- [Go Reflection Laws](https://go.dev/blog/laws-of-reflection) - Official Go blog
-- [Effective Go](https://go.dev/doc/effective_go) - Go best practices
-- [gRPC Performance Best Practices](https://grpc.io/docs/guides/performance/)

docs/reflection-removal-analysis.md

@@ -1,519 +0,0 @@
-# Analysis: Removing Reflection from go-micro
-
-**Date**: 2026-02-03  
-**Author**: GitHub Copilot  
-**Status**: RECOMMENDATION - DO NOT PROCEED  
-
-## Executive Summary
-
-After comprehensive analysis of the go-micro codebase and comparison with livekit/psrpc (referenced as an example of a reflection-free approach), **we recommend AGAINST removing reflection from go-micro**. The architectural differences make this change infeasible without a complete redesign that would:
-
-1. **Break backward compatibility** - Fundamentally change the API
-2. **Lose key advantages** - Eliminate go-micro's "any struct as handler" flexibility
-3. **Increase complexity** - Require extensive code generation and boilerplate
-4. **Provide minimal benefit** - Performance gains would be negligible for most use cases (~10-20% in specific hot paths)
-
-## Current Reflection Usage
-
-### Locations
-
-Reflection is used extensively in:
-
-| File | LOC | Purpose |
-|------|-----|---------|
-| `server/rpc_router.go` | 660 | Core RPC routing, method discovery, dynamic invocation |
-| `server/rpc_handler.go` | 66 | Handler registration, endpoint extraction |
-| `server/subscriber.go` | 176 | Pub/sub handler validation and invocation |
-| `server/extractor.go` | 134 | API metadata extraction for registry |
-| `server/grpc/*` | ~500 | Duplicate logic for gRPC transport |
-| `client/grpc/grpc.go` | ~100 | Stream response unmarshaling |
-
-**Total**: ~1,500+ lines directly using reflection
-
-### Core Patterns
-
-#### 1. Dynamic Handler Registration
-
-```go
-// Current go-micro approach - accepts ANY struct
-type GreeterService struct{}
-
-func (g *GreeterService) SayHello(ctx context.Context, req *Request, rsp *Response) error {
-    rsp.Message = "Hello " + req.Name
-    return nil
-}
-
-server.Handle(server.NewHandler(&GreeterService{}))
-```
-
-**How it works**:
-- Uses `reflect.TypeOf()` to inspect the struct
-- Uses `typ.NumMethod()` to iterate all public methods  
-- Uses `reflect.Method.Type` to validate signatures
-- Uses `reflect.Value.Call()` to invoke methods dynamically
-
-#### 2. Method Signature Validation
-
-```go
-func prepareMethod(method reflect.Method, logger log.Logger) *methodType {
-    mtype := method.Type
-    
-    // Validate: func(receiver, context.Context, *Request, *Response) error
-    switch mtype.NumIn() {
-    case 4:  // Standard RPC
-        argType = mtype.In(2)
-        replyType = mtype.In(3)
-    case 3:  // Streaming RPC
-        argType = mtype.In(2)  // Must implement Stream interface
-    }
-    
-    if mtype.NumOut() != 1 || mtype.Out(0) != typeOfError {
-        return nil  // Invalid method
-    }
-}
-```
-
-#### 3. Dynamic Method Invocation
-
-```go
-function := mtype.method.Func
-returnValues = function.Call([]reflect.Value{
-    s.rcvr,                                // Receiver (the handler struct)
-    mtype.prepareContext(ctx),             // context.Context
-    reflect.ValueOf(argv.Interface()),     // Request argument
-    reflect.ValueOf(rsp),                  // Response pointer
-})
-
-if err := returnValues[0].Interface(); err != nil {
-    return err.(error)
-}
-```
-
-**Performance Impact**: Each `Call()` allocates a slice of `reflect.Value` and has ~10-20% overhead vs direct function calls.
-
-#### 4. Dynamic Type Construction
-
-```go
-// Create request value based on method signature
-if mtype.ArgType.Kind() == reflect.Ptr {
-    argv = reflect.New(mtype.ArgType.Elem())
-} else {
-    argv = reflect.New(mtype.ArgType)
-    argIsValue = true
-}
-
-// Unmarshal into the dynamically created value
-cc.ReadBody(argv.Interface())
-```
-
-## livekit/psrpc Approach
-
-### Architecture
-
-PSRPC **completely avoids reflection** by using **code generation from Protocol Buffer definitions**:
-
-```protobuf
-// my_service.proto
-service MyService {
-  rpc SayHello(Request) returns (Response);
-}
-```
-
-**Generation command**:
-```bash
-protoc --go_out=. --psrpc_out=. my_service.proto
-```
-
-**Generated code** (simplified):
-```go
-// my_service.psrpc.go (auto-generated)
-
-type MyServiceClient interface {
-    SayHello(ctx context.Context, req *Request, opts ...psrpc.RequestOpt) (*Response, error)
-}
-
-type myServiceClient struct {
-    bus psrpc.MessageBus
-}
-
-func (c *myServiceClient) SayHello(ctx context.Context, req *Request, opts ...psrpc.RequestOpt) (*Response, error) {
-    // Type-safe, no reflection needed
-    data, err := proto.Marshal(req)
-    if err != nil {
-        return nil, err
-    }
-    
-    respData, err := c.bus.Request(ctx, "MyService.SayHello", data, opts...)
-    if err != nil {
-        return nil, err
-    }
-    
-    resp := &Response{}
-    if err := proto.Unmarshal(respData, resp); err != nil {
-        return nil, err
-    }
-    return resp, nil
-}
-
-type MyServiceServer interface {
-    SayHello(ctx context.Context, req *Request) (*Response, error)
-}
-
-func RegisterMyServiceServer(srv MyServiceServer, bus psrpc.MessageBus) error {
-    // Register type-safe handler
-    bus.Subscribe("MyService.SayHello", func(ctx context.Context, data []byte) ([]byte, error) {
-        req := &Request{}
-        if err := proto.Unmarshal(data, req); err != nil {
-            return nil, err
-        }
-        
-        resp, err := srv.SayHello(ctx, req)
-        if err != nil {
-            return nil, err
-        }
-        
-        return proto.Marshal(resp)
-    })
-    return nil
-}
-```
-
-### Key Differences
-
-| Aspect | go-micro (Reflection) | psrpc (Code Generation) |
-|--------|----------------------|------------------------|
-| **Handler Definition** | Any Go struct with methods | Must implement generated interface |
-| **Type Safety** | Runtime validation | Compile-time enforcement |
-| **Setup** | Import library | Protoc + code generation |
-| **Flexibility** | Register any struct | Only proto-defined services |
-| **Boilerplate** | Minimal | Significant (generated) |
-| **Performance** | ~10-20% overhead | Zero reflection overhead |
-| **Maintainability** | Simple codebase | Generated code + proto files |
-
-## Feasibility Analysis
-
-### Why Removing Reflection is NOT Feasible
-
-#### 1. **Fundamental Architecture Mismatch**
-
-go-micro's **core value proposition** is:
-
-> "Register any Go struct as a service handler without boilerplate"
-
-```go
-// This is go-micro's strength
-type EmailService struct {
-    mailer *smtp.Client
-}
-
-func (e *EmailService) Send(ctx context.Context, req *Email, rsp *Status) error {
-    return e.mailer.Send(req)
-}
-
-// Simple registration - no interfaces to implement
-server.Handle(server.NewHandler(&EmailService{}))
-```
-
-**With code generation (psrpc-style)**:
-
-```protobuf
-// Would require proto file
-service EmailService {
-  rpc Send(Email) returns (Status);
-}
-```
-
-```go
-// Must implement generated interface
-type emailServiceServer struct {
-    mailer *smtp.Client
-}
-
-func (e *emailServiceServer) Send(ctx context.Context, req *Email) (*Status, error) {
-    // Different signature - no *rsp parameter
-    return &Status{}, e.mailer.Send(req)
-}
-
-// Different registration
-RegisterEmailServiceServer(&emailServiceServer{...}, bus)
-```
-
-**Impact**: Complete API redesign, breaking change for all users.
-
-#### 2. **Go Generics Cannot Replace Runtime Type Discovery**
-
-Go generics (as of Go 1.24) require **compile-time type knowledge**:
-
-```go
-// IMPOSSIBLE: You can't iterate methods of T at runtime
-func RegisterHandler[T any](handler T) {
-    // Go generics can't do:
-    // - Iterate methods
-    // - Check method signatures
-    // - Call methods by name string
-    // - Create instances from types
-}
-```
-
-**Why**: Generics are a compile-time feature. go-micro needs runtime introspection of arbitrary user-defined types.
-
-#### 3. **Loss of Key Features**
-
-Features that **require reflection** and would be lost:
-
-1. **Dynamic endpoint discovery** - Building service registry metadata
-2. **API documentation generation** - Extracting request/response types  
-3. **Flexible handler signatures** - Supporting optional context, streaming
-4. **Pub/Sub handler validation** - Ensuring correct signatures
-5. **Cross-transport compatibility** - Same handler works with HTTP, gRPC, etc.
-
-#### 4. **Minimal Performance Benefit**
-
-Performance testing shows:
-
-- **Reflection overhead**: ~10-20% per RPC call
-- **Typical RPC includes**: Network I/O (1-10ms), serialization (100μs-1ms), business logic (variable)
-- **Reflection cost**: ~10-50μs
-
-**Example**: 
-- Total RPC time: 2ms
-- Reflection overhead: 20μs (1% of total)
-- Removing reflection saves: **1% latency improvement**
-
-For **99% of use cases**, network and serialization dominate. Reflection is negligible.
-
-#### 5. **Code Generation Complexity**
-
-To match go-micro's features with code generation:
-
-```
-User Handler → Proto Definition → protoc-gen-micro → Generated Code
-                  (manual)          (maintain)         (commit)
-```
-
-**Maintenance burden**:
-- Maintain protoc-gen-micro plugin (~2,000 LOC)
-- Users must install protoc toolchain
-- Every handler change requires regeneration
-- Generated code needs version control
-- Debugging involves generated code
-
-**Current simplicity**:
-```go
-// Just write Go code
-server.Handle(server.NewHandler(&MyService{}))
-```
-
-### What Would Be Required
-
-To remove reflection, go-micro would need:
-
-1. **Proto-first design** - All services defined in .proto files
-2. **Code generator** - Maintain protoc-gen-micro plugin
-3. **Generated interfaces** - Users implement generated stubs
-4. **Breaking changes** - Completely different API
-5. **Migration path** - Help users migrate existing services
-
-**Estimated effort**: 6-12 months, complete rewrite
-
-## Comparison with Similar Frameworks
-
-| Framework | Approach | Reflection |
-|-----------|----------|----------|
-| **go-micro** | Dynamic registration | Heavy use |
-| **gRPC-Go** | Proto + codegen | Protobuf reflection only |
-| **psrpc** | Proto + codegen | None |
-| **Twirp** | Proto + codegen | None |
-| **go-kit** | Manual interfaces | Minimal |
-| **Gin/Echo** | Manual routing | None (HTTP only) |
-
-**Insight**: RPC frameworks that avoid reflection **all require code generation**. There's no middle ground.
-
-## Performance Analysis
-
-### Benchmarks (Hypothetical)
-
-Based on reflection overhead patterns:
-
-| Metric | Current (Reflection) | After Removal (Hypothetical) | Improvement |
-|--------|---------------------|------------------------------|-------------|
-| Method dispatch | 10-50μs | 1-5μs | 5-10x |
-| Type construction | 5-20μs | 1-2μs | 5-10x |
-| Total per-RPC overhead | ~50μs | ~10μs | **5x faster** |
-
-**But in context**:
-
-| Component | Time |
-|-----------|------|
-| Network I/O | 1-10ms |
-| Protobuf marshal/unmarshal | 100-500μs |
-| Business logic | Variable (often milliseconds) |
-| **Reflection overhead** | **50μs (0.5-5% of total)** |
-
-### When Reflection Matters
-
-Reflection overhead is significant ONLY when:
-
-1. **Extremely high request rates** (>100k RPS)
-2. **Minimal business logic** (<100μs)
-3. **Local/loopback communication** (<100μs network)
-
-**Example use case**: In-process microservices with <1ms SLA.
-
-**For most users**: Database queries, external API calls, and business logic dominate.
-
-## Recommendations
-
-### Primary Recommendation: **DO NOT REMOVE REFLECTION**
-
-**Rationale**:
-1. **Architectural fit** - Reflection enables go-micro's core value proposition
-2. **Negligible impact** - Performance overhead is <5% in typical scenarios  
-3. **High risk** - Would break all existing code
-4. **High cost** - 6-12 month rewrite with ongoing maintenance burden
-5. **User experience** - Current API is simpler and more Go-idiomatic
-
-### Alternative Approaches
-
-If performance is critical for specific use cases:
-
-#### Option 1: **Hybrid Approach**
-
-Add **optional** code generation path:
-
-```go
-// Option A: Current reflection-based (simple)
-server.Handle(server.NewHandler(&MyService{}))
-
-// Option B: New codegen-based (fast)
-server.Handle(NewGeneratedMyServiceHandler(&MyService{}))
-```
-
-**Benefits**:
-- Backward compatible
-- Users opt-in for performance
-- Best of both worlds
-
-**Cost**: Maintain both paths
-
-#### Option 2: **Optimize Hot Paths**
-
-Keep reflection but optimize critical paths:
-
-```go
-// Cache reflect.Value to avoid repeated lookups
-type methodCache struct {
-    function reflect.Value
-    argType  reflect.Type
-    // Pre-allocate call arguments
-    callArgs [4]reflect.Value
-}
-```
-
-**Benefits**:
-- ~2-3x faster reflection
-- No API changes
-- Lower risk
-
-**Cost**: Internal refactoring only
-
-#### Option 3: **Document Performance Characteristics**
-
-Add documentation for users who need maximum performance:
-
-```markdown
-## Performance Considerations
-
-go-micro uses reflection for dynamic handler registration, which adds
-~50μs overhead per RPC call. For most applications this is negligible.
-
-If you need <100μs latency:
-- Consider gRPC with protocol buffers
-- Use direct client/server without service discovery
-- Benchmark your specific use case
-```
-
-**Benefits**:
-- Set correct expectations
-- Guide high-performance users
-- Zero implementation cost
-
-## Conclusion
-
-**Removing reflection from go-micro is technically infeasible** without a fundamental redesign that would:
-
-- Eliminate the framework's primary value proposition (simplicity)
-- Break all existing code
-- Require 6-12 months of development
-- Provide <5% performance improvement for 99% of users
-
-**Recommendation**: Close this issue with explanation that reflection is a deliberate architectural choice that enables go-micro's ease of use. For performance-critical applications, recommend:
-
-1. Profile first - ensure reflection is actually the bottleneck
-2. Consider gRPC or psrpc if code generation is acceptable
-3. Use go-micro's strengths for rapid development, then optimize specific services if needed
-
-The comparison with livekit/psrpc shows that avoiding reflection **requires** code generation and proto-first design, which is a completely different architecture incompatible with go-micro's goals.
-
-## References
-
-- [livekit/psrpc](https://github.com/livekit/psrpc) - Proto-based RPC without reflection
-- [Go Reflection Performance](https://go.dev/blog/laws-of-reflection) - Official Go blog
-- [Protocol Buffers](https://developers.google.com/protocol-buffers) - Google's data serialization
-- [gRPC-Go](https://github.com/grpc/grpc-go) - Code generation approach
-
-## Appendix: Reflection Usage Details
-
-### Files and Line Counts
-
-```bash
-$ grep -r "reflect\." server/*.go | wc -l
-312
-
-$ grep -r "reflect\.Value" server/*.go | wc -l
-87
-
-$ grep -r "reflect\.Type" server/*.go | wc -l
-64
-```
-
-### Hot Path Analysis
-
-Most frequently called reflection operations per request:
-
-1. `reflect.Value.Call()` - 1x per RPC (method invocation)
-2. `reflect.TypeOf()` - 1x per RPC (request validation)
-3. `reflect.New()` - 1-2x per RPC (request/response construction)
-4. `reflect.Value.Interface()` - 2-3x per RPC (type assertions)
-
-**Total reflection operations**: ~6-10 per RPC call
-
-### Memory Allocations
-
-Reflection introduces these allocations per request:
-
-- `[]reflect.Value` for Call() - 32 bytes + 4 pointers (64 bytes on 64-bit)
-- Reflect metadata lookups - amortized via caching
-- Interface conversions - 16 bytes each
-
-**Total per-request overhead**: ~150 bytes
-
-**Context**: Typical request + response protobuf: 100-10,000 bytes
-
-## Issue Resolution
-
-**Proposed Comment**:
-
-> After thorough analysis comparing go-micro with livekit/psrpc and evaluating the feasibility of removing reflection, we've determined this would require a fundamental architectural redesign incompatible with go-micro's goals.
->
-> **Key findings**:
-> 1. psrpc avoids reflection through **code generation** from proto files - a completely different architecture
-> 2. go-micro's strength is "register any struct" without boilerplate - this **requires** reflection
-> 3. Reflection overhead is ~50μs per RPC, typically <5% of total latency
-> 4. Removing reflection would be a breaking change requiring 6-12 months of development
->
-> **Recommendation**: Keep reflection as a deliberate design choice. For users needing maximum performance, recommend profiling first and considering gRPC/psrpc if code generation is acceptable.
->
-> See detailed analysis: [docs/reflection-removal-analysis.md](docs/reflection-removal-analysis.md)
->
-> Closing as "won't fix" - reflection is an intentional architectural decision that enables go-micro's simplicity and flexibility.

events/natsjs/nats.go

@@ -5,7 +5,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"io"
 	"strings"
 	"time"
 
@@ -36,12 +35,11 @@ func NewStream(opts ...Option) (events.Stream, error) {
 
 	s := &stream{opts: options}
 
-	conn, natsJetStreamCtx, err := connectToNatsJetStream(options)
+	natsJetStreamCtx, err := connectToNatsJetStream(options)
 	if err != nil {
 		return nil, fmt.Errorf("error connecting to nats cluster %v: %w", options.ClusterID, err)
 	}
 
-	s.conn = conn
 	s.natsJetStreamCtx = natsJetStreamCtx
 
 	return s, nil
@@ -49,11 +47,10 @@ func NewStream(opts ...Option) (events.Stream, error) {
 
 type stream struct {
 	opts             Options
-	conn             *nats.Conn           // store connection for lifecycle management
 	natsJetStreamCtx nats.JetStreamContext
 }
 
-func connectToNatsJetStream(options Options) (*nats.Conn, nats.JetStreamContext, error) {
+func connectToNatsJetStream(options Options) (nats.JetStreamContext, error) {
 	nopts := nats.GetDefaultOptions()
 	if options.TLSConfig != nil {
 		nopts.Secure = true
@@ -80,16 +77,15 @@ func connectToNatsJetStream(options Options) (*nats.Conn, nats.JetStreamContext,
 	conn, err := nopts.Connect()
 	if err != nil {
 		tls := nopts.TLSConfig != nil
-		return nil, nil, fmt.Errorf("error connecting to nats at %v with tls enabled (%v): %w", options.Address, tls, err)
+		return nil, fmt.Errorf("error connecting to nats at %v with tls enabled (%v): %w", options.Address, tls, err)
 	}
 
 	js, err := conn.JetStream()
 	if err != nil {
-		conn.Close() // Close connection if JetStream context fails
-		return nil, nil, fmt.Errorf("error while obtaining JetStream context: %w", err)
+		return nil, fmt.Errorf("error while obtaining JetStream context: %w", err)
 	}
 
-	return conn, js, nil
+	return js, nil
 }
 
 // Publish a message to a topic.
@@ -272,16 +268,3 @@ func (s *stream) Consume(topic string, opts ...events.ConsumeOption) (<-chan eve
 
 	return channel, nil
 }
-
-// Close implements io.Closer and closes the underlying NATS connection.
-// This method is optional but recommended to prevent connection leaks.
-func (s *stream) Close() error {
-	if s.conn != nil {
-		s.conn.Close()
-		s.conn = nil
-	}
-	return nil
-}
-
-// Ensure stream implements io.Closer
-var _ io.Closer = (*stream)(nil)

internal/website/_data/navigation.yml

@@ -3,8 +3,6 @@ core:
     url: /docs/
   - title: Getting Started
     url: /docs/getting-started.html
-  - title: Deployment
-    url: /docs/deployment.html
   - title: Architecture
     url: /docs/architecture.html
   - title: Configuration

internal/website/_layouts/blog.html

@@ -1,68 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>{% if page.title %}{{ page.title }} | {% endif %}Go Micro Blog</title>
-  <meta name="description" content="{{ page.description | default: 'Go Micro Blog - News, updates, and tutorials for the Go Micro framework' }}">
-  <style>
-    :root {
-      --bg: #ffffff;
-      --border: #e5e5e5;
-    }
-    * { box-sizing: border-box; }
-    body { font-family: system-ui,-apple-system,"Segoe UI",Roboto,"Helvetica Neue",Arial,sans-serif; margin:0; background: var(--bg); color:#222; line-height: 1.7; }
-    a { color:#0366d6; text-decoration:none; }
-    a:hover { text-decoration:underline; }
-    header { display:flex; align-items:center; justify-content:space-between; padding:.75rem 1.5rem; background:#fff; border-bottom:1px solid var(--border); position:sticky; top:0; z-index:20; }
-    .logo-link { display:flex; align-items:center; gap:.5rem; font-weight:600; color:#222; }
-    .logo-link img { height:36px; }
-    header nav { display:flex; align-items:center; gap: 1rem; }
-    header nav a { font-weight:500; }
-    .container { max-width: 720px; margin: 0 auto; padding: 2rem 1.5rem 4rem; }
-    .blog-header { margin-bottom: 2rem; padding-bottom: 1rem; border-bottom: 1px solid var(--border); }
-    .blog-header h1 { margin: 0 0 0.5rem; font-size: 2rem; }
-    .blog-header .meta { color: #666; font-size: 0.9rem; }
-    article h1 { font-size: 2.25rem; margin: 0 0 0.5rem; line-height: 1.3; }
-    article .meta { color: #666; font-size: 0.9rem; margin-bottom: 2rem; }
-    article h2 { font-size: 1.5rem; margin-top: 2.5rem; }
-    article h3 { font-size: 1.25rem; margin-top: 2rem; }
-    article p { margin: 1rem 0; }
-    article ul, article ol { margin: 1rem 0; padding-left: 1.5rem; }
-    article li { margin: 0.5rem 0; }
-    pre, code { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
-    pre { background:#f6f8fa; border:1px solid #d0d7de; padding:1rem; border-radius:6px; overflow-x:auto; font-size: 0.9rem; }
-    code { background: #f6f8fa; padding: 0.15rem 0.3rem; border-radius: 3px; font-size: 0.9em; }
-    pre code { background: none; padding: 0; }
-    blockquote { margin: 1.5rem 0; padding: 0.5rem 1rem; border-left: 4px solid #0366d6; background: #f6f8fa; }
-    blockquote p { margin: 0; }
-    .post-nav { margin-top: 3rem; padding-top: 1.5rem; border-top: 1px solid var(--border); display: flex; justify-content: space-between; font-size: 0.9rem; }
-    footer { max-width: 720px; margin: 0 auto; padding: 2rem 1.5rem; border-top: 1px solid var(--border); font-size: 0.8rem; color: #666; }
-    @media (max-width: 600px) {
-      .container { padding: 1.5rem 1rem; }
-      article h1 { font-size: 1.75rem; }
-      header { padding: 0.5rem 1rem; }
-      header nav { gap: 0.5rem; font-size: 0.9rem; }
-    }
-  </style>
-</head>
-<body>
-  <header>
-    <a class="logo-link" href="/">
-      <img src="/images/logo.png" alt="Go Micro Logo">
-      <span style="font-size: 1.3rem;">Go Micro</span>
-    </a>
-    <nav>
-      <a href="/blog/">Blog</a>
-      <a href="/docs/">Docs</a>
-      <a href="https://github.com/micro/go-micro" target="_blank">GitHub</a>
-    </nav>
-  </header>
-  <div class="container">
-    {{ content }}
-  </div>
-  <footer>
-    © {{ site.time | date: '%Y' }} Go Micro. Apache 2.0 Licensed.
-  </footer>
-</body>
-</html>

internal/website/_layouts/default.html

@@ -86,7 +86,6 @@
     </a>
     <button class="menu-toggle" id="menuToggle">☰ Menu</button>
     <nav>
-      <a href="/blog/">Blog</a>
       <a href="/docs/">Docs</a>
       <a href="/docs/search.html">Search</a>
       <a href="https://github.com/micro/go-micro" target="_blank" rel="noopener">GitHub</a>
@@ -152,7 +151,7 @@
     </main>
   </div>
   <footer>
-    © {{ site.time | date: '%Y' }} Go Micro. Apache 2.0 Licensed. <a href="/blog/">Blog</a> · <a href="/docs/">Docs</a> · <a href="/docs/search.html">Search</a> · <a href="https://github.com/micro/go-micro">GitHub</a> · <a href="https://github.com/micro/go-micro/issues/new?labels=question&template=question.md" style="opacity:0.7">Support</a>
+    © {{ site.time | date: '%Y' }} Go Micro. Apache 2.0 Licensed. <a href="/docs/">Docs</a> · <a href="/docs/search.html">Search</a> · <a href="https://github.com/micro/go-micro">GitHub</a> · <a href="https://github.com/micro/go-micro/issues/new?labels=question&template=question.md" style="opacity:0.7">Support</a>
   </footer>
   <script>
   (function(){

internal/website/blog/1.md

@@ -1,131 +0,0 @@
----
-layout: blog
-title: Introducing micro deploy
-permalink: /blog/1
-description: Deploy your Go Micro services to any Linux server with a single command
----
-
-# Introducing micro deploy
-
-*January 27, 2026 • By the Go Micro Team*
-
-We're excited to announce **micro deploy** in Go Micro v5.13.0 — a simple way to deploy your services to any Linux server.
-
-## The Problem
-
-Go Micro has always been great for building microservices:
-
-```bash
-micro new myservice
-cd myservice
-micro run
-```
-
-But getting those services to production? That was on you. You'd need to figure out Docker, Kubernetes, or write your own deployment scripts.
-
-We tried to solve this with Micro v3 — a full platform-as-a-service. But it was too much. Too complex. Nobody wanted another platform to manage.
-
-## The Solution
-
-The new approach is simple: **systemd + SSH**.
-
-Every Linux server has systemd. It's battle-tested, it manages processes, it restarts them when they crash, it handles logging. Why reinvent it?
-
-### One-Time Server Setup
-
-```bash
-ssh user@server
-curl -fsSL https://go-micro.dev/install.sh | sh
-sudo micro init --server
-```
-
-This creates:
-- `/opt/micro/bin/` — where your binaries live
-- `/opt/micro/config/` — environment files
-- A systemd template for managing services
-
-### Deploy
-
-```bash
-micro deploy user@server
-```
-
-That's it. The command:
-1. Builds your services for Linux
-2. Copies binaries via SSH
-3. Configures systemd services
-4. Verifies everything is running
-
-### Manage
-
-```bash
-micro status --remote user@server
-micro logs --remote user@server
-micro logs myservice --remote user@server -f
-```
-
-## Named Deploy Targets
-
-Add deploy targets to your `micro.mu`:
-
-```
-service users
-    path ./users
-    port 8081
-
-service web
-    path ./web
-    port 8080
-
-deploy prod
-    ssh deploy@prod.example.com
-
-deploy staging
-    ssh deploy@staging.example.com
-```
-
-Then:
-
-```bash
-micro deploy prod
-micro deploy staging
-```
-
-## Philosophy
-
-- **systemd is the standard** — don't fight it, use it
-- **SSH is the transport** — no custom agents or protocols
-- **Errors guide you** — every failure tells you how to fix it
-- **No platform** — just your server, your services
-
-## What's Next?
-
-This is just the beginning. We're thinking about:
-
-- **Secrets management** — integrating with vault/sops
-- **Multi-server deploys** — deploy to a fleet
-- **Metrics** — Prometheus endpoints out of the box
-- **Rolling updates** — zero-downtime deployments
-
-## Try It
-
-```bash
-go install go-micro.dev/v5/cmd/micro@v5.13.0
-micro new myapp
-cd myapp
-micro run
-
-# When you're ready to deploy:
-micro deploy user@your-server
-```
-
-See the [deployment guide](/docs/deployment.html) for full documentation.
-
----
-
-*Go Micro is an open source framework for distributed systems development in Go. [Star us on GitHub](https://github.com/micro/go-micro).*
-
-<div class="post-nav">
-  <div><a href="/blog/">← All Posts</a></div>
-  <div></div>
-</div>

internal/website/blog/index.html

@@ -1,19 +0,0 @@
----
-layout: blog
-title: Blog
-permalink: /blog/
----
-
-<div class="blog-header">
-  <h1>Go Micro Blog</h1>
-  <p class="meta">News, updates, and tutorials for Go Micro</p>
-</div>
-
-<div class="posts">
-  <article style="margin-bottom: 2rem; padding-bottom: 1.5rem; border-bottom: 1px solid #e5e5e5;">
-    <h2 style="margin: 0 0 0.5rem;"><a href="/blog/1">Introducing micro deploy</a></h2>
-    <p class="meta" style="color: #666; font-size: 0.85rem;">January 27, 2026</p>
-    <p>Deploy your Go Micro services to any Linux server with a single command. No Docker, no Kubernetes, no platform — just systemd.</p>
-    <a href="/blog/1">Read more →</a>
-  </article>
-</div>

internal/website/docs/deployment.md

@@ -1,349 +0,0 @@
----
-layout: default
-title: Deployment
----
-
-# Deploying Go Micro Services
-
-This guide covers deploying go-micro services to a Linux server using systemd.
-
-## Overview
-
-go-micro provides a simple deployment workflow:
-
-1. **Develop locally** with `micro run`
-2. **Build binaries** with `micro build`
-3. **Deploy to server** with `micro deploy`
-
-On the server, services are managed by systemd - the standard Linux process supervisor.
-
-## Quick Start
-
-### 1. Prepare Your Server
-
-On your server (Ubuntu, Debian, or any systemd-based Linux):
-
-```bash
-# Install micro
-curl -fsSL https://go-micro.dev/install.sh | sh
-
-# Initialize for deployment
-sudo micro init --server
-```
-
-This creates:
-- `/opt/micro/bin/` - where service binaries live
-- `/opt/micro/data/` - persistent data directory
-- `/opt/micro/config/` - environment files
-- systemd template for managing services
-
-### 2. Deploy from Your Machine
-
-```bash
-# From your project directory
-micro deploy user@your-server
-```
-
-That's it! The deploy command:
-1. Builds your services for Linux
-2. Copies binaries to the server
-3. Configures and starts systemd services
-4. Verifies everything is running
-
-## Detailed Setup
-
-### Server Requirements
-
-- Linux with systemd (Ubuntu 16.04+, Debian 8+, CentOS 7+, etc.)
-- SSH access
-- Go installed (only if building on server)
-
-### Server Initialization Options
-
-```bash
-# Basic setup (creates 'micro' user)
-sudo micro init --server
-
-# Custom installation path
-sudo micro init --server --path /home/deploy/micro
-
-# Run services as existing user
-sudo micro init --server --user deploy
-
-# Initialize remotely (from your laptop)
-micro init --server --remote user@your-server
-```
-
-### What Gets Created
-
-**Directories:**
-```
-/opt/micro/
-├── bin/      # Service binaries
-├── data/     # Persistent data (databases, files)
-└── config/   # Environment files (*.env)
-```
-
-**Systemd Template** (`/etc/systemd/system/micro@.service`):
-```ini
-[Unit]
-Description=Micro service: %i
-After=network.target
-
-[Service]
-Type=simple
-User=micro
-WorkingDirectory=/opt/micro
-ExecStart=/opt/micro/bin/%i
-Restart=on-failure
-RestartSec=5
-EnvironmentFile=-/opt/micro/config/%i.env
-
-[Install]
-WantedBy=multi-user.target
-```
-
-The `%i` is replaced with the service name. So `micro@users.service` runs `/opt/micro/bin/users`.
-
-## Deployment
-
-### Basic Deploy
-
-```bash
-micro deploy user@server
-```
-
-### Deploy Specific Service
-
-```bash
-micro deploy user@server --service users
-```
-
-### Force Rebuild
-
-```bash
-micro deploy user@server --build
-```
-
-### Named Deploy Targets
-
-Add to your `micro.mu`:
-
-```
-service users
-    path ./users
-    port 8081
-
-service web
-    path ./web
-    port 8080
-
-deploy prod
-    ssh deploy@prod.example.com
-
-deploy staging
-    ssh deploy@staging.example.com
-```
-
-Then:
-```bash
-micro deploy prod      # deploys to prod.example.com
-micro deploy staging   # deploys to staging.example.com
-```
-
-## Managing Services
-
-### Check Status
-
-```bash
-# Local services
-micro status
-
-# Remote services
-micro status --remote user@server
-```
-
-Output:
-```
-server.example.com
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  users    ● running    pid 1234
-  posts    ● running    pid 1235
-  web      ● running    pid 1236
-```
-
-### View Logs
-
-```bash
-# All services
-micro logs --remote user@server
-
-# Specific service
-micro logs users --remote user@server
-
-# Follow logs
-micro logs users --remote user@server -f
-```
-
-### Stop Services
-
-```bash
-micro stop users --remote user@server
-```
-
-### Direct systemctl Access
-
-You can also manage services directly on the server:
-
-```bash
-# Status
-sudo systemctl status micro@users
-
-# Restart
-sudo systemctl restart micro@users
-
-# Stop
-sudo systemctl stop micro@users
-
-# Logs
-journalctl -u micro@users -f
-```
-
-## Environment Variables
-
-Create environment files at `/opt/micro/config/<service>.env`:
-
-```bash
-# /opt/micro/config/users.env
-DATABASE_URL=postgres://localhost/users
-REDIS_URL=redis://localhost:6379
-LOG_LEVEL=info
-```
-
-These are automatically loaded by systemd when the service starts.
-
-## SSH Setup
-
-### Key-Based Authentication
-
-```bash
-# Generate key (if you don't have one)
-ssh-keygen -t ed25519
-
-# Copy to server
-ssh-copy-id user@server
-```
-
-### SSH Config
-
-Add to `~/.ssh/config`:
-
-```
-Host prod
-    HostName prod.example.com
-    User deploy
-    IdentityFile ~/.ssh/deploy_key
-
-Host staging
-    HostName staging.example.com
-    User deploy
-    IdentityFile ~/.ssh/deploy_key
-```
-
-Then deploy with:
-```bash
-micro deploy prod
-```
-
-## Troubleshooting
-
-### "Cannot connect to server"
-
-```
-✗ Cannot connect to myserver
-
-  SSH connection failed. Check that:
-  • The server is reachable: ping myserver
-  • SSH is configured: ssh user@myserver
-  • Your key is added: ssh-add -l
-```
-
-**Fix:**
-```bash
-# Test SSH connection
-ssh user@server
-
-# Add SSH key
-ssh-copy-id user@server
-
-# Check SSH agent
-eval $(ssh-agent)
-ssh-add
-```
-
-### "Server not initialized"
-
-```
-✗ Server not initialized
-
-  micro is not set up on myserver.
-```
-
-**Fix:**
-```bash
-ssh user@server 'sudo micro init --server'
-```
-
-### "Service failed to start"
-
-Check the logs:
-```bash
-micro logs myservice --remote user@server
-
-# Or on the server:
-journalctl -u micro@myservice -n 50
-```
-
-Common causes:
-- Missing environment variables
-- Port already in use
-- Database not reachable
-- Binary permissions issue
-
-### "Permission denied"
-
-Ensure your user can write to `/opt/micro/bin/`:
-
-```bash
-# On server
-sudo chown -R deploy:deploy /opt/micro
-
-# Or add user to micro group
-sudo usermod -aG micro deploy
-```
-
-## Security Best Practices
-
-1. **Use a dedicated deploy user** - Don't deploy as root
-2. **Use SSH keys** - Disable password authentication
-3. **Restrict sudo** - Only allow necessary commands
-4. **Firewall** - Only expose needed ports
-5. **Secrets** - Use environment files with restricted permissions (0600)
-
-### Minimal sudo access
-
-Add to `/etc/sudoers.d/micro`:
-```
-deploy ALL=(ALL) NOPASSWD: /bin/systemctl daemon-reload
-deploy ALL=(ALL) NOPASSWD: /bin/systemctl enable micro@*
-deploy ALL=(ALL) NOPASSWD: /bin/systemctl restart micro@*
-deploy ALL=(ALL) NOPASSWD: /bin/systemctl stop micro@*
-deploy ALL=(ALL) NOPASSWD: /bin/systemctl status micro@*
-```
-
-## Next Steps
-
-- [micro run](./micro-run.md) - Local development
-- [micro.mu configuration](./config.md) - Configuration file format
-- [Health checks](./health.md) - Service health endpoints

internal/website/docs/getting-started.md

@@ -110,11 +110,9 @@ If you want to define services with protobuf you can use protoc-gen-micro (go-mi
 Install the generator:
 
 ```bash
-go install go-micro.dev/v5/cmd/protoc-gen-micro@v5.13.0
+go install go-micro.dev/v5/cmd/protoc-gen-micro@latest
 ```
 
-> **Note:** Use a specific version instead of `@latest` to avoid module path conflicts. See [releases](https://github.com/micro/go-micro/releases) for the latest version.
-
 ```bash
 cd helloworld
 mkdir proto
@@ -224,11 +222,9 @@ func main() {
 Install the Micro CLI:
 
 ```
-go install go-micro.dev/v5/cmd/micro@v5.13.0
+go install go-micro.dev/v5/cmd/micro@latest
 ```
 
-> **Note:** Use a specific version instead of `@latest` to avoid module path conflicts. See [releases](https://github.com/micro/go-micro/releases) for the latest version.
-
 Call a running service via RPC:
 
 ```

internal/website/docs/guides/grpc-compatibility.md

@@ -88,7 +88,7 @@ message Response {
 
 ```bash
 # Install protoc-gen-micro
-go install go-micro.dev/v5/cmd/protoc-gen-micro@v5.13.0
+go install go-micro.dev/v5/cmd/protoc-gen-micro@latest
 
 # Generate Go code
 protoc --proto_path=. \
@@ -97,8 +97,6 @@ protoc --proto_path=. \
     proto/helloworld.proto
 ```
 
-> **Note:** Use a specific version instead of `@latest` to avoid module path conflicts. See [releases](https://github.com/micro/go-micro/releases) for the latest version.
-
 ### Server Implementation
 
 ```go

internal/website/docs/guides/migration/from-grpc.md

@@ -90,7 +90,7 @@ Update your proto generation:
 
 ```bash
 # Install protoc-gen-micro
-go install go-micro.dev/v5/cmd/protoc-gen-micro@v5.13.0
+go install go-micro.dev/v5/cmd/protoc-gen-micro@latest
 
 # Generate both gRPC and Go Micro code
 protoc --proto_path=. \
@@ -100,8 +100,6 @@ protoc --proto_path=. \
   proto/hello.proto
 ```
 
-> **Note:** Use a specific version instead of `@latest` to avoid module path conflicts. See [releases](https://github.com/micro/go-micro/releases) for the latest version.
-
 This generates:
 - `hello.pb.go` - Protocol Buffers types
 - `hello_grpc.pb.go` - gRPC client/server (keep for compatibility)

internal/website/docs/server.md

@@ -11,11 +11,9 @@ The Micro server is an optional API and dashboard that provides a fixed entrypoi
 Install the CLI which includes the server command:
 
 ```bash
-go install go-micro.dev/v5/cmd/micro@v5.13.0
+go install go-micro.dev/v5/cmd/micro@latest
 ```
 
-> **Note:** Use a specific version instead of `@latest` to avoid module path conflicts. See [releases](https://github.com/micro/go-micro/releases) for the latest version.
-
 ## Run
 
 Start the server:

internal/website/index.html

@@ -251,9 +251,9 @@
       
       <div class="links">
         <a href="docs/" class="primary">Documentation</a>
-        <a href="blog/" class="secondary">Blog</a>
         <a href="https://github.com/micro/go-micro" class="secondary">GitHub</a>
         <a href="https://pkg.go.dev/go-micro.dev/v5" class="secondary">Reference</a>
+        <a href="badge.html" class="secondary">Get Badge</a>
       </div>
       
       <div class="showcase">

internal/website/install.sh

@@ -1,75 +0,0 @@
-#!/bin/bash
-# Install script for micro CLI
-# Usage: curl -fsSL https://go-micro.dev/install.sh | sh
-
-set -e
-
-VERSION="${MICRO_VERSION:-latest}"
-OS=$(uname -s | tr '[:upper:]' '[:lower:]')
-ARCH=$(uname -m)
-
-# Normalize architecture
-case $ARCH in
-    x86_64|amd64) ARCH="amd64" ;;
-    aarch64|arm64) ARCH="arm64" ;;
-    armv7l) ARCH="arm" ;;
-    *) echo "Unsupported architecture: $ARCH"; exit 1 ;;
-esac
-
-# Normalize OS
-case $OS in
-    darwin) OS="darwin" ;;
-    linux) OS="linux" ;;
-    *) echo "Unsupported OS: $OS"; exit 1 ;;
-esac
-
-# Determine install directory
-if [ "$EUID" -eq 0 ] || [ "$(id -u)" -eq 0 ]; then
-    INSTALL_DIR="/usr/local/bin"
-else
-    INSTALL_DIR="$HOME/.local/bin"
-    mkdir -p "$INSTALL_DIR"
-fi
-
-echo "Installing micro ${VERSION} for ${OS}/${ARCH}..."
-
-# Download URL
-if [ "$VERSION" = "latest" ]; then
-    URL="https://github.com/micro/go-micro/releases/latest/download/micro-${OS}-${ARCH}"
-else
-    URL="https://github.com/micro/go-micro/releases/download/${VERSION}/micro-${OS}-${ARCH}"
-fi
-
-# Download
-TMP_FILE=$(mktemp)
-if command -v curl &> /dev/null; then
-    curl -fsSL "$URL" -o "$TMP_FILE"
-elif command -v wget &> /dev/null; then
-    wget -q "$URL" -O "$TMP_FILE"
-else
-    echo "Error: curl or wget required"
-    exit 1
-fi
-
-# Install
-chmod +x "$TMP_FILE"
-mv "$TMP_FILE" "$INSTALL_DIR/micro"
-
-echo ""
-echo "✓ Installed micro to $INSTALL_DIR/micro"
-echo ""
-
-# Verify
-if command -v micro &> /dev/null; then
-    micro --version
-else
-    echo "Note: Add $INSTALL_DIR to your PATH:"
-    echo "  export PATH=\"\$PATH:$INSTALL_DIR\""
-fi
-
-echo ""
-echo "Get started:"
-echo "  micro new myservice    # Create a new service"
-echo "  micro run              # Run locally"
-echo "  micro deploy           # Deploy to server"
-echo ""

registry/cache/cache.go

@@ -159,22 +159,14 @@ func (c *cache) get(service string) ([]*registry.Service, error) {
 		return cp, nil
 	}
 
-	// Check rate limiting BEFORE entering singleflight
-	// This prevents blocking when we have stale cache and etcd is down
+	// Check rate limiting before unlocking
+	// This prevents multiple sequential attempts within the retry interval
 	lastRefresh := c.lastRefreshAttempt[service]
 	minimumRetryInterval := c.opts.MinimumRetryInterval
 	if minimumRetryInterval == 0 {
 		minimumRetryInterval = DefaultMinimumRetryInterval
 	}
 
-	// If we're being rate limited AND have stale cache, return it immediately
-	// This avoids blocking all goroutines when etcd has long timeout
-	if !lastRefresh.IsZero() && time.Since(lastRefresh) < minimumRetryInterval && len(cp) > 0 {
-		c.RUnlock()
-		// Return stale cache even if expired
-		return cp, nil
-	}
-
 	// unlock the read lock before potentially blocking operations
 	c.RUnlock()
 
@@ -183,18 +175,8 @@ func (c *cache) get(service string) ([]*registry.Service, error) {
 		// Use singleflight to deduplicate concurrent requests
 		val, err, _ := c.sg.Do(service, func() (interface{}, error) {
 			// Inside singleflight - only one goroutine executes this
-			
-			// Re-check rate limiting inside singleflight
-			// (in case another goroutine just completed a refresh)
-			c.RLock()
-			currentLastRefresh := c.lastRefreshAttempt[service]
-			currentMinimumRetryInterval := c.opts.MinimumRetryInterval
-			if currentMinimumRetryInterval == 0 {
-				currentMinimumRetryInterval = DefaultMinimumRetryInterval
-			}
-			c.RUnlock()
-			
-			if !currentLastRefresh.IsZero() && time.Since(currentLastRefresh) < currentMinimumRetryInterval {
+			// Apply rate limiting to prevent excessive registry calls
+			if !lastRefresh.IsZero() && time.Since(lastRefresh) < minimumRetryInterval {
 				// We're being rate limited
 				// Check if we have stale cache to return
 				c.RLock()

transport/nats/nats.go

@@ -16,25 +16,19 @@ import (
 )
 
 type ntport struct {
-	addrs           []string
-	opts            transport.Options
-	nopts           nats.Options
-	pool            *connectionPool  // connection pool for clients
-	poolSize        int
-	poolIdleTimeout time.Duration
-	mu              sync.RWMutex
+	addrs []string
+	opts  transport.Options
+	nopts nats.Options
 }
 
 type ntportClient struct {
-	conn       *nats.Conn
-	pooledConn *pooledConnection  // reference to pooled connection if using pool
-	pool       *connectionPool    // reference to pool to return connection on close
-	addr       string
-	id         string
-	local      string
-	remote     string
-	sub        *nats.Subscription
-	opts       transport.Options
+	conn   *nats.Conn
+	addr   string
+	id     string
+	local  string
+	remote string
+	sub    *nats.Subscription
+	opts   transport.Options
 }
 
 type ntportSocket struct {
@@ -73,20 +67,8 @@ func configure(n *ntport, opts ...transport.Option) {
 	}
 
 	natsOptions := nats.GetDefaultOptions()
-	if no, ok := n.opts.Context.Value(optionsKey{}).(nats.Options); ok {
-		natsOptions = no
-	}
-
-	// Set pool size (default is 1 - no pooling)
-	n.poolSize = 1
-	if poolSize, ok := n.opts.Context.Value(poolSizeKey{}).(int); ok && poolSize > 0 {
-		n.poolSize = poolSize
-	}
-
-	// Set pool idle timeout (default is 5 minutes)
-	n.poolIdleTimeout = 5 * time.Minute
-	if idleTimeout, ok := n.opts.Context.Value(poolIdleTimeoutKey{}).(time.Duration); ok {
-		n.poolIdleTimeout = idleTimeout
+	if n, ok := n.opts.Context.Value(optionsKey{}).(nats.Options); ok {
+		natsOptions = n
 	}
 
 	// transport.Options have higher priority than nats.Options
@@ -109,31 +91,6 @@ func configure(n *ntport, opts ...transport.Option) {
 	n.opts.Addrs = setAddrs(n.opts.Addrs)
 	n.nopts = natsOptions
 	n.addrs = n.opts.Addrs
-
-	// Initialize connection pool if size > 1
-	if n.poolSize > 1 && n.pool == nil {
-		factory := func() (*nats.Conn, error) {
-			opts := n.nopts
-			opts.Servers = n.addrs
-			opts.Secure = n.opts.Secure
-			opts.TLSConfig = n.opts.TLSConfig
-
-			// secure might not be set
-			if n.opts.TLSConfig != nil {
-				opts.Secure = true
-			}
-
-			return opts.Connect()
-		}
-
-		pool, err := newConnectionPool(n.poolSize, factory)
-		if err == nil {
-			if n.poolIdleTimeout > 0 {
-				pool.idleTimeout = n.poolIdleTimeout
-			}
-			n.pool = pool
-		}
-	}
 }
 
 func setAddrs(addrs []string) []string {
@@ -209,13 +166,6 @@ func (n *ntportClient) Recv(m *transport.Message) error {
 
 func (n *ntportClient) Close() error {
 	n.sub.Unsubscribe()
-
-	// If using a pooled connection, return it to the pool
-	if n.pool != nil && n.pooledConn != nil {
-		return n.pool.Put(n.pooledConn)
-	}
-
-	// Otherwise, close the connection directly
 	n.conn.Close()
 	return nil
 }
@@ -394,68 +344,37 @@ func (n *ntport) Dial(addr string, dialOpts ...transport.DialOption) (transport.
 		o(&dopts)
 	}
 
-	var c *nats.Conn
-	var pooledConn *pooledConnection
-	var err error
+	opts := n.nopts
+	opts.Servers = n.addrs
+	opts.Secure = n.opts.Secure
+	opts.TLSConfig = n.opts.TLSConfig
+	opts.Timeout = dopts.Timeout
 
-	// Use connection pool if available
-	n.mu.RLock()
-	hasPool := n.pool != nil
-	n.mu.RUnlock()
+	// secure might not be set
+	if n.opts.TLSConfig != nil {
+		opts.Secure = true
+	}
 
-	if hasPool {
-		pooledConn, err = n.pool.Get()
-		if err != nil {
-			return nil, err
-		}
-		c = pooledConn.Conn()
-		if c == nil {
-			n.pool.Put(pooledConn)
-			return nil, errors.New("invalid connection from pool")
-		}
-	} else {
-		// Create a new connection (original behavior)
-		opts := n.nopts
-		opts.Servers = n.addrs
-		opts.Secure = n.opts.Secure
-		opts.TLSConfig = n.opts.TLSConfig
-		opts.Timeout = dopts.Timeout
-
-		// secure might not be set
-		if n.opts.TLSConfig != nil {
-			opts.Secure = true
-		}
-
-		c, err = opts.Connect()
-		if err != nil {
-			return nil, err
-		}
+	c, err := opts.Connect()
+	if err != nil {
+		return nil, err
 	}
 
 	id := nats.NewInbox()
 	sub, err := c.SubscribeSync(id)
 	if err != nil {
-		if pooledConn != nil {
-			n.pool.Put(pooledConn)
-		} else {
-			c.Close()
-		}
 		return nil, err
 	}
 
-	client := &ntportClient{
-		conn:       c,
-		pooledConn: pooledConn,
-		pool:       n.pool,
-		addr:       addr,
-		id:         id,
-		sub:        sub,
-		opts:       n.opts,
-		local:      id,
-		remote:     addr,
-	}
-
-	return client, nil
+	return &ntportClient{
+		conn:   c,
+		addr:   addr,
+		id:     id,
+		sub:    sub,
+		opts:   n.opts,
+		local:  id,
+		remote: addr,
+	}, nil
 }
 
 func (n *ntport) Listen(addr string, listenOpts ...transport.ListenOption) (transport.Listener, error) {

transport/nats/options.go

@@ -2,15 +2,12 @@ package nats
 
 import (
 	"context"
-	"time"
 
 	"github.com/nats-io/nats.go"
 	"go-micro.dev/v5/transport"
 )
 
 type optionsKey struct{}
-type poolSizeKey struct{}
-type poolIdleTimeoutKey struct{}
 
 // Options allow to inject a nats.Options struct for configuring
 // the nats connection.
@@ -22,27 +19,3 @@ func Options(nopts nats.Options) transport.Option {
 		o.Context = context.WithValue(o.Context, optionsKey{}, nopts)
 	}
 }
-
-// PoolSize sets the size of the connection pool.
-// If set to a value > 1, the transport will use a connection pool.
-// Default is 1 (no pooling).
-func PoolSize(size int) transport.Option {
-	return func(o *transport.Options) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		o.Context = context.WithValue(o.Context, poolSizeKey{}, size)
-	}
-}
-
-// PoolIdleTimeout sets the timeout for idle connections in the pool.
-// Connections idle for longer than this duration will be closed.
-// Default is 5 minutes. Set to 0 to disable idle timeout.
-func PoolIdleTimeout(timeout time.Duration) transport.Option {
-	return func(o *transport.Options) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		o.Context = context.WithValue(o.Context, poolIdleTimeoutKey{}, timeout)
-	}
-}

transport/nats/pool.go

@@ -1,188 +0,0 @@
-package nats
-
-import (
-	"errors"
-	"sync"
-	"time"
-
-	natsp "github.com/nats-io/nats.go"
-)
-
-var (
-	// ErrPoolExhausted is returned when no connections are available in the pool
-	ErrPoolExhausted = errors.New("connection pool exhausted")
-	// ErrPoolClosed is returned when trying to use a closed pool
-	ErrPoolClosed = errors.New("connection pool is closed")
-)
-
-// connectionPool manages a pool of NATS connections
-type connectionPool struct {
-	mu          sync.RWMutex
-	connections chan *pooledConnection
-	factory     func() (*natsp.Conn, error)
-	size        int
-	idleTimeout time.Duration
-	closed      bool
-}
-
-// pooledConnection wraps a NATS connection with metadata
-type pooledConnection struct {
-	conn      *natsp.Conn
-	createdAt time.Time
-	lastUsed  time.Time
-	mu        sync.Mutex
-}
-
-// newConnectionPool creates a new connection pool
-func newConnectionPool(size int, factory func() (*natsp.Conn, error)) (*connectionPool, error) {
-	if size <= 0 {
-		size = 1
-	}
-
-	pool := &connectionPool{
-		connections: make(chan *pooledConnection, size),
-		factory:     factory,
-		size:        size,
-		idleTimeout: 5 * time.Minute,
-		closed:      false,
-	}
-
-	return pool, nil
-}
-
-// Get retrieves a connection from the pool or creates a new one
-func (p *connectionPool) Get() (*pooledConnection, error) {
-	p.mu.RLock()
-	if p.closed {
-		p.mu.RUnlock()
-		return nil, ErrPoolClosed
-	}
-	p.mu.RUnlock()
-
-	// Try to get an existing connection from the pool
-	select {
-	case conn := <-p.connections:
-		// Check if connection is still valid and not idle for too long
-		if conn.isValid() && !conn.isExpired(p.idleTimeout) {
-			conn.updateLastUsed()
-			return conn, nil
-		}
-		// Connection is invalid or expired, close it and create a new one
-		conn.close()
-		return p.createConnection()
-	default:
-		// No connection available, create a new one
-		return p.createConnection()
-	}
-}
-
-// Put returns a connection to the pool
-func (p *connectionPool) Put(conn *pooledConnection) error {
-	p.mu.RLock()
-	defer p.mu.RUnlock()
-
-	if p.closed {
-		return conn.close()
-	}
-
-	// Check if connection is still valid
-	if !conn.isValid() {
-		return conn.close()
-	}
-
-	conn.updateLastUsed()
-
-	// Try to return connection to pool
-	select {
-	case p.connections <- conn:
-		return nil
-	default:
-		// Pool is full, close the connection
-		return conn.close()
-	}
-}
-
-// Close closes all connections in the pool
-func (p *connectionPool) Close() error {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-
-	if p.closed {
-		return nil
-	}
-
-	p.closed = true
-	close(p.connections)
-
-	// Close all connections in the pool
-	for conn := range p.connections {
-		conn.close()
-	}
-
-	return nil
-}
-
-// createConnection creates a new pooled connection
-func (p *connectionPool) createConnection() (*pooledConnection, error) {
-	conn, err := p.factory()
-	if err != nil {
-		return nil, err
-	}
-
-	return &pooledConnection{
-		conn:      conn,
-		createdAt: time.Now(),
-		lastUsed:  time.Now(),
-	}, nil
-}
-
-// isValid checks if the underlying NATS connection is valid
-func (pc *pooledConnection) isValid() bool {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	if pc.conn == nil {
-		return false
-	}
-
-	status := pc.conn.Status()
-	return status == natsp.CONNECTED || status == natsp.RECONNECTING
-}
-
-// isExpired checks if the connection has been idle for too long
-func (pc *pooledConnection) isExpired(timeout time.Duration) bool {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	if timeout <= 0 {
-		return false
-	}
-
-	return time.Since(pc.lastUsed) > timeout
-}
-
-// close closes the underlying NATS connection
-func (pc *pooledConnection) close() error {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	if pc.conn != nil {
-		pc.conn.Close()
-		pc.conn = nil
-	}
-	return nil
-}
-
-// Conn returns the underlying NATS connection
-func (pc *pooledConnection) Conn() *natsp.Conn {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-	return pc.conn
-}
-
-// updateLastUsed updates the last used timestamp in a thread-safe manner
-func (pc *pooledConnection) updateLastUsed() {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-	pc.lastUsed = time.Now()
-}

transport/nats/pool_test.go

@@ -1,170 +0,0 @@
-package nats
-
-import (
-	"sync"
-	"testing"
-	"time"
-
-	natsp "github.com/nats-io/nats.go"
-)
-
-func TestTransportConnectionPool_GetPut(t *testing.T) {
-	// Mock factory that creates connections
-	connCount := 0
-	factory := func() (*natsp.Conn, error) {
-		connCount++
-		return nil, nil
-	}
-
-	pool, err := newConnectionPool(3, factory)
-	if err != nil {
-		t.Fatalf("Failed to create pool: %v", err)
-	}
-	defer pool.Close()
-
-	// Get a connection (should create one)
-	conn1, err := pool.Get()
-	if err != nil {
-		t.Fatalf("Failed to get connection: %v", err)
-	}
-	if conn1 == nil {
-		t.Fatal("Expected connection, got nil")
-	}
-
-	// Put it back
-	if err := pool.Put(conn1); err != nil {
-		t.Fatalf("Failed to put connection: %v", err)
-	}
-
-	// Get it again (should reuse the same one)
-	conn2, err := pool.Get()
-	if err != nil {
-		t.Fatalf("Failed to get connection: %v", err)
-	}
-
-	if conn2 == nil {
-		t.Fatal("Expected connection, got nil")
-	}
-}
-
-func TestTransportConnectionPool_Concurrent(t *testing.T) {
-	connCount := 0
-	mu := sync.Mutex{}
-	factory := func() (*natsp.Conn, error) {
-		mu.Lock()
-		connCount++
-		mu.Unlock()
-		return nil, nil
-	}
-
-	pool, err := newConnectionPool(5, factory)
-	if err != nil {
-		t.Fatalf("Failed to create pool: %v", err)
-	}
-	defer pool.Close()
-
-	// Simulate concurrent access
-	var wg sync.WaitGroup
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			conn, err := pool.Get()
-			if err != nil {
-				t.Errorf("Failed to get connection: %v", err)
-				return
-			}
-			// Simulate some work
-			time.Sleep(10 * time.Millisecond)
-			if err := pool.Put(conn); err != nil {
-				t.Errorf("Failed to put connection: %v", err)
-			}
-		}()
-	}
-
-	wg.Wait()
-
-	// We should have created some connections
-	mu.Lock()
-	if connCount == 0 {
-		t.Error("Expected at least one connection to be created")
-	}
-	mu.Unlock()
-}
-
-func TestTransportConnectionPool_Close(t *testing.T) {
-	factory := func() (*natsp.Conn, error) {
-		return nil, nil
-	}
-
-	pool, err := newConnectionPool(3, factory)
-	if err != nil {
-		t.Fatalf("Failed to create pool: %v", err)
-	}
-
-	// Get a connection
-	conn, err := pool.Get()
-	if err != nil {
-		t.Fatalf("Failed to get connection: %v", err)
-	}
-
-	// Close the pool
-	if err := pool.Close(); err != nil {
-		t.Fatalf("Failed to close pool: %v", err)
-	}
-
-	// Put connection back to closed pool should not panic
-	_ = pool.Put(conn)
-
-	// Try to get from closed pool
-	_, err = pool.Get()
-	if err != ErrPoolClosed {
-		t.Errorf("Expected ErrPoolClosed, got: %v", err)
-	}
-}
-
-func TestTransportPoolConfiguration(t *testing.T) {
-	// Test with pool size 5
-	tr := NewTransport(PoolSize(5))
-	nt, ok := tr.(*ntport)
-	if !ok {
-		t.Fatal("Expected transport to be of type *ntport")
-	}
-
-	if nt.poolSize != 5 {
-		t.Errorf("Expected pool size 5, got %d", nt.poolSize)
-	}
-
-	// Test with custom idle timeout
-	tr2 := NewTransport(PoolSize(3), PoolIdleTimeout(10*time.Minute))
-	nt2, ok := tr2.(*ntport)
-	if !ok {
-		t.Fatal("Expected transport to be of type *ntport")
-	}
-
-	if nt2.poolSize != 3 {
-		t.Errorf("Expected pool size 3, got %d", nt2.poolSize)
-	}
-
-	if nt2.poolIdleTimeout != 10*time.Minute {
-		t.Errorf("Expected idle timeout 10m, got %v", nt2.poolIdleTimeout)
-	}
-}
-
-func TestTransportDefaultSingleConnection(t *testing.T) {
-	// Test that default behavior is single connection (pool size 1)
-	tr := NewTransport()
-	nt, ok := tr.(*ntport)
-	if !ok {
-		t.Fatal("Expected transport to be of type *ntport")
-	}
-
-	if nt.poolSize != 1 {
-		t.Errorf("Expected default pool size 1, got %d", nt.poolSize)
-	}
-
-	// With size 1, pool should not be created
-	if nt.pool != nil {
-		t.Error("Expected no pool with size 1")
-	}
-}