diff --git a/exec_test.go b/exec_test.go
index 00c49c5..c48f5ca 100644
--- a/exec_test.go
+++ b/exec_test.go
@@ -5,26 +5,26 @@
 package dsrpc
 
 import (
-        "bytes"
-        "context"
-        "encoding/json"
-        "errors"
-        "io"
-        "math/rand"
-        "testing"
-        "time"
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"io"
+	"math/rand"
+	"testing"
+	"time"
 
-        "github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/require"
 )
 
 const HelloMethod string = "hello"
 
 type HelloParams struct {
-        Message string `json:"message" msgpack:"message"`
+	Message string `json:"message" msgpack:"message"`
 }
 
 type HelloResult struct {
-        Message string `json:"message" msgpack:"message"`
+	Message string `json:"message" msgpack:"message"`
 }
 
 const SaveMethod string = "save"
@@ -38,342 +38,342 @@ type LoadParams HelloParams
 type LoadResult HelloResult
 
 func TestLocalExec(t *testing.T) {
-        var err error
-        params := HelloParams{}
-        params.Message = "hello server!"
-        result := HelloResult{}
+	var err error
+	params := HelloParams{}
+	params.Message = "hello server!"
+	result := HelloResult{}
 
-        auth := CreateAuth([]byte("qwert"), []byte("12345"))
+	auth := CreateAuth([]byte("qwert"), []byte("12345"))
 
-        err = LocalExec(HelloMethod, &params, &result, auth, helloHandler)
-        require.NoError(t, err)
+	err = LocalExec(HelloMethod, &params, &result, auth, helloHandler)
+	require.NoError(t, err)
 
-        resultJson, _ := json.Marshal(result)
-        logDebug("method result:", string(resultJson))
+	resultJson, _ := json.Marshal(result)
+	logDebug("method result:", string(resultJson))
 }
 
 func TestLocalSave(t *testing.T) {
-        var err error
+	var err error
 
-        params := SaveParams{}
-        params.Message = "save data!"
-        result := SaveResult{}
-        auth := CreateAuth([]byte("qwert"), []byte("12345"))
+	params := SaveParams{}
+	params.Message = "save data!"
+	result := SaveResult{}
+	auth := CreateAuth([]byte("qwert"), []byte("12345"))
 
-        var binSize int64 = 16
-        rand.Seed(time.Now().UnixNano())
-        binBytes := make([]byte, binSize)
-        rand.Read(binBytes)
+	var binSize int64 = 16
+	rand.Seed(time.Now().UnixNano())
+	binBytes := make([]byte, binSize)
+	rand.Read(binBytes)
 
-        reader := bytes.NewReader(binBytes)
+	reader := bytes.NewReader(binBytes)
 
-        timeout := time.Duration(5 * time.Second)
-        ctx, cancel := context.WithTimeout(context.Background(), timeout)
-        defer cancel()
+	timeout := time.Duration(5 * time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
 
-        err = LocalPut(ctx, SaveMethod, reader, binSize, &params, &result, auth, saveHandler)
-        require.NoError(t, err)
+	err = LocalPut(ctx, SaveMethod, reader, binSize, &params, &result, auth, saveHandler)
+	require.NoError(t, err)
 
-        resultJson, _ := json.Marshal(result)
-        logDebug("method result:", string(resultJson))
+	resultJson, _ := json.Marshal(result)
+	logDebug("method result:", string(resultJson))
 }
 
 func TestLocalLoad(t *testing.T) {
-        var err error
+	var err error
 
-        params := LoadParams{}
-        params.Message = "load data!"
-        result := LoadResult{}
-        auth := CreateAuth([]byte("qwert"), []byte("12345"))
+	params := LoadParams{}
+	params.Message = "load data!"
+	result := LoadResult{}
+	auth := CreateAuth([]byte("qwert"), []byte("12345"))
 
-        binBytes := make([]byte, 0)
-        writer := bytes.NewBuffer(binBytes)
+	binBytes := make([]byte, 0)
+	writer := bytes.NewBuffer(binBytes)
 
-        timeout := time.Duration(5 * time.Second)
-        ctx, cancel := context.WithTimeout(context.Background(), timeout)
-        defer cancel()
+	timeout := time.Duration(5 * time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
 
-        err = LocalGet(ctx, LoadMethod, writer, &params, &result, auth, loadHandler)
-        require.NoError(t, err)
+	err = LocalGet(ctx, LoadMethod, writer, &params, &result, auth, loadHandler)
+	require.NoError(t, err)
 
-        resultJson, _ := json.Marshal(result)
-        logDebug("method result:", string(resultJson))
-        logDebug("bin size:", len(writer.Bytes()))
+	resultJson, _ := json.Marshal(result)
+	logDebug("method result:", string(resultJson))
+	logDebug("bin size:", len(writer.Bytes()))
 }
 
 func TestNetExec(t *testing.T) {
-        go testServ(false)
-        time.Sleep(100 * time.Millisecond)
-        err := clientHello()
+	go testServ(false)
+	time.Sleep(100 * time.Millisecond)
+	err := clientHello()
 
-        require.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestNetSave(t *testing.T) {
-        go testServ(false)
-        time.Sleep(100 * time.Millisecond)
-        err := clientSave()
-        require.NoError(t, err)
+	go testServ(false)
+	time.Sleep(100 * time.Millisecond)
+	err := clientSave()
+	require.NoError(t, err)
 }
 
 func TestNetLoad(t *testing.T) {
-        go testServ(false)
-        time.Sleep(100 * time.Millisecond)
-        err := clientLoad()
-        require.NoError(t, err)
+	go testServ(false)
+	time.Sleep(100 * time.Millisecond)
+	err := clientLoad()
+	require.NoError(t, err)
 }
 
 func BenchmarkNetPut(b *testing.B) {
-        go testServ(true)
-        time.Sleep(1000 * time.Millisecond)
-        clientSave()
+	go testServ(true)
+	time.Sleep(1000 * time.Millisecond)
+	clientSave()
 
-        pBench := func(pb *testing.PB) {
-                for pb.Next() {
-                        clientSave()
-                }
-        }
-        b.SetParallelism(2000)
-        b.RunParallel(pBench)
+	pBench := func(pb *testing.PB) {
+		for pb.Next() {
+			clientSave()
+		}
+	}
+	b.SetParallelism(2000)
+	b.RunParallel(pBench)
 }
 
 func clientHello() error {
-        var err error
+	var err error
 
-        params := HelloParams{}
-        params.Message = "hello server!"
-        result := HelloResult{}
-        auth := CreateAuth([]byte("qwert"), []byte("12345"))
+	params := HelloParams{}
+	params.Message = "hello server!"
+	result := HelloResult{}
+	auth := CreateAuth([]byte("qwert"), []byte("12345"))
 
-        var binSize int64 = 16
-        rand.Seed(time.Now().UnixNano())
-        binBytes := make([]byte, binSize)
-        rand.Read(binBytes)
+	var binSize int64 = 16
+	rand.Seed(time.Now().UnixNano())
+	binBytes := make([]byte, binSize)
+	rand.Read(binBytes)
 
-        timeout := time.Duration(5 * time.Second)
-        ctx, cancel := context.WithTimeout(context.Background(), timeout)
-        defer cancel()
+	timeout := time.Duration(5 * time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
 
-        err = Exec(ctx, "127.0.0.1:18081", HelloMethod, &params, &result, auth)
-        if err != nil {
-                logError("method err:", err)
-                return err
-        }
-        resultJson, _ := json.Marshal(result)
-        logDebug("method result:", string(resultJson))
-        return err
+	err = Exec(ctx, "127.0.0.1:18081", HelloMethod, &params, &result, auth)
+	if err != nil {
+		logError("method err:", err)
+		return err
+	}
+	resultJson, _ := json.Marshal(result)
+	logDebug("method result:", string(resultJson))
+	return err
 }
 
 func clientSave() error {
-        var err error
+	var err error
 
-        params := SaveParams{}
-        params.Message = "save data!"
-        result := SaveResult{}
-        auth := CreateAuth([]byte("qwert"), []byte("12345"))
+	params := SaveParams{}
+	params.Message = "save data!"
+	result := SaveResult{}
+	auth := CreateAuth([]byte("qwert"), []byte("12345"))
 
-        var binSize int64 = 16
-        rand.Seed(time.Now().UnixNano())
-        binBytes := make([]byte, binSize)
-        rand.Read(binBytes)
+	var binSize int64 = 16
+	rand.Seed(time.Now().UnixNano())
+	binBytes := make([]byte, binSize)
+	rand.Read(binBytes)
 
-        reader := bytes.NewReader(binBytes)
+	reader := bytes.NewReader(binBytes)
 
-        timeout := time.Duration(5 * time.Second)
-        ctx, cancel := context.WithTimeout(context.Background(), timeout)
-        defer cancel()
+	timeout := time.Duration(5 * time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
 
-        err = Put(ctx, "127.0.0.1:18081", SaveMethod, reader, binSize, &params, &result, auth)
-        if err != nil {
-                logError("method err:", err)
-                return err
-        }
-        resultJson, _ := json.Marshal(result)
-        logDebug("method result:", string(resultJson))
-        return err
+	err = Put(ctx, "127.0.0.1:18081", SaveMethod, reader, binSize, &params, &result, auth)
+	if err != nil {
+		logError("method err:", err)
+		return err
+	}
+	resultJson, _ := json.Marshal(result)
+	logDebug("method result:", string(resultJson))
+	return err
 }
 
 func clientLoad() error {
-        var err error
+	var err error
 
-        params := LoadParams{}
-        params.Message = "load data!"
-        result := LoadResult{}
-        auth := CreateAuth([]byte("qwert"), []byte("12345"))
+	params := LoadParams{}
+	params.Message = "load data!"
+	result := LoadResult{}
+	auth := CreateAuth([]byte("qwert"), []byte("12345"))
 
-        binBytes := make([]byte, 0)
-        writer := bytes.NewBuffer(binBytes)
+	binBytes := make([]byte, 0)
+	writer := bytes.NewBuffer(binBytes)
 
-        timeout := time.Duration(5 * time.Second)
-        ctx, cancel := context.WithTimeout(context.Background(), timeout)
-        defer cancel()
+	timeout := time.Duration(5 * time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
 
-        err = Get(ctx, "127.0.0.1:18081", LoadMethod, writer, &params, &result, auth)
-        if err != nil {
-                logError("method err:", err)
-                return err
-        }
-        resultJson, _ := json.Marshal(result)
-        logDebug("method result:", string(resultJson))
-        logDebug("bin size:", len(writer.Bytes()))
-        return err
+	err = Get(ctx, "127.0.0.1:18081", LoadMethod, writer, &params, &result, auth)
+	if err != nil {
+		logError("method err:", err)
+		return err
+	}
+	resultJson, _ := json.Marshal(result)
+	logDebug("method result:", string(resultJson))
+	logDebug("bin size:", len(writer.Bytes()))
+	return err
 }
 
 var testServRun bool = false
 
 func testServ(quiet bool) error {
-        var err error
+	var err error
 
-        if testServRun {
-                return err
-        }
-        testServRun = true
+	if testServRun {
+		return err
+	}
+	testServRun = true
 
-        if quiet {
-                SetAccessWriter(io.Discard)
-                SetMessageWriter(io.Discard)
-        }
+	if quiet {
+		SetAccessWriter(io.Discard)
+		SetMessageWriter(io.Discard)
+	}
 
-        serv := NewService()
-        serv.Handle(HelloMethod, helloHandler)
-        serv.Handle(SaveMethod, saveHandler)
-        serv.Handle(LoadMethod, loadHandler)
+	serv := NewService()
+	serv.Handle(HelloMethod, helloHandler)
+	serv.Handle(SaveMethod, saveHandler)
+	serv.Handle(LoadMethod, loadHandler)
 
-        serv.PreMiddleware(LogRequest)
-        serv.PreMiddleware(auth)
+	serv.PreMiddleware(LogRequest)
+	serv.PreMiddleware(auth)
 
-        serv.PostMiddleware(LogResponse)
-        serv.PostMiddleware(LogAccess)
+	serv.PostMiddleware(LogResponse)
+	serv.PostMiddleware(LogAccess)
 
-        err = serv.Listen(":18081")
-        if err != nil {
-                return err
-        }
-        return err
+	err = serv.Listen(":18081")
+	if err != nil {
+		return err
+	}
+	return err
 }
 
 func auth(content *Content) error {
-        var err error
-        reqIdent := content.AuthIdent()
-        reqSalt := content.AuthSalt()
-        reqHash := content.AuthHash()
+	var err error
+	reqIdent := content.AuthIdent()
+	reqSalt := content.AuthSalt()
+	reqHash := content.AuthHash()
 
-        ident := reqIdent
-        pass := []byte("12345")
+	ident := reqIdent
+	pass := []byte("12345")
 
-        auth := content.Auth()
-        logDebug("auth ", string(auth.Json()))
+	auth := content.Auth()
+	logDebug("auth ", string(auth.Json()))
 
-        ok := CheckHash(ident, pass, reqSalt, reqHash)
-        logDebug("auth ok:", ok)
-        if !ok {
-                err = errors.New("auth ident or pass missmatch")
-                content.SendError(err)
-                return err
-        }
-        return err
+	ok := CheckHash(ident, pass, reqSalt, reqHash)
+	logDebug("auth ok:", ok)
+	if !ok {
+		err = errors.New("auth ident or pass missmatch")
+		content.SendError(err)
+		return err
+	}
+	return err
 }
 
 func helloHandler(content *Content) error {
-        var err error
-        params := HelloParams{}
+	var err error
+	params := HelloParams{}
 
-        err = content.BindParams(&params)
-        if err != nil {
-                return err
-        }
+	err = content.BindParams(&params)
+	if err != nil {
+		return err
+	}
 
-        timeout := time.Duration(5 * time.Second)
-        ctx, cancel := context.WithTimeout(context.Background(), timeout)
-        defer cancel()
+	timeout := time.Duration(5 * time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
 
-        err = content.ReadBin(ctx, io.Discard)
-        if err != nil {
-                content.SendError(err)
-                return err
-        }
+	err = content.ReadBin(ctx, io.Discard)
+	if err != nil {
+		content.SendError(err)
+		return err
+	}
 
-        result := HelloResult{}
-        result.Message = "hello, client!"
+	result := HelloResult{}
+	result.Message = "hello, client!"
 
-        err = content.SendResult(result, 0)
-        if err != nil {
-                return err
-        }
-        return err
+	err = content.SendResult(result, 0)
+	if err != nil {
+		return err
+	}
+	return err
 }
 
 func saveHandler(content *Content) error {
-        var err error
-        params := SaveParams{}
+	var err error
+	params := SaveParams{}
 
-        err = content.BindParams(&params)
-        if err != nil {
-                return err
-        }
+	err = content.BindParams(&params)
+	if err != nil {
+		return err
+	}
 
-        bufferBytes := make([]byte, 0, 1024)
-        binWriter := bytes.NewBuffer(bufferBytes)
+	bufferBytes := make([]byte, 0, 1024)
+	binWriter := bytes.NewBuffer(bufferBytes)
 
-        timeout := time.Duration(5 * time.Second)
-        ctx, cancel := context.WithTimeout(context.Background(), timeout)
-        defer cancel()
+	timeout := time.Duration(5 * time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
 
-        err = content.ReadBin(ctx, binWriter)
-        if err != nil {
-                content.SendError(err)
-                return err
-        }
+	err = content.ReadBin(ctx, binWriter)
+	if err != nil {
+		content.SendError(err)
+		return err
+	}
 
-        result := SaveResult{}
-        result.Message = "saved successfully!"
+	result := SaveResult{}
+	result.Message = "saved successfully!"
 
-        err = content.SendResult(result, 0)
-        if err != nil {
-                return err
-        }
-        return err
+	err = content.SendResult(result, 0)
+	if err != nil {
+		return err
+	}
+	return err
 }
 
 func loadHandler(content *Content) error {
-        var err error
-        params := SaveParams{}
+	var err error
+	params := SaveParams{}
 
-        err = content.BindParams(&params)
-        if err != nil {
-                return err
-        }
+	err = content.BindParams(&params)
+	if err != nil {
+		return err
+	}
 
-        timeout := time.Duration(5 * time.Second)
-        ctx, cancel := context.WithTimeout(context.Background(), timeout)
-        defer cancel()
+	timeout := time.Duration(5 * time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
 
-        err = content.ReadBin(ctx, io.Discard)
-        if err != nil {
-                content.SendError(err)
-                return err
-        }
+	err = content.ReadBin(ctx, io.Discard)
+	if err != nil {
+		content.SendError(err)
+		return err
+	}
 
-        var binSize int64 = 1024
-        rand.Seed(time.Now().UnixNano())
-        binBytes := make([]byte, binSize)
-        rand.Read(binBytes)
+	var binSize int64 = 1024
+	rand.Seed(time.Now().UnixNano())
+	binBytes := make([]byte, binSize)
+	rand.Read(binBytes)
 
-        binReader := bytes.NewReader(binBytes)
+	binReader := bytes.NewReader(binBytes)
 
-        result := SaveResult{}
-        result.Message = "load successfully!"
+	result := SaveResult{}
+	result.Message = "load successfully!"
 
-        err = content.SendResult(result, binSize)
-        if err != nil {
-                return err
-        }
+	err = content.SendResult(result, binSize)
+	if err != nil {
+		return err
+	}
 
-        binWriter := content.BinWriter()
-        _, err = CopyBytes(ctx, binReader, binWriter, binSize)
-        if err != nil {
-                return err
-        }
+	binWriter := content.BinWriter()
+	_, err = CopyBytes(ctx, binReader, binWriter, binSize)
+	if err != nil {
+		return err
+	}
 
-        return err
+	return err
 }
diff --git a/logger.go b/logger.go
index ac6ea15..d303580 100644
--- a/logger.go
+++ b/logger.go
@@ -10,41 +10,27 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"time"
 )
 
 var (
 	messageWriter io.Writer = os.Stdout
 	accessWriter  io.Writer = os.Stdout
-	logTimestamp  bool      = false
 )
 
-func getLogStamp() string {
-	var stamp string
-	if logTimestamp {
-		stamp = time.Now().Format(time.RFC3339)
-	}
-	return stamp
-}
-
 func logDebug(messages ...any) {
-	stamp := getLogStamp()
-	fmt.Fprintln(messageWriter, stamp, "debug", messages)
+	fmt.Fprintln(messageWriter, "debug:", messages)
 }
 
 func logInfo(messages ...any) {
-	stamp := getLogStamp()
-	fmt.Fprintln(messageWriter, stamp, "info", messages)
+	fmt.Fprintln(messageWriter, "info:", messages)
 }
 
 func logError(messages ...any) {
-	stamp := getLogStamp()
-	fmt.Fprintln(messageWriter, stamp, "error", messages)
+	fmt.Fprintln(messageWriter, "error:", messages)
 }
 
 func logAccess(messages ...any) {
-	stamp := getLogStamp()
-	fmt.Fprintln(accessWriter, stamp, "access", messages)
+	fmt.Fprintln(accessWriter, "access:", messages)
 }
 
 func SetAccessWriter(writer io.Writer) {
@@ -54,8 +40,3 @@ func SetAccessWriter(writer io.Writer) {
 func SetMessageWriter(writer io.Writer) {
 	messageWriter = writer
 }
-
-func EnableLogTimestamp(enable bool) {
-	logTimestamp = enable
-}
-