Delete SECURITY.md

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>

README.md

@@ -1,29 +1,28 @@
 # Micro
-![Coverage](https://img.shields.io/badge/Coverage-44.8%25-yellow)
+![Coverage](https://img.shields.io/badge/Coverage-44.7%25-yellow)
 [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![Doc](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/go.unistack.org/micro/v3?tab=overview)
 [![Status](https://git.unistack.org/unistack-org/micro/actions/workflows/job_tests.yml/badge.svg?branch=v3)](https://git.unistack.org/unistack-org/micro/actions?query=workflow%3Abuild+branch%3Av3+event%3Apush)
-[![Lint](https://goreportcard.com/badge/go.unistack.org/micro/v3)](https://goreportcard.com/report/go.unistack.org/micro/v3) 
-![Coverage](https://img.shields.io/badge/coverage-44.6%25-yellow)
+[![Lint](https://goreportcard.com/badge/go.unistack.org/micro/v3)](https://goreportcard.com/report/go.unistack.org/micro/v3)
 
 Micro is a standard library for microservices.
 
 ## Overview
 
-Micro provides the core requirements for distributed systems development including RPC and Event driven communication. 
+Micro provides the core requirements for distributed systems development including SYNC and ASYNC communication. 
 
 ## Features
 
-Micro abstracts away the details of distributed systems. Here are the main features.
+Micro abstracts away the details of distributed systems. Main features:
 
 - **Dynamic Config** - Load and hot reload dynamic config from anywhere. The config interface provides a way to load application 
-level config from any source such as env vars, cmdline, file, consul, vault... You can merge the sources and even define fallbacks.
+level config from any source such as env vars, cmdline, file, consul, vault, etc... You can merge the sources and even define fallbacks.
 
 - **Data Storage** - A simple data store interface to read, write and delete records. It includes support for memory, file and 
 s3. State and persistence becomes a core requirement beyond prototyping and Micro looks to build that into the framework.
 
 - **Service Discovery** - Automatic service registration and name resolution. Service discovery is at the core of micro service 
-development. When service A needs to speak to service B it needs the location of that service.
+development.
 
 - **Message Encoding** - Dynamic message encoding based on content-type. The client and server will use codecs along with content-type 
 to seamlessly encode and decode Go types for you. Any variety of messages could be encoded and sent from different clients. The client 

SECURITY.md

@@ -1,15 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-Use this section to tell people about which versions of your project are
-currently being supported with security updates.
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 3.7.x   | :white_check_mark: |
-| < 3.7.0 | :x:                |
-
-## Reporting a Vulnerability
-
-If you find any issue, please create github issue in this repo

logger/options.go

@@ -99,6 +99,7 @@ func WithAddFields(fields ...interface{}) Option {
 					iv, iok := o.Fields[i].(string)
 					jv, jok := fields[j].(string)
 					if iok && jok && iv == jv {
+						o.Fields[i+1] = fields[j+1]
 						fields = slices.Delete(fields, j, j+2)
 					}
 				}

logger/slog/slog.go

@@ -278,7 +278,7 @@ func (s *slogLogger) printLog(ctx context.Context, lvl logger.Level, msg string,
 		}
 	}
 
-	if (s.opts.AddStacktrace || lvl == logger.FatalLevel) || (s.opts.AddStacktrace && lvl == logger.ErrorLevel) {
+	if s.opts.AddStacktrace && (lvl == logger.FatalLevel || lvl == logger.ErrorLevel) {
 		stackInfo := make([]byte, 1024*1024)
 		if stackSize := runtime.Stack(stackInfo, false); stackSize > 0 {
 			traceLines := reTrace.Split(string(stackInfo[:stackSize]), -1)

logger/slog/slog_test.go

@@ -21,7 +21,7 @@ import (
 func TestStacktrace(t *testing.T) {
 	ctx := context.TODO()
 	buf := bytes.NewBuffer(nil)
-	l := NewLogger(logger.WithLevel(logger.ErrorLevel), logger.WithOutput(buf),
+	l := NewLogger(logger.WithLevel(logger.DebugLevel), logger.WithOutput(buf),
 		WithHandlerFunc(slog.NewTextHandler),
 		logger.WithAddStacktrace(true),
 	)
@@ -124,7 +124,7 @@ func TestWithDedupKeysWithAddFields(t *testing.T) {
 
 	l.Info(ctx, "msg3")
 
-	if !bytes.Contains(buf.Bytes(), []byte(`msg=msg3 key1=val1 key2=val2`)) {
+	if !bytes.Contains(buf.Bytes(), []byte(`msg=msg3 key1=val4 key2=val3`)) {
 		t.Fatalf("logger error not works, buf contains: %s", buf.Bytes())
 	}
 }

tracer/memory/memory.go

@@ -89,6 +89,10 @@ func (s *Span) Tracer() tracer.Tracer {
 	return s.tracer
 }
 
+func (s *Span) IsRecording() bool {
+	return true
+}
+
 type Event struct {
 	name   string
 	labels []interface{}

tracer/noop.go

@@ -120,6 +120,10 @@ func (s *noopSpan) SetStatus(st SpanStatus, msg string) {
 	s.statusMsg = msg
 }
 
+func (s *noopSpan) IsRecording() bool {
+	return false
+}
+
 // NewTracer returns new memory tracer
 func NewTracer(opts ...Option) Tracer {
 	return &noopTracer{

tracer/tracer.go

@@ -78,4 +78,6 @@ type Span interface {
 	TraceID() string
 	// SpanID returns span id
 	SpanID() string
+	// IsRecording returns the recording state of the Span.
+	IsRecording() bool
 }

util/buffer/seeker_buffer.go

@@ -0,0 +1,78 @@
+package buffer
+
+import "io"
+
+var _ interface {
+	io.ReadCloser
+	io.ReadSeeker
+} = (*SeekerBuffer)(nil)
+
+// Buffer is a ReadWriteCloser that supports seeking. It's intended to
+// replicate the functionality of bytes.Buffer that I use in my projects.
+//
+// Note that the seeking is limited to the read marker; all writes are
+// append-only.
+type SeekerBuffer struct {
+	data []byte
+	pos  int64
+}
+
+func NewSeekerBuffer(data []byte) *SeekerBuffer {
+	return &SeekerBuffer{
+		data: data,
+	}
+}
+
+func (b *SeekerBuffer) Read(p []byte) (int, error) {
+	if b.pos >= int64(len(b.data)) {
+		return 0, io.EOF
+	}
+
+	n := copy(p, b.data[b.pos:])
+	b.pos += int64(n)
+	return n, nil
+}
+
+func (b *SeekerBuffer) Write(p []byte) (int, error) {
+	b.data = append(b.data, p...)
+	return len(p), nil
+}
+
+// Seek sets the read pointer to pos.
+func (b *SeekerBuffer) Seek(offset int64, whence int) (int64, error) {
+	switch whence {
+	case io.SeekStart:
+		b.pos = offset
+	case io.SeekEnd:
+		b.pos = int64(len(b.data)) + offset
+	case io.SeekCurrent:
+		b.pos += offset
+	}
+
+	return b.pos, nil
+}
+
+// Rewind resets the read pointer to 0.
+func (b *SeekerBuffer) Rewind() error {
+	if _, err := b.Seek(0, io.SeekStart); err != nil {
+		return err
+	}
+	return nil
+}
+
+// Close clears all the data out of the buffer and sets the read position to 0.
+func (b *SeekerBuffer) Close() error {
+	b.data = nil
+	b.pos = 0
+	return nil
+}
+
+// Len returns the length of data remaining to be read.
+func (b *SeekerBuffer) Len() int {
+	return len(b.data[b.pos:])
+}
+
+// Bytes returns the underlying bytes from the current position.
+func (b *SeekerBuffer) Bytes() []byte {
+	return b.data[b.pos:]
+}

util/buffer/seeker_buffer_test.go

@@ -0,0 +1,55 @@
+package buffer
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func noErrorT(t *testing.T, err error) {
+	if nil != err {
+		t.Fatalf("%s", err)
+	}
+}
+
+func boolT(t *testing.T, cond bool, s ...string) {
+	if !cond {
+		what := strings.Join(s, ", ")
+		if len(what) > 0 {
+			what = ": " + what
+		}
+		t.Fatalf("assert.Bool failed%s", what)
+	}
+}
+
+func TestSeeking(t *testing.T) {
+	partA := []byte("hello, ")
+	partB := []byte("world!")
+
+	buf := NewSeekerBuffer(partA)
+
+	boolT(t, buf.Len() == len(partA), fmt.Sprintf("on init: have length %d, want length %d", buf.Len(), len(partA)))
+
+	b := make([]byte, 32)
+
+	n, err := buf.Read(b)
+	noErrorT(t, err)
+	boolT(t, buf.Len() == 0, fmt.Sprintf("after reading 1: have length %d, want length 0", buf.Len()))
+	boolT(t, n == len(partA), fmt.Sprintf("after reading 2: have length %d, want length %d", n, len(partA)))
+
+	n, err = buf.Write(partB)
+	noErrorT(t, err)
+	boolT(t, n == len(partB), fmt.Sprintf("after writing: have length %d, want length %d", n, len(partB)))
+
+	n, err = buf.Read(b)
+	noErrorT(t, err)
+	boolT(t, buf.Len() == 0, fmt.Sprintf("after rereading 1: have length %d, want length 0", buf.Len()))
+	boolT(t, n == len(partB), fmt.Sprintf("after rereading 2: have length %d, want length %d", n, len(partB)))
+
+	partsLen := len(partA) + len(partB)
+	_ = buf.Rewind()
+	boolT(t, buf.Len() == partsLen, fmt.Sprintf("after rewinding: have length %d, want length %d", buf.Len(), partsLen))
+
+	buf.Close()
+	boolT(t, buf.Len() == 0, fmt.Sprintf("after closing, have length %d, want length 0", buf.Len()))
+}