Merge pull request #283 from 0xProject/release/1.0.6-beta

Release version 1.0.6-beta

Author: fabioberger

DEPLOYMENT.md

@@ -1,4 +1,4 @@
-[![Version](https://img.shields.io/badge/version-1.0.5--beta-orange.svg)](https://github.com/0xProject/0x-mesh/releases)
+[![Version](https://img.shields.io/badge/version-1.0.6--beta-orange.svg)](https://github.com/0xProject/0x-mesh/releases)
 
 # 0x Mesh Deployment Guide
 
@@ -25,7 +25,7 @@ docker run \
 -p 60557:60557 \
 -p 60558:60558 \
 -e ETHEREUM_NETWORK_ID="1" \
--e ETHEREUM_RPC_URL="https://mainnet.infura.io/v3/a9a23d2566e542629179d6372ace13c9" \
+-e ETHEREUM_RPC_URL="ADD_YOUR_ETHEREUM_RPC_ENDPOINT_HERE" \
 -e VERBOSITY=5 \
 0xorg/mesh:latest
 ```

DEVELOPMENT.md

@@ -1,4 +1,4 @@
-[![Version](https://img.shields.io/badge/version-1.0.5--beta-orange.svg)](https://github.com/0xProject/0x-mesh/releases)
+[![Version](https://img.shields.io/badge/version-1.0.6--beta-orange.svg)](https://github.com/0xProject/0x-mesh/releases)
 
 # 0x Mesh Development Guide
 

Gopkg.lock

@@ -1,4 +1,4 @@
-[![Version](https://img.shields.io/badge/version-1.0.5--beta-orange.svg)](https://github.com/0xProject/0x-mesh/releases)
+[![Version](https://img.shields.io/badge/version-1.0.6--beta-orange.svg)](https://github.com/0xProject/0x-mesh/releases)
 [![Chat with us on Discord](https://img.shields.io/badge/chat-Discord-blueViolet.svg)](https://discord.gg/HF7fHwk)
 [![GoDoc](https://godoc.org/github.com/0xProject/0x-mesh?status.svg)](https://godoc.org/github.com/0xProject/0x-mesh)
 [![Circle CI](https://img.shields.io/circleci/project/0xProject/0x-mesh/master.svg)](https://circleci.com/gh/0xProject/0x-mesh/tree/master)
@@ -12,7 +12,7 @@
 
 ## Versions
 
-You are looking at the documentation for version `1.0.5-beta`. To see the
+You are looking at the documentation for version `1.0.6-beta`. To see the
 documentation for a different version, visit the
 [Releases Page](https://github.com/0xProject/0x-mesh/releases).
 

README.md

@@ -1,4 +1,4 @@
-[![Version](https://img.shields.io/badge/version-1.0.5--beta-orange.svg)](https://github.com/0xProject/0x-mesh/releases)
+[![Version](https://img.shields.io/badge/version-1.0.6--beta-orange.svg)](https://github.com/0xProject/0x-mesh/releases)
 
 # 0x Mesh Usage Guide
 

USAGE.md

@@ -17,14 +17,15 @@ import (
 	"github.com/0xProject/0x-mesh/p2p"
 	libp2p "github.com/libp2p/go-libp2p"
 	autonat "github.com/libp2p/go-libp2p-autonat-svc"
-	relay "github.com/libp2p/go-libp2p-circuit"
+	circuit "github.com/libp2p/go-libp2p-circuit"
 	connmgr "github.com/libp2p/go-libp2p-connmgr"
 	p2pcrypto "github.com/libp2p/go-libp2p-crypto"
 	host "github.com/libp2p/go-libp2p-host"
 	dht "github.com/libp2p/go-libp2p-kad-dht"
 	p2pnet "github.com/libp2p/go-libp2p-net"
 	peer "github.com/libp2p/go-libp2p-peer"
 	routing "github.com/libp2p/go-libp2p-routing"
+	"github.com/libp2p/go-libp2p/p2p/host/relay"
 	ma "github.com/multiformats/go-multiaddr"
 	"github.com/plaid/go-envvar/envvar"
 	log "github.com/sirupsen/logrus"
@@ -59,6 +60,13 @@ type Config struct {
 	PrivateKeyPath string `envvar:"PRIVATE_KEY_PATH" default:"0x_mesh/keys/privkey"`
 }
 
+func init() {
+	// Since we know that the bootstrap nodes are more stable, we can
+	// safely reduce AdvertiseBootDelay. This will allow the bootstrap nodes to
+	// advertise themselves as relays sooner.
+	relay.AdvertiseBootDelay = 30 * time.Second
+}
+
 func main() {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
@@ -73,6 +81,7 @@ func main() {
 	// TODO(albrow): Don't use global settings for logger.
 	log.SetFormatter(&log.JSONFormatter{})
 	log.SetLevel(log.Level(config.Verbosity))
+	log.AddHook(loghooks.NewKeySuffixHook())
 
 	// Parse private key file
 	privKey, err := initPrivateKey(config.PrivateKeyPath)
@@ -114,7 +123,7 @@ func main() {
 		libp2p.ListenAddrs(hostAddr),
 		libp2p.Identity(privKey),
 		libp2p.ConnectionManager(connManager),
-		libp2p.EnableRelay(relay.OptHop),
+		libp2p.EnableRelay(circuit.OptHop),
 		libp2p.EnableAutoRelay(),
 		libp2p.Routing(newDHT),
 		libp2p.AddrsFactory(newAddrsFactory(advertiseAddrs)),

cmd/mesh-bootstrap/main.go

@@ -104,9 +104,10 @@ func New(config Config) (*App, error) {
 	// Configure logger
 	// TODO(albrow): Don't use global variables for log settings.
 	log.SetLevel(log.Level(config.Verbosity))
+	log.AddHook(loghooks.NewKeySuffixHook())
 	log.WithFields(map[string]interface{}{
 		"config":  config,
-		"version": "1.0.5-beta",
+		"version": "1.0.6-beta",
 	}).Info("Initializing new core.App")
 
 	if config.EthereumRPCMaxContentLength < maxOrderSizeInBytes {

core/core.go

@@ -2,7 +2,7 @@ version: '3'
 
 services:
     mesh:
-        image: 0xorg/mesh:1.0.5-beta
+        image: 0xorg/mesh:1.0.6-beta
         restart: always
         logging:
             driver: fluentd

examples/beta_telemetry_node/docker-compose.yml

@@ -0,0 +1,116 @@
+package loghooks
+
+import (
+	"bytes"
+	"encoding"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+)
+
+var errNestedMapType = errors.New("nested map types are not supported")
+
+// KeySuffixHook is a logger hook that adds suffixes to all keys based on their
+// type.
+type KeySuffixHook struct{}
+
+// NewKeySuffixHook creates and returns a new KeySuffixHook.
+func NewKeySuffixHook() *KeySuffixHook {
+	return &KeySuffixHook{}
+}
+
+// Ensure that KeySuffixHook implements log.Hook.
+var _ log.Hook = &KeySuffixHook{}
+
+func (h *KeySuffixHook) Levels() []log.Level {
+	return log.AllLevels
+}
+
+func (h *KeySuffixHook) Fire(entry *log.Entry) error {
+	for key, value := range entry.Data {
+		typ, err := getTypeForValue(value)
+		if err != nil {
+			if err == errNestedMapType {
+				// We can't safely log nested map types, so replace the value with a
+				// string.
+				newKey := fmt.Sprintf("%s_json_string", key)
+				delete(entry.Data, key)
+				mapString, err := json.Marshal(value)
+				if err != nil {
+					return err
+				}
+				entry.Data[newKey] = string(mapString)
+				continue
+			} else {
+				return err
+			}
+		}
+		newKey := fmt.Sprintf("%s_%s", key, typ)
+		delete(entry.Data, key)
+		entry.Data[newKey] = value
+	}
+	return nil
+}
+
+// getTypeForValue returns a string representation of the type of the given val.
+func getTypeForValue(val interface{}) (string, error) {
+	if _, ok := val.(json.Marshaler); ok {
+		// If val implements json.Marshaler, return the type of json.Marshal(val)
+		// instead of the type of val.
+		buf := &bytes.Buffer{}
+		if err := json.NewEncoder(buf).Encode(val); err != nil {
+			return "", err
+		}
+		var holder interface{}
+		if err := json.NewDecoder(buf).Decode(&holder); err != nil {
+			return "", err
+		}
+		return getTypeForValue(holder)
+	}
+	if _, ok := val.(encoding.TextMarshaler); ok {
+		// The json package always encodes values that implement
+		// encoding.TextMarshaler as a string.
+		return "string", nil
+	}
+
+	underlyingType := getUnderlyingType(reflect.TypeOf(val))
+	switch kind := underlyingType.Kind(); kind {
+	case reflect.Bool:
+		return "bool", nil
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
+		return "number", nil
+	case reflect.String, reflect.Complex64, reflect.Complex128, reflect.Func, reflect.Chan:
+		return "string", nil
+	case reflect.Array, reflect.Slice:
+		return "array", nil
+	case reflect.Map:
+		// Nested map types can't be efficiently indexed because they allow for
+		// arbitrary keys. We don't allow them.
+		return "", errNestedMapType
+	case reflect.Struct:
+		return getSafeStructTypeName(underlyingType)
+	default:
+		return "", fmt.Errorf("cannot determine type suffix for kind: %s", kind)
+	}
+}
+
+// getUnderlyingType returns the underlying type for the given type by
+// recursively dereferencing pointer types.
+func getUnderlyingType(typ reflect.Type) reflect.Type {
+	if typ.Kind() == reflect.Ptr {
+		return getUnderlyingType(typ.Elem())
+	}
+	return typ
+}
+
+// getSafeStructTypeName replaces dots in the name of the given type with
+// underscores. Elasticsearch does not allow dots in key names.
+func getSafeStructTypeName(typ reflect.Type) (string, error) {
+	unsafeTypeName := typ.String()
+	safeTypeName := strings.ReplaceAll(unsafeTypeName, ".", "_")
+	return safeTypeName, nil
+}

loghooks/key_suffix_hook.go

@@ -0,0 +1,146 @@
+package loghooks
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/0xProject/0x-mesh/constants"
+
+	log "github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+type myStruct struct {
+	myInt    int
+	myString string
+}
+
+func TestGetTypeForValue(t *testing.T) {
+	testCases := []struct {
+		input    interface{}
+		expected string
+	}{
+		{
+			input:    true,
+			expected: "bool",
+		},
+		{
+			input:    int(42),
+			expected: "number",
+		},
+		{
+			input:    int8(42),
+			expected: "number",
+		},
+		{
+			input:    int16(42),
+			expected: "number",
+		},
+		{
+			input:    int32(42),
+			expected: "number",
+		},
+		{
+			input:    int64(42),
+			expected: "number",
+		},
+		{
+			input:    uint(42),
+			expected: "number",
+		},
+		{
+			input:    uint8(42),
+			expected: "number",
+		},
+		{
+			input:    uint16(42),
+			expected: "number",
+		},
+		{
+			input:    uint32(42),
+			expected: "number",
+		},
+		{
+			input:    uint64(42),
+			expected: "number",
+		},
+		{
+			input:    float32(42),
+			expected: "number",
+		},
+		{
+			input:    float64(42),
+			expected: "number",
+		},
+		{
+			input:    "foo",
+			expected: "string",
+		},
+		{
+			input:    complex64(42i + 7),
+			expected: "string",
+		},
+		{
+			input:    complex128(42i + 7),
+			expected: "string",
+		},
+		{
+			input:    func() {},
+			expected: "string",
+		},
+		{
+			input:    make(chan struct{}),
+			expected: "string",
+		},
+		{
+			input:    []int{},
+			expected: "array",
+		},
+		{
+			input:    [...]int{},
+			expected: "array",
+		},
+		{
+			input:    myStruct{},
+			expected: "loghooks_myStruct",
+		},
+		{
+			// Implements encoding.TextUnmarshaler but not json.Marshaler.
+			input:    constants.NullAddress,
+			expected: "string",
+		},
+		{
+			// We don't expect the case of anonymous structs to come up often, but we
+			// do handle it correcly. " ", "{", "}", and ";" are allowed in
+			// Elasticsearch. The resulting string is ugly but at least it is
+			// guaranteed to prevent field mapping conflicts.
+			input: struct {
+				myInt    int
+				myString string
+			}{},
+			expected: "struct { myInt int; myString string }",
+		},
+	}
+
+	for _, testCase := range testCases {
+		testCaseInfo := fmt.Sprintf("input: (%T) %v", testCase.input, testCase.input)
+		actual, err := getTypeForValue(testCase.input)
+		require.NoError(t, err, testCaseInfo)
+		assert.Equal(t, testCase.expected, actual, testCaseInfo)
+	}
+}
+
+func TestKeySuffixHookWithNestedMapType(t *testing.T) {
+	hook := NewKeySuffixHook()
+	entry := &log.Entry{
+		Data: log.Fields{
+			"myMap": map[string]int{"one": 1},
+		},
+	}
+	require.NoError(t, hook.Fire(entry))
+	expectedData := log.Fields{
+		"myMap_json_string": `{"one":1}`,
+	}
+	assert.Equal(t, expectedData, entry.Data)
+}