Vendor the newtmgr dependencies
Project: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/commit/5528d6fc Tree: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/tree/5528d6fc Diff: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/diff/5528d6fc Branch: refs/heads/develop Commit: 5528d6fcf7cc46a4062578a34094ecc533ae5f97 Parents: c2dda8b Author: spoonofpower <[email protected]> Authored: Wed Jul 27 19:48:32 2016 -0700 Committer: spoonofpower <[email protected]> Committed: Wed Jul 27 19:48:32 2016 -0700 ---------------------------------------------------------------------- newtmgr/Godeps/Godeps.json | 113 + newtmgr/Godeps/Readme | 5 + .../github.com/Sirupsen/logrus/.gitignore | 1 + .../github.com/Sirupsen/logrus/.travis.yml | 10 + .../github.com/Sirupsen/logrus/CHANGELOG.md | 66 + .../vendor/github.com/Sirupsen/logrus/LICENSE | 21 + .../vendor/github.com/Sirupsen/logrus/README.md | 402 +++ .../github.com/Sirupsen/logrus/alt_exit.go | 64 + .../vendor/github.com/Sirupsen/logrus/doc.go | 26 + .../vendor/github.com/Sirupsen/logrus/entry.go | 264 ++ .../github.com/Sirupsen/logrus/exported.go | 193 ++ .../github.com/Sirupsen/logrus/formatter.go | 45 + .../vendor/github.com/Sirupsen/logrus/hooks.go | 34 + .../Sirupsen/logrus/json_formatter.go | 41 + .../vendor/github.com/Sirupsen/logrus/logger.go | 212 ++ .../vendor/github.com/Sirupsen/logrus/logrus.go | 143 + .../github.com/Sirupsen/logrus/terminal_bsd.go | 9 + .../Sirupsen/logrus/terminal_linux.go | 12 + .../Sirupsen/logrus/terminal_notwindows.go | 21 + .../Sirupsen/logrus/terminal_solaris.go | 15 + .../Sirupsen/logrus/terminal_windows.go | 27 + .../Sirupsen/logrus/text_formatter.go | 161 ++ .../vendor/github.com/Sirupsen/logrus/writer.go | 53 + .../inconshreveable/mousetrap/LICENSE | 13 + .../inconshreveable/mousetrap/README.md | 23 + .../inconshreveable/mousetrap/trap_others.go | 15 + .../inconshreveable/mousetrap/trap_windows.go | 98 + .../mousetrap/trap_windows_1.4.go | 46 + .../github.com/joaojeronimo/go-crc16/README.md | 32 + .../joaojeronimo/go-crc16/crc16-kermit.go | 17 + .../github.com/joaojeronimo/go-crc16/crc16.go | 44 + newtmgr/vendor/github.com/kr/pretty/.gitignore | 4 + newtmgr/vendor/github.com/kr/pretty/License | 21 + newtmgr/vendor/github.com/kr/pretty/Readme | 9 + newtmgr/vendor/github.com/kr/pretty/diff.go | 265 ++ .../vendor/github.com/kr/pretty/formatter.go | 328 +++ newtmgr/vendor/github.com/kr/pretty/pretty.go | 108 + newtmgr/vendor/github.com/kr/pretty/zero.go | 41 + newtmgr/vendor/github.com/kr/text/License | 19 + newtmgr/vendor/github.com/kr/text/Readme | 3 + newtmgr/vendor/github.com/kr/text/doc.go | 3 + newtmgr/vendor/github.com/kr/text/indent.go | 74 + newtmgr/vendor/github.com/kr/text/wrap.go | 86 + .../github.com/mitchellh/go-homedir/LICENSE | 21 + .../github.com/mitchellh/go-homedir/README.md | 14 + .../github.com/mitchellh/go-homedir/homedir.go | 137 + .../mitchellh/mapstructure/.travis.yml | 7 + .../github.com/mitchellh/mapstructure/LICENSE | 21 + .../github.com/mitchellh/mapstructure/README.md | 46 + .../mitchellh/mapstructure/decode_hooks.go | 154 + .../github.com/mitchellh/mapstructure/error.go | 50 + .../mitchellh/mapstructure/mapstructure.go | 771 +++++ .../github.com/runtimeinc/gatt/.gitignore | 3 + .../github.com/runtimeinc/gatt/LICENSE.md | 27 + .../vendor/github.com/runtimeinc/gatt/adv.go | 234 ++ .../vendor/github.com/runtimeinc/gatt/attr.go | 160 + .../github.com/runtimeinc/gatt/central.go | 152 + .../runtimeinc/gatt/central_darwin.go | 70 + .../github.com/runtimeinc/gatt/central_linux.go | 446 +++ .../vendor/github.com/runtimeinc/gatt/common.go | 399 +++ .../vendor/github.com/runtimeinc/gatt/const.go | 153 + .../vendor/github.com/runtimeinc/gatt/device.go | 158 + .../github.com/runtimeinc/gatt/device_darwin.go | 505 ++++ .../github.com/runtimeinc/gatt/device_linux.go | 240 ++ .../vendor/github.com/runtimeinc/gatt/doc.go | 88 + .../github.com/runtimeinc/gatt/known_uuid.go | 122 + .../runtimeinc/gatt/l2cap_writer_linux.go | 156 + .../github.com/runtimeinc/gatt/linux/cmd/cmd.go | 995 +++++++ .../github.com/runtimeinc/gatt/linux/const.go | 21 + .../github.com/runtimeinc/gatt/linux/device.go | 109 + .../github.com/runtimeinc/gatt/linux/devices.go | 58 + .../github.com/runtimeinc/gatt/linux/doc.go | 5 + .../github.com/runtimeinc/gatt/linux/evt/evt.go | 382 +++ .../runtimeinc/gatt/linux/gioctl/LICENSE.md | 22 + .../runtimeinc/gatt/linux/gioctl/README.md | 12 + .../runtimeinc/gatt/linux/gioctl/ioctl.go | 57 + .../github.com/runtimeinc/gatt/linux/hci.go | 397 +++ .../github.com/runtimeinc/gatt/linux/l2cap.go | 174 ++ .../runtimeinc/gatt/linux/socket/asm.s | 8 + .../gatt/linux/socket/asm_linux_386.s | 33 + .../runtimeinc/gatt/linux/socket/socket.go | 121 + .../gatt/linux/socket/socket_common.go | 24 + .../gatt/linux/socket/socket_darwin.go | 6 + .../gatt/linux/socket/socket_linux.go | 7 + .../gatt/linux/socket/socket_linux_386.go | 31 + .../runtimeinc/gatt/linux/util/util.go | 16 + .../github.com/runtimeinc/gatt/option_darwin.go | 15 + .../github.com/runtimeinc/gatt/option_linux.go | 87 + .../github.com/runtimeinc/gatt/peripheral.go | 102 + .../runtimeinc/gatt/peripheral_darwin.go | 277 ++ .../runtimeinc/gatt/peripheral_linux.go | 448 +++ .../vendor/github.com/runtimeinc/gatt/readme.md | 115 + .../vendor/github.com/runtimeinc/gatt/uuid.go | 86 + .../github.com/runtimeinc/gatt/xpc/LICENSE | 21 + .../github.com/runtimeinc/gatt/xpc/doc.go | 8 + .../runtimeinc/gatt/xpc/xpc_darwin.go | 350 +++ .../runtimeinc/gatt/xpc/xpc_wrapper_darwin.c | 85 + .../runtimeinc/gatt/xpc/xpc_wrapper_darwin.h | 32 + newtmgr/vendor/github.com/spf13/cast/.gitignore | 23 + newtmgr/vendor/github.com/spf13/cast/LICENSE | 21 + newtmgr/vendor/github.com/spf13/cast/README.md | 72 + newtmgr/vendor/github.com/spf13/cast/cast.go | 78 + newtmgr/vendor/github.com/spf13/cast/caste.go | 500 ++++ .../vendor/github.com/spf13/cobra/.gitignore | 36 + newtmgr/vendor/github.com/spf13/cobra/.mailmap | 3 + .../vendor/github.com/spf13/cobra/.travis.yml | 18 + .../vendor/github.com/spf13/cobra/LICENSE.txt | 174 ++ newtmgr/vendor/github.com/spf13/cobra/README.md | 898 ++++++ .../github.com/spf13/cobra/bash_completions.go | 630 ++++ .../github.com/spf13/cobra/bash_completions.md | 206 ++ newtmgr/vendor/github.com/spf13/cobra/cobra.go | 175 ++ .../vendor/github.com/spf13/cobra/command.go | 1256 ++++++++ .../github.com/spf13/cobra/command_notwin.go | 5 + .../github.com/spf13/cobra/command_win.go | 26 + .../spf13/jwalterweatherman/.gitignore | 22 + .../github.com/spf13/jwalterweatherman/LICENSE | 21 + .../spf13/jwalterweatherman/README.md | 161 ++ .../thatswhyyoualwaysleaveanote.go | 256 ++ .../vendor/github.com/spf13/pflag/.travis.yml | 17 + newtmgr/vendor/github.com/spf13/pflag/LICENSE | 28 + newtmgr/vendor/github.com/spf13/pflag/README.md | 275 ++ newtmgr/vendor/github.com/spf13/pflag/bool.go | 97 + newtmgr/vendor/github.com/spf13/pflag/count.go | 97 + .../vendor/github.com/spf13/pflag/duration.go | 86 + newtmgr/vendor/github.com/spf13/pflag/flag.go | 934 ++++++ .../vendor/github.com/spf13/pflag/float32.go | 91 + .../vendor/github.com/spf13/pflag/float64.go | 87 + .../vendor/github.com/spf13/pflag/golangflag.go | 104 + newtmgr/vendor/github.com/spf13/pflag/int.go | 87 + newtmgr/vendor/github.com/spf13/pflag/int32.go | 91 + newtmgr/vendor/github.com/spf13/pflag/int64.go | 87 + newtmgr/vendor/github.com/spf13/pflag/int8.go | 91 + .../vendor/github.com/spf13/pflag/int_slice.go | 128 + newtmgr/vendor/github.com/spf13/pflag/ip.go | 96 + newtmgr/vendor/github.com/spf13/pflag/ipmask.go | 122 + newtmgr/vendor/github.com/spf13/pflag/ipnet.go | 100 + newtmgr/vendor/github.com/spf13/pflag/string.go | 82 + .../github.com/spf13/pflag/string_slice.go | 111 + newtmgr/vendor/github.com/spf13/pflag/uint.go | 91 + newtmgr/vendor/github.com/spf13/pflag/uint16.go | 89 + newtmgr/vendor/github.com/spf13/pflag/uint32.go | 89 + newtmgr/vendor/github.com/spf13/pflag/uint64.go | 91 + newtmgr/vendor/github.com/spf13/pflag/uint8.go | 91 + .../vendor/github.com/tarm/serial/.travis.yml | 9 + newtmgr/vendor/github.com/tarm/serial/LICENSE | 27 + newtmgr/vendor/github.com/tarm/serial/README.md | 82 + newtmgr/vendor/github.com/tarm/serial/serial.go | 167 ++ .../github.com/tarm/serial/serial_linux.go | 157 + .../github.com/tarm/serial/serial_posix.go | 196 ++ .../github.com/tarm/serial/serial_windows.go | 327 +++ newtmgr/vendor/golang.org/x/sys/LICENSE | 27 + newtmgr/vendor/golang.org/x/sys/PATENTS | 22 + newtmgr/vendor/golang.org/x/sys/unix/.gitignore | 1 + newtmgr/vendor/golang.org/x/sys/unix/asm.s | 10 + .../golang.org/x/sys/unix/asm_darwin_386.s | 29 + .../golang.org/x/sys/unix/asm_darwin_amd64.s | 29 + .../golang.org/x/sys/unix/asm_darwin_arm.s | 30 + .../golang.org/x/sys/unix/asm_darwin_arm64.s | 30 + .../golang.org/x/sys/unix/asm_dragonfly_amd64.s | 29 + .../golang.org/x/sys/unix/asm_freebsd_386.s | 29 + .../golang.org/x/sys/unix/asm_freebsd_amd64.s | 29 + .../golang.org/x/sys/unix/asm_freebsd_arm.s | 29 + .../golang.org/x/sys/unix/asm_linux_386.s | 35 + .../golang.org/x/sys/unix/asm_linux_amd64.s | 29 + .../golang.org/x/sys/unix/asm_linux_arm.s | 29 + .../golang.org/x/sys/unix/asm_linux_arm64.s | 24 + .../golang.org/x/sys/unix/asm_linux_mips64x.s | 28 + .../golang.org/x/sys/unix/asm_linux_ppc64x.s | 28 + .../golang.org/x/sys/unix/asm_linux_s390x.s | 28 + .../golang.org/x/sys/unix/asm_netbsd_386.s | 29 + .../golang.org/x/sys/unix/asm_netbsd_amd64.s | 29 + .../golang.org/x/sys/unix/asm_netbsd_arm.s | 29 + .../golang.org/x/sys/unix/asm_openbsd_386.s | 29 + .../golang.org/x/sys/unix/asm_openbsd_amd64.s | 29 + .../golang.org/x/sys/unix/asm_solaris_amd64.s | 17 + .../golang.org/x/sys/unix/bluetooth_linux.go | 35 + .../vendor/golang.org/x/sys/unix/constants.go | 13 + .../vendor/golang.org/x/sys/unix/env_unix.go | 27 + .../vendor/golang.org/x/sys/unix/env_unset.go | 14 + newtmgr/vendor/golang.org/x/sys/unix/flock.go | 24 + .../golang.org/x/sys/unix/flock_linux_32bit.go | 13 + newtmgr/vendor/golang.org/x/sys/unix/gccgo.go | 46 + newtmgr/vendor/golang.org/x/sys/unix/gccgo_c.c | 41 + .../golang.org/x/sys/unix/gccgo_linux_amd64.go | 20 + newtmgr/vendor/golang.org/x/sys/unix/mkall.sh | 285 ++ .../vendor/golang.org/x/sys/unix/mkerrors.sh | 476 +++ newtmgr/vendor/golang.org/x/sys/unix/mkpost.go | 62 + .../vendor/golang.org/x/sys/unix/mksyscall.pl | 323 +++ .../golang.org/x/sys/unix/mksyscall_solaris.pl | 294 ++ .../golang.org/x/sys/unix/mksysctl_openbsd.pl | 264 ++ .../golang.org/x/sys/unix/mksysnum_darwin.pl | 39 + .../golang.org/x/sys/unix/mksysnum_dragonfly.pl | 50 + .../golang.org/x/sys/unix/mksysnum_freebsd.pl | 63 + .../golang.org/x/sys/unix/mksysnum_linux.pl | 58 + .../golang.org/x/sys/unix/mksysnum_netbsd.pl | 58 + .../golang.org/x/sys/unix/mksysnum_openbsd.pl | 50 + newtmgr/vendor/golang.org/x/sys/unix/race.go | 30 + newtmgr/vendor/golang.org/x/sys/unix/race0.go | 25 + .../golang.org/x/sys/unix/sockcmsg_linux.go | 36 + .../golang.org/x/sys/unix/sockcmsg_unix.go | 103 + newtmgr/vendor/golang.org/x/sys/unix/str.go | 26 + newtmgr/vendor/golang.org/x/sys/unix/syscall.go | 76 + .../vendor/golang.org/x/sys/unix/syscall_bsd.go | 628 ++++ .../golang.org/x/sys/unix/syscall_darwin.go | 511 ++++ .../golang.org/x/sys/unix/syscall_darwin_386.go | 77 + .../x/sys/unix/syscall_darwin_amd64.go | 79 + .../golang.org/x/sys/unix/syscall_darwin_arm.go | 71 + .../x/sys/unix/syscall_darwin_arm64.go | 77 + .../golang.org/x/sys/unix/syscall_dragonfly.go | 412 +++ .../x/sys/unix/syscall_dragonfly_amd64.go | 61 + .../golang.org/x/sys/unix/syscall_freebsd.go | 683 +++++ .../x/sys/unix/syscall_freebsd_386.go | 61 + .../x/sys/unix/syscall_freebsd_amd64.go | 61 + .../x/sys/unix/syscall_freebsd_arm.go | 61 + .../golang.org/x/sys/unix/syscall_linux.go | 1115 +++++++ .../golang.org/x/sys/unix/syscall_linux_386.go | 399 +++ .../x/sys/unix/syscall_linux_amd64.go | 157 + .../golang.org/x/sys/unix/syscall_linux_arm.go | 263 ++ .../x/sys/unix/syscall_linux_arm64.go | 192 ++ .../x/sys/unix/syscall_linux_mips64x.go | 215 ++ .../x/sys/unix/syscall_linux_ppc64x.go | 135 + .../x/sys/unix/syscall_linux_s390x.go | 329 +++ .../golang.org/x/sys/unix/syscall_netbsd.go | 492 ++++ .../golang.org/x/sys/unix/syscall_netbsd_386.go | 42 + .../x/sys/unix/syscall_netbsd_amd64.go | 42 + .../golang.org/x/sys/unix/syscall_netbsd_arm.go | 42 + .../golang.org/x/sys/unix/syscall_no_getwd.go | 11 + .../golang.org/x/sys/unix/syscall_openbsd.go | 304 ++ .../x/sys/unix/syscall_openbsd_386.go | 42 + .../x/sys/unix/syscall_openbsd_amd64.go | 42 + .../golang.org/x/sys/unix/syscall_solaris.go | 713 +++++ .../x/sys/unix/syscall_solaris_amd64.go | 35 + .../golang.org/x/sys/unix/syscall_unix.go | 297 ++ .../golang.org/x/sys/unix/types_darwin.go | 250 ++ .../golang.org/x/sys/unix/types_dragonfly.go | 242 ++ .../golang.org/x/sys/unix/types_freebsd.go | 353 +++ .../vendor/golang.org/x/sys/unix/types_linux.go | 450 +++ .../golang.org/x/sys/unix/types_netbsd.go | 232 ++ .../golang.org/x/sys/unix/types_openbsd.go | 244 ++ .../golang.org/x/sys/unix/types_solaris.go | 260 ++ .../golang.org/x/sys/unix/zerrors_darwin_386.go | 1576 ++++++++++ .../x/sys/unix/zerrors_darwin_amd64.go | 1576 ++++++++++ .../golang.org/x/sys/unix/zerrors_darwin_arm.go | 1293 +++++++++ .../x/sys/unix/zerrors_darwin_arm64.go | 1576 ++++++++++ .../x/sys/unix/zerrors_dragonfly_amd64.go | 1530 ++++++++++ .../x/sys/unix/zerrors_freebsd_386.go | 1743 +++++++++++ .../x/sys/unix/zerrors_freebsd_amd64.go | 1748 +++++++++++ .../x/sys/unix/zerrors_freebsd_arm.go | 1729 +++++++++++ .../golang.org/x/sys/unix/zerrors_linux_386.go | 1819 ++++++++++++ .../x/sys/unix/zerrors_linux_amd64.go | 1820 ++++++++++++ .../golang.org/x/sys/unix/zerrors_linux_arm.go | 1743 +++++++++++ .../x/sys/unix/zerrors_linux_arm64.go | 1897 ++++++++++++ .../x/sys/unix/zerrors_linux_mips64.go | 1917 ++++++++++++ .../x/sys/unix/zerrors_linux_mips64le.go | 1917 ++++++++++++ .../x/sys/unix/zerrors_linux_ppc64.go | 1970 +++++++++++++ .../x/sys/unix/zerrors_linux_ppc64le.go | 1969 +++++++++++++ .../x/sys/unix/zerrors_linux_s390x.go | 2027 +++++++++++++ .../golang.org/x/sys/unix/zerrors_netbsd_386.go | 1712 +++++++++++ .../x/sys/unix/zerrors_netbsd_amd64.go | 1702 +++++++++++ .../golang.org/x/sys/unix/zerrors_netbsd_arm.go | 1688 +++++++++++ .../x/sys/unix/zerrors_openbsd_386.go | 1584 ++++++++++ .../x/sys/unix/zerrors_openbsd_amd64.go | 1583 ++++++++++ .../x/sys/unix/zerrors_solaris_amd64.go | 1436 +++++++++ .../x/sys/unix/zsyscall_darwin_386.go | 1427 +++++++++ .../x/sys/unix/zsyscall_darwin_amd64.go | 1443 +++++++++ .../x/sys/unix/zsyscall_darwin_arm.go | 1427 +++++++++ .../x/sys/unix/zsyscall_darwin_arm64.go | 1427 +++++++++ .../x/sys/unix/zsyscall_dragonfly_amd64.go | 1413 +++++++++ .../x/sys/unix/zsyscall_freebsd_386.go | 1665 +++++++++++ .../x/sys/unix/zsyscall_freebsd_amd64.go | 1665 +++++++++++ .../x/sys/unix/zsyscall_freebsd_arm.go | 1665 +++++++++++ .../golang.org/x/sys/unix/zsyscall_linux_386.go | 1660 +++++++++++ .../x/sys/unix/zsyscall_linux_amd64.go | 1854 ++++++++++++ .../golang.org/x/sys/unix/zsyscall_linux_arm.go | 1761 +++++++++++ .../x/sys/unix/zsyscall_linux_arm64.go | 1734 +++++++++++ .../x/sys/unix/zsyscall_linux_mips64.go | 1803 ++++++++++++ .../x/sys/unix/zsyscall_linux_mips64le.go | 1803 ++++++++++++ .../x/sys/unix/zsyscall_linux_ppc64.go | 1865 ++++++++++++ .../x/sys/unix/zsyscall_linux_ppc64le.go | 1865 ++++++++++++ .../x/sys/unix/zsyscall_linux_s390x.go | 1645 +++++++++++ .../x/sys/unix/zsyscall_netbsd_386.go | 1327 +++++++++ .../x/sys/unix/zsyscall_netbsd_amd64.go | 1327 +++++++++ .../x/sys/unix/zsyscall_netbsd_arm.go | 1327 +++++++++ .../x/sys/unix/zsyscall_openbsd_386.go | 1387 +++++++++ .../x/sys/unix/zsyscall_openbsd_amd64.go | 1387 +++++++++ .../x/sys/unix/zsyscall_solaris_amd64.go | 1559 ++++++++++ .../golang.org/x/sys/unix/zsysctl_openbsd.go | 270 ++ .../golang.org/x/sys/unix/zsysnum_darwin_386.go | 398 +++ .../x/sys/unix/zsysnum_darwin_amd64.go | 398 +++ .../golang.org/x/sys/unix/zsysnum_darwin_arm.go | 358 +++ .../x/sys/unix/zsysnum_darwin_arm64.go | 398 +++ .../x/sys/unix/zsysnum_dragonfly_amd64.go | 304 ++ .../x/sys/unix/zsysnum_freebsd_386.go | 351 +++ .../x/sys/unix/zsysnum_freebsd_amd64.go | 351 +++ .../x/sys/unix/zsysnum_freebsd_arm.go | 351 +++ .../golang.org/x/sys/unix/zsysnum_linux_386.go | 355 +++ .../x/sys/unix/zsysnum_linux_amd64.go | 321 ++ .../golang.org/x/sys/unix/zsysnum_linux_arm.go | 356 +++ .../x/sys/unix/zsysnum_linux_arm64.go | 272 ++ .../x/sys/unix/zsysnum_linux_mips64.go | 327 +++ .../x/sys/unix/zsysnum_linux_mips64le.go | 327 +++ .../x/sys/unix/zsysnum_linux_ppc64.go | 360 +++ .../x/sys/unix/zsysnum_linux_ppc64le.go | 353 +++ .../x/sys/unix/zsysnum_linux_s390x.go | 328 +++ .../golang.org/x/sys/unix/zsysnum_netbsd_386.go | 273 ++ .../x/sys/unix/zsysnum_netbsd_amd64.go | 273 ++ .../golang.org/x/sys/unix/zsysnum_netbsd_arm.go | 273 ++ .../x/sys/unix/zsysnum_openbsd_386.go | 207 ++ .../x/sys/unix/zsysnum_openbsd_amd64.go | 207 ++ .../x/sys/unix/zsysnum_solaris_amd64.go | 13 + .../golang.org/x/sys/unix/ztypes_darwin_386.go | 447 +++ .../x/sys/unix/ztypes_darwin_amd64.go | 462 +++ .../golang.org/x/sys/unix/ztypes_darwin_arm.go | 449 +++ .../x/sys/unix/ztypes_darwin_arm64.go | 457 +++ .../x/sys/unix/ztypes_dragonfly_amd64.go | 443 +++ .../golang.org/x/sys/unix/ztypes_freebsd_386.go | 502 ++++ .../x/sys/unix/ztypes_freebsd_amd64.go | 505 ++++ .../golang.org/x/sys/unix/ztypes_freebsd_arm.go | 497 ++++ .../golang.org/x/sys/unix/ztypes_linux_386.go | 627 ++++ .../golang.org/x/sys/unix/ztypes_linux_amd64.go | 645 +++++ .../golang.org/x/sys/unix/ztypes_linux_arm.go | 607 ++++ .../golang.org/x/sys/unix/ztypes_linux_arm64.go | 624 ++++ .../x/sys/unix/ztypes_linux_mips64.go | 627 ++++ .../x/sys/unix/ztypes_linux_mips64le.go | 627 ++++ .../golang.org/x/sys/unix/ztypes_linux_ppc64.go | 634 ++++ .../x/sys/unix/ztypes_linux_ppc64le.go | 634 ++++ .../golang.org/x/sys/unix/ztypes_linux_s390x.go | 649 +++++ .../golang.org/x/sys/unix/ztypes_netbsd_386.go | 396 +++ .../x/sys/unix/ztypes_netbsd_amd64.go | 403 +++ .../golang.org/x/sys/unix/ztypes_netbsd_arm.go | 401 +++ .../golang.org/x/sys/unix/ztypes_openbsd_386.go | 441 +++ .../x/sys/unix/ztypes_openbsd_amd64.go | 448 +++ .../x/sys/unix/ztypes_solaris_amd64.go | 422 +++ newtmgr/vendor/gopkg.in/fsnotify.v1/.gitignore | 6 + newtmgr/vendor/gopkg.in/fsnotify.v1/.travis.yml | 29 + newtmgr/vendor/gopkg.in/fsnotify.v1/AUTHORS | 44 + .../vendor/gopkg.in/fsnotify.v1/CHANGELOG.md | 295 ++ .../vendor/gopkg.in/fsnotify.v1/CONTRIBUTING.md | 77 + newtmgr/vendor/gopkg.in/fsnotify.v1/LICENSE | 28 + newtmgr/vendor/gopkg.in/fsnotify.v1/README.md | 50 + newtmgr/vendor/gopkg.in/fsnotify.v1/fen.go | 37 + newtmgr/vendor/gopkg.in/fsnotify.v1/fsnotify.go | 62 + newtmgr/vendor/gopkg.in/fsnotify.v1/inotify.go | 325 +++ .../gopkg.in/fsnotify.v1/inotify_poller.go | 187 ++ newtmgr/vendor/gopkg.in/fsnotify.v1/kqueue.go | 503 ++++ .../gopkg.in/fsnotify.v1/open_mode_bsd.go | 11 + .../gopkg.in/fsnotify.v1/open_mode_darwin.go | 12 + newtmgr/vendor/gopkg.in/fsnotify.v1/windows.go | 561 ++++ .../vendor/mynewt.apache.org/newt/DISCLAIMER | 8 + newtmgr/vendor/mynewt.apache.org/newt/LICENSE | 244 ++ newtmgr/vendor/mynewt.apache.org/newt/NOTICE | 8 + .../vendor/mynewt.apache.org/newt/util/util.go | 421 +++ .../vendor/mynewt.apache.org/newt/viper/LICENSE | 21 + .../mynewt.apache.org/newt/viper/README.md | 620 ++++ .../mynewt.apache.org/newt/viper/flags.go | 57 + .../vendor/mynewt.apache.org/newt/viper/util.go | 195 ++ .../mynewt.apache.org/newt/viper/viper.go | 1300 +++++++++ .../vendor/mynewt.apache.org/newt/yaml/apic.go | 767 +++++ .../mynewt.apache.org/newt/yaml/decode.go | 308 ++ .../mynewt.apache.org/newt/yaml/emitterc.go | 1710 +++++++++++ .../vendor/mynewt.apache.org/newt/yaml/misc.go | 32 + .../mynewt.apache.org/newt/yaml/parserc.go | 1121 +++++++ .../mynewt.apache.org/newt/yaml/readerc.go | 419 +++ .../mynewt.apache.org/newt/yaml/scannerc.go | 2735 ++++++++++++++++++ .../vendor/mynewt.apache.org/newt/yaml/shim.go | 42 + .../mynewt.apache.org/newt/yaml/writerc.go | 114 + .../vendor/mynewt.apache.org/newt/yaml/yamlh.go | 754 +++++ .../mynewt.apache.org/newt/yaml/yamlprivateh.go | 198 ++ 368 files changed, 141784 insertions(+) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/Godeps/Godeps.json ---------------------------------------------------------------------- diff --git a/newtmgr/Godeps/Godeps.json b/newtmgr/Godeps/Godeps.json new file mode 100644 index 0000000..42d952d --- /dev/null +++ b/newtmgr/Godeps/Godeps.json @@ -0,0 +1,113 @@ +{ + "ImportPath": "mynewt.apache.org/newt/newtmgr", + "GoVersion": "go1.6", + "GodepVersion": "v74", + "Deps": [ + { + "ImportPath": "github.com/Sirupsen/logrus", + "Comment": "v0.10.0-28-ga283a10", + "Rev": "a283a10442df8dc09befd873fab202bf8a253d6a" + }, + { + "ImportPath": "github.com/inconshreveable/mousetrap", + "Rev": "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75" + }, + { + "ImportPath": "github.com/joaojeronimo/go-crc16", + "Rev": "59bd0194935ecff6f47039ee12efd09ff894a14a" + }, + { + "ImportPath": "github.com/kr/pretty", + "Comment": "go.weekly.2011-12-22-35-g737b74a", + "Rev": "737b74a46c4bf788349f72cb256fed10aea4d0ac" + }, + { + "ImportPath": "github.com/kr/text", + "Rev": "7cafcd837844e784b526369c9bce262804aebc60" + }, + { + "ImportPath": "github.com/mitchellh/go-homedir", + "Rev": "756f7b183b7ab78acdbbee5c7f392838ed459dda" + }, + { + "ImportPath": "github.com/mitchellh/mapstructure", + "Rev": "21a35fb16463dfb7c8eee579c65d995d95e64d1e" + }, + { + "ImportPath": "github.com/runtimeinc/gatt", + "Rev": "c853b3423b251fe4ba4b8ac8e2b48ef37fef52d1" + }, + { + "ImportPath": "github.com/runtimeinc/gatt/linux", + "Rev": "c853b3423b251fe4ba4b8ac8e2b48ef37fef52d1" + }, + { + "ImportPath": "github.com/runtimeinc/gatt/linux/cmd", + "Rev": "c853b3423b251fe4ba4b8ac8e2b48ef37fef52d1" + }, + { + "ImportPath": "github.com/runtimeinc/gatt/linux/evt", + "Rev": "c853b3423b251fe4ba4b8ac8e2b48ef37fef52d1" + }, + { + "ImportPath": "github.com/runtimeinc/gatt/linux/gioctl", + "Rev": "c853b3423b251fe4ba4b8ac8e2b48ef37fef52d1" + }, + { + "ImportPath": "github.com/runtimeinc/gatt/linux/socket", + "Rev": "c853b3423b251fe4ba4b8ac8e2b48ef37fef52d1" + }, + { + "ImportPath": "github.com/runtimeinc/gatt/linux/util", + "Rev": "c853b3423b251fe4ba4b8ac8e2b48ef37fef52d1" + }, + { + "ImportPath": "github.com/runtimeinc/gatt/xpc", + "Rev": "c853b3423b251fe4ba4b8ac8e2b48ef37fef52d1" + }, + { + "ImportPath": "github.com/spf13/cast", + "Rev": "27b586b42e29bec072fe7379259cc719e1289da6" + }, + { + "ImportPath": "github.com/spf13/cobra", + "Rev": "f62e98d28ab7ad31d707ba837a966378465c7b57" + }, + { + "ImportPath": "github.com/spf13/jwalterweatherman", + "Rev": "33c24e77fb80341fe7130ee7c594256ff08ccc46" + }, + { + "ImportPath": "github.com/spf13/pflag", + "Rev": "1560c1005499d61b80f865c04d39ca7505bf7f0b" + }, + { + "ImportPath": "github.com/tarm/serial", + "Rev": "37be519d49878d0098e34fb614136b81e6c87861" + }, + { + "ImportPath": "golang.org/x/sys/unix", + "Rev": "a646d33e2ee3172a661fc09bca23bb4889a41bc8" + }, + { + "ImportPath": "gopkg.in/fsnotify.v1", + "Comment": "v1.3.1", + "Rev": "a8a77c9133d2d6fd8334f3260d06f60e8d80a5fb" + }, + { + "ImportPath": "mynewt.apache.org/newt/util", + "Comment": "mynewt_0_9_0_tag-61-gc2dda8b", + "Rev": "c2dda8b2dfda07dc2658df13bd27f12aff214880" + }, + { + "ImportPath": "mynewt.apache.org/newt/viper", + "Comment": "mynewt_0_9_0_tag-61-gc2dda8b", + "Rev": "c2dda8b2dfda07dc2658df13bd27f12aff214880" + }, + { + "ImportPath": "mynewt.apache.org/newt/yaml", + "Comment": "mynewt_0_9_0_tag-61-gc2dda8b", + "Rev": "c2dda8b2dfda07dc2658df13bd27f12aff214880" + } + ] +} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/Godeps/Readme ---------------------------------------------------------------------- diff --git a/newtmgr/Godeps/Readme b/newtmgr/Godeps/Readme new file mode 100644 index 0000000..4cdaa53 --- /dev/null +++ b/newtmgr/Godeps/Readme @@ -0,0 +1,5 @@ +This directory tree is generated automatically by godep. + +Please do not edit. + +See https://github.com/tools/godep for more information. http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/.gitignore ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/.gitignore b/newtmgr/vendor/github.com/Sirupsen/logrus/.gitignore new file mode 100644 index 0000000..66be63a --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/.gitignore @@ -0,0 +1 @@ +logrus http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/.travis.yml ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/.travis.yml b/newtmgr/vendor/github.com/Sirupsen/logrus/.travis.yml new file mode 100644 index 0000000..dee4eb2 --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/.travis.yml @@ -0,0 +1,10 @@ +language: go +go: + - 1.3 + - 1.4 + - 1.5 + - 1.6 + - tip +install: + - go get -t ./... +script: GOMAXPROCS=4 GORACE="halt_on_error=1" go test -race -v ./... http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/CHANGELOG.md ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/CHANGELOG.md b/newtmgr/vendor/github.com/Sirupsen/logrus/CHANGELOG.md new file mode 100644 index 0000000..f2c2bc2 --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/CHANGELOG.md @@ -0,0 +1,66 @@ +# 0.10.0 + +* feature: Add a test hook (#180) +* feature: `ParseLevel` is now case-insensitive (#326) +* feature: `FieldLogger` interface that generalizes `Logger` and `Entry` (#308) +* performance: avoid re-allocations on `WithFields` (#335) + +# 0.9.0 + +* logrus/text_formatter: don't emit empty msg +* logrus/hooks/airbrake: move out of main repository +* logrus/hooks/sentry: move out of main repository +* logrus/hooks/papertrail: move out of main repository +* logrus/hooks/bugsnag: move out of main repository +* logrus/core: run tests with `-race` +* logrus/core: detect TTY based on `stderr` +* logrus/core: support `WithError` on logger +* logrus/core: Solaris support + +# 0.8.7 + +* logrus/core: fix possible race (#216) +* logrus/doc: small typo fixes and doc improvements + + +# 0.8.6 + +* hooks/raven: allow passing an initialized client + +# 0.8.5 + +* logrus/core: revert #208 + +# 0.8.4 + +* formatter/text: fix data race (#218) + +# 0.8.3 + +* logrus/core: fix entry log level (#208) +* logrus/core: improve performance of text formatter by 40% +* logrus/core: expose `LevelHooks` type +* logrus/core: add support for DragonflyBSD and NetBSD +* formatter/text: print structs more verbosely + +# 0.8.2 + +* logrus: fix more Fatal family functions + +# 0.8.1 + +* logrus: fix not exiting on `Fatalf` and `Fatalln` + +# 0.8.0 + +* logrus: defaults to stderr instead of stdout +* hooks/sentry: add special field for `*http.Request` +* formatter/text: ignore Windows for colors + +# 0.7.3 + +* formatter/\*: allow configuration of timestamp layout + +# 0.7.2 + +* formatter/text: Add configuration option for time format (#158) http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/LICENSE ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/LICENSE b/newtmgr/vendor/github.com/Sirupsen/logrus/LICENSE new file mode 100644 index 0000000..f090cb4 --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014 Simon Eskildsen + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/README.md ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/README.md b/newtmgr/vendor/github.com/Sirupsen/logrus/README.md new file mode 100644 index 0000000..f8302c3 --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/README.md @@ -0,0 +1,402 @@ +# Logrus <img src="http://i.imgur.com/hTeVwmJ.png"; width="40" height="40" alt=":walrus:" class="emoji" title=":walrus:"/> [](https://travis-ci.org/Sirupsen/logrus) [](https://godoc.org/github.com/Sirupsen/logrus) + +Logrus is a structured logger for Go (golang), completely API compatible with +the standard library logger. [Godoc][godoc]. **Please note the Logrus API is not +yet stable (pre 1.0). Logrus itself is completely stable and has been used in +many large deployments. The core API is unlikely to change much but please +version control your Logrus to make sure you aren't fetching latest `master` on +every build.** + +Nicely color-coded in development (when a TTY is attached, otherwise just +plain text): + + + +With `log.SetFormatter(&log.JSONFormatter{})`, for easy parsing by logstash +or Splunk: + +```json +{"animal":"walrus","level":"info","msg":"A group of walrus emerges from the +ocean","size":10,"time":"2014-03-10 19:57:38.562264131 -0400 EDT"} + +{"level":"warning","msg":"The group's number increased tremendously!", +"number":122,"omg":true,"time":"2014-03-10 19:57:38.562471297 -0400 EDT"} + +{"animal":"walrus","level":"info","msg":"A giant walrus appears!", +"size":10,"time":"2014-03-10 19:57:38.562500591 -0400 EDT"} + +{"animal":"walrus","level":"info","msg":"Tremendously sized cow enters the ocean.", +"size":9,"time":"2014-03-10 19:57:38.562527896 -0400 EDT"} + +{"level":"fatal","msg":"The ice breaks!","number":100,"omg":true, +"time":"2014-03-10 19:57:38.562543128 -0400 EDT"} +``` + +With the default `log.SetFormatter(&log.TextFormatter{})` when a TTY is not +attached, the output is compatible with the +[logfmt](http://godoc.org/github.com/kr/logfmt) format: + +```text +time="2015-03-26T01:27:38-04:00" level=debug msg="Started observing beach" animal=walrus number=8 +time="2015-03-26T01:27:38-04:00" level=info msg="A group of walrus emerges from the ocean" animal=walrus size=10 +time="2015-03-26T01:27:38-04:00" level=warning msg="The group's number increased tremendously!" number=122 omg=true +time="2015-03-26T01:27:38-04:00" level=debug msg="Temperature changes" temperature=-4 +time="2015-03-26T01:27:38-04:00" level=panic msg="It's over 9000!" animal=orca size=9009 +time="2015-03-26T01:27:38-04:00" level=fatal msg="The ice breaks!" err=&{0x2082280c0 map[animal:orca size:9009] 2015-03-26 01:27:38.441574009 -0400 EDT panic It's over 9000!} number=100 omg=true +exit status 1 +``` + +#### Example + +The simplest way to use Logrus is simply the package-level exported logger: + +```go +package main + +import ( + log "github.com/Sirupsen/logrus" +) + +func main() { + log.WithFields(log.Fields{ + "animal": "walrus", + }).Info("A walrus appears") +} +``` + +Note that it's completely api-compatible with the stdlib logger, so you can +replace your `log` imports everywhere with `log "github.com/Sirupsen/logrus"` +and you'll now have the flexibility of Logrus. You can customize it all you +want: + +```go +package main + +import ( + "os" + log "github.com/Sirupsen/logrus" +) + +func init() { + // Log as JSON instead of the default ASCII formatter. + log.SetFormatter(&log.JSONFormatter{}) + + // Output to stderr instead of stdout, could also be a file. + log.SetOutput(os.Stderr) + + // Only log the warning severity or above. + log.SetLevel(log.WarnLevel) +} + +func main() { + log.WithFields(log.Fields{ + "animal": "walrus", + "size": 10, + }).Info("A group of walrus emerges from the ocean") + + log.WithFields(log.Fields{ + "omg": true, + "number": 122, + }).Warn("The group's number increased tremendously!") + + log.WithFields(log.Fields{ + "omg": true, + "number": 100, + }).Fatal("The ice breaks!") + + // A common pattern is to re-use fields between logging statements by re-using + // the logrus.Entry returned from WithFields() + contextLogger := log.WithFields(log.Fields{ + "common": "this is a common field", + "other": "I also should be logged always", + }) + + contextLogger.Info("I'll be logged with common and other field") + contextLogger.Info("Me too") +} +``` + +For more advanced usage such as logging to multiple locations from the same +application, you can also create an instance of the `logrus` Logger: + +```go +package main + +import ( + "github.com/Sirupsen/logrus" +) + +// Create a new instance of the logger. You can have any number of instances. +var log = logrus.New() + +func main() { + // The API for setting attributes is a little different than the package level + // exported logger. See Godoc. + log.Out = os.Stderr + + log.WithFields(logrus.Fields{ + "animal": "walrus", + "size": 10, + }).Info("A group of walrus emerges from the ocean") +} +``` + +#### Fields + +Logrus encourages careful, structured logging though logging fields instead of +long, unparseable error messages. For example, instead of: `log.Fatalf("Failed +to send event %s to topic %s with key %d")`, you should log the much more +discoverable: + +```go +log.WithFields(log.Fields{ + "event": event, + "topic": topic, + "key": key, +}).Fatal("Failed to send event") +``` + +We've found this API forces you to think about logging in a way that produces +much more useful logging messages. We've been in countless situations where just +a single added field to a log statement that was already there would've saved us +hours. The `WithFields` call is optional. + +In general, with Logrus using any of the `printf`-family functions should be +seen as a hint you should add a field, however, you can still use the +`printf`-family functions with Logrus. + +#### Hooks + +You can add hooks for logging levels. For example to send errors to an exception +tracking service on `Error`, `Fatal` and `Panic`, info to StatsD or log to +multiple places simultaneously, e.g. syslog. + +Logrus comes with [built-in hooks](hooks/). Add those, or your custom hook, in +`init`: + +```go +import ( + log "github.com/Sirupsen/logrus" + "gopkg.in/gemnasium/logrus-airbrake-hook.v2" // the package is named "aibrake" + logrus_syslog "github.com/Sirupsen/logrus/hooks/syslog" + "log/syslog" +) + +func init() { + + // Use the Airbrake hook to report errors that have Error severity or above to + // an exception tracker. You can create custom hooks, see the Hooks section. + log.AddHook(airbrake.NewHook(123, "xyz", "production")) + + hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "") + if err != nil { + log.Error("Unable to connect to local syslog daemon") + } else { + log.AddHook(hook) + } +} +``` +Note: Syslog hook also support connecting to local syslog (Ex. "/dev/log" or "/var/run/syslog" or "/var/run/log"). For the detail, please check the [syslog hook README](hooks/syslog/README.md). + +| Hook | Description | +| ----- | ----------- | +| [Airbrake](https://github.com/gemnasium/logrus-airbrake-hook) | Send errors to the Airbrake API V3. Uses the official [`gobrake`](https://github.com/airbrake/gobrake) behind the scenes. | +| [Airbrake "legacy"](https://github.com/gemnasium/logrus-airbrake-legacy-hook) | Send errors to an exception tracking service compatible with the Airbrake API V2. Uses [`airbrake-go`](https://github.com/tobi/airbrake-go) behind the scenes. | +| [Papertrail](https://github.com/polds/logrus-papertrail-hook) | Send errors to the [Papertrail](https://papertrailapp.com) hosted logging service via UDP. | +| [Syslog](https://github.com/Sirupsen/logrus/blob/master/hooks/syslog/syslog.go) | Send errors to remote syslog server. Uses standard library `log/syslog` behind the scenes. | +| [Bugsnag](https://github.com/Shopify/logrus-bugsnag/blob/master/bugsnag.go) | Send errors to the Bugsnag exception tracking service. | +| [Sentry](https://github.com/evalphobia/logrus_sentry) | Send errors to the Sentry error logging and aggregation service. | +| [Hiprus](https://github.com/nubo/hiprus) | Send errors to a channel in hipchat. | +| [Logrusly](https://github.com/sebest/logrusly) | Send logs to [Loggly](https://www.loggly.com/) | +| [Slackrus](https://github.com/johntdyer/slackrus) | Hook for Slack chat. | +| [Journalhook](https://github.com/wercker/journalhook) | Hook for logging to `systemd-journald` | +| [Graylog](https://github.com/gemnasium/logrus-graylog-hook) | Hook for logging to [Graylog](http://graylog2.org/) | +| [Raygun](https://github.com/squirkle/logrus-raygun-hook) | Hook for logging to [Raygun.io](http://raygun.io/) | +| [LFShook](https://github.com/rifflock/lfshook) | Hook for logging to the local filesystem | +| [Honeybadger](https://github.com/agonzalezro/logrus_honeybadger) | Hook for sending exceptions to Honeybadger | +| [Mail](https://github.com/zbindenren/logrus_mail) | Hook for sending exceptions via mail | +| [Rollrus](https://github.com/heroku/rollrus) | Hook for sending errors to rollbar | +| [Fluentd](https://github.com/evalphobia/logrus_fluent) | Hook for logging to fluentd | +| [Mongodb](https://github.com/weekface/mgorus) | Hook for logging to mongodb | +| [Influxus] (http://github.com/vlad-doru/influxus) | Hook for concurrently logging to [InfluxDB] (http://influxdata.com/) | +| [InfluxDB](https://github.com/Abramovic/logrus_influxdb) | Hook for logging to influxdb | +| [Octokit](https://github.com/dorajistyle/logrus-octokit-hook) | Hook for logging to github via octokit | +| [DeferPanic](https://github.com/deferpanic/dp-logrus) | Hook for logging to DeferPanic | +| [Redis-Hook](https://github.com/rogierlommers/logrus-redis-hook) | Hook for logging to a ELK stack (through Redis) | +| [Amqp-Hook](https://github.com/vladoatanasov/logrus_amqp) | Hook for logging to Amqp broker (Like RabbitMQ) | +| [KafkaLogrus](https://github.com/goibibo/KafkaLogrus) | Hook for logging to kafka | +| [Typetalk](https://github.com/dragon3/logrus-typetalk-hook) | Hook for logging to [Typetalk](https://www.typetalk.in/) | +| [ElasticSearch](https://github.com/sohlich/elogrus) | Hook for logging to ElasticSearch| +| [Sumorus](https://github.com/doublefree/sumorus) | Hook for logging to [SumoLogic](https://www.sumologic.com/)| +| [Logstash](https://github.com/bshuster-repo/logrus-logstash-hook) | Hook for logging to [Logstash](https://www.elastic.co/products/logstash) | + +#### Level logging + +Logrus has six logging levels: Debug, Info, Warning, Error, Fatal and Panic. + +```go +log.Debug("Useful debugging information.") +log.Info("Something noteworthy happened!") +log.Warn("You should probably take a look at this.") +log.Error("Something failed but I'm not quitting.") +// Calls os.Exit(1) after logging +log.Fatal("Bye.") +// Calls panic() after logging +log.Panic("I'm bailing.") +``` + +You can set the logging level on a `Logger`, then it will only log entries with +that severity or anything above it: + +```go +// Will log anything that is info or above (warn, error, fatal, panic). Default. +log.SetLevel(log.InfoLevel) +``` + +It may be useful to set `log.Level = logrus.DebugLevel` in a debug or verbose +environment if your application has that. + +#### Entries + +Besides the fields added with `WithField` or `WithFields` some fields are +automatically added to all logging events: + +1. `time`. The timestamp when the entry was created. +2. `msg`. The logging message passed to `{Info,Warn,Error,Fatal,Panic}` after + the `AddFields` call. E.g. `Failed to send event.` +3. `level`. The logging level. E.g. `info`. + +#### Environments + +Logrus has no notion of environment. + +If you wish for hooks and formatters to only be used in specific environments, +you should handle that yourself. For example, if your application has a global +variable `Environment`, which is a string representation of the environment you +could do: + +```go +import ( + log "github.com/Sirupsen/logrus" +) + +init() { + // do something here to set environment depending on an environment variable + // or command-line flag + if Environment == "production" { + log.SetFormatter(&log.JSONFormatter{}) + } else { + // The TextFormatter is default, you don't actually have to do this. + log.SetFormatter(&log.TextFormatter{}) + } +} +``` + +This configuration is how `logrus` was intended to be used, but JSON in +production is mostly only useful if you do log aggregation with tools like +Splunk or Logstash. + +#### Formatters + +The built-in logging formatters are: + +* `logrus.TextFormatter`. Logs the event in colors if stdout is a tty, otherwise + without colors. + * *Note:* to force colored output when there is no TTY, set the `ForceColors` + field to `true`. To force no colored output even if there is a TTY set the + `DisableColors` field to `true` +* `logrus.JSONFormatter`. Logs fields as JSON. + +Third party logging formatters: + +* [`logstash`](https://github.com/bshuster-repo/logrus-logstash-hook). Logs fields as [Logstash](http://logstash.net) Events. +* [`prefixed`](https://github.com/x-cray/logrus-prefixed-formatter). Displays log entry source along with alternative layout. +* [`zalgo`](https://github.com/aybabtme/logzalgo). Invoking the PÍÌ«o̳̼ÌwÌÍÌ°Íe̬ÍÌÍrÍ̼̹̲ Ì«ÍÍ̳ÍÅÌ ÍÍÌfÌÍÌ Í̲ÌÍÍZÌ̫̤̫ͪaÍ̬ÍÌlÍÍg̳̥oÌ°Ì¥Ì !Ì£Í̲̻ÍÌ ÌÌ̦̹̦. + +You can define your formatter by implementing the `Formatter` interface, +requiring a `Format` method. `Format` takes an `*Entry`. `entry.Data` is a +`Fields` type (`map[string]interface{}`) with all your fields as well as the +default ones (see Entries section above): + +```go +type MyJSONFormatter struct { +} + +log.SetFormatter(new(MyJSONFormatter)) + +func (f *MyJSONFormatter) Format(entry *Entry) ([]byte, error) { + // Note this doesn't include Time, Level and Message which are available on + // the Entry. Consult `godoc` on information about those fields or read the + // source of the official loggers. + serialized, err := json.Marshal(entry.Data) + if err != nil { + return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err) + } + return append(serialized, '\n'), nil +} +``` + +#### Logger as an `io.Writer` + +Logrus can be transformed into an `io.Writer`. That writer is the end of an `io.Pipe` and it is your responsibility to close it. + +```go +w := logger.Writer() +defer w.Close() + +srv := http.Server{ + // create a stdlib log.Logger that writes to + // logrus.Logger. + ErrorLog: log.New(w, "", 0), +} +``` + +Each line written to that writer will be printed the usual way, using formatters +and hooks. The level for those entries is `info`. + +#### Rotation + +Log rotation is not provided with Logrus. Log rotation should be done by an +external program (like `logrotate(8)`) that can compress and delete old log +entries. It should not be a feature of the application-level logger. + +#### Tools + +| Tool | Description | +| ---- | ----------- | +|[Logrus Mate](https://github.com/gogap/logrus_mate)|Logrus mate is a tool for Logrus to manage loggers, you can initial logger's level, hook and formatter by config file, the logger will generated with different config at different environment.| + +#### Testing + +Logrus has a built in facility for asserting the presence of log messages. This is implemented through the `test` hook and provides: + +* decorators for existing logger (`test.NewLocal` and `test.NewGlobal`) which basically just add the `test` hook +* a test logger (`test.NewNullLogger`) that just records log messages (and does not output any): + +```go +logger, hook := NewNullLogger() +logger.Error("Hello error") + +assert.Equal(1, len(hook.Entries)) +assert.Equal(logrus.ErrorLevel, hook.LastEntry().Level) +assert.Equal("Hello error", hook.LastEntry().Message) + +hook.Reset() +assert.Nil(hook.LastEntry()) +``` + +#### Fatal handlers + +Logrus can register one or more functions that will be called when any `fatal` +level message is logged. The registered handlers will be executed before +logrus performs a `os.Exit(1)`. This behavior may be helpful if callers need +to gracefully shutdown. Unlike a `panic("Something went wrong...")` call which can be intercepted with a deferred `recover` a call to `os.Exit(1)` can not be intercepted. + +``` +... +handler := func() { + // gracefully shutdown something... +} +logrus.RegisterExitHandler(handler) +... +``` http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/alt_exit.go ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/alt_exit.go b/newtmgr/vendor/github.com/Sirupsen/logrus/alt_exit.go new file mode 100644 index 0000000..b4c9e84 --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/alt_exit.go @@ -0,0 +1,64 @@ +package logrus + +// The following code was sourced and modified from the +// https://bitbucket.org/tebeka/atexit package governed by the following license: +// +// Copyright (c) 2012 Miki Tebeka <[email protected]>. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of +// this software and associated documentation files (the "Software"), to deal in +// the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do so, +// subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +import ( + "fmt" + "os" +) + +var handlers = []func(){} + +func runHandler(handler func()) { + defer func() { + if err := recover(); err != nil { + fmt.Fprintln(os.Stderr, "Error: Logrus exit handler error:", err) + } + }() + + handler() +} + +func runHandlers() { + for _, handler := range handlers { + runHandler(handler) + } +} + +// Exit runs all the Logrus atexit handlers and then terminates the program using os.Exit(code) +func Exit(code int) { + runHandlers() + os.Exit(code) +} + +// RegisterExitHandler adds a Logrus Exit handler, call logrus.Exit to invoke +// all handlers. The handlers will also be invoked when any Fatal log entry is +// made. +// +// This method is useful when a caller wishes to use logrus to log a fatal +// message but also needs to gracefully shutdown. An example usecase could be +// closing database connections, or sending a alert that the application is +// closing. +func RegisterExitHandler(handler func()) { + handlers = append(handlers, handler) +} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/doc.go ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/doc.go b/newtmgr/vendor/github.com/Sirupsen/logrus/doc.go new file mode 100644 index 0000000..dddd5f8 --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/doc.go @@ -0,0 +1,26 @@ +/* +Package logrus is a structured logger for Go, completely API compatible with the standard library logger. + + +The simplest way to use Logrus is simply the package-level exported logger: + + package main + + import ( + log "github.com/Sirupsen/logrus" + ) + + func main() { + log.WithFields(log.Fields{ + "animal": "walrus", + "number": 1, + "size": 10, + }).Info("A walrus appears") + } + +Output: + time="2015-09-07T08:48:33Z" level=info msg="A walrus appears" animal=walrus number=1 size=10 + +For a full guide visit https://github.com/Sirupsen/logrus +*/ +package logrus http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/entry.go ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/entry.go b/newtmgr/vendor/github.com/Sirupsen/logrus/entry.go new file mode 100644 index 0000000..54bfc57 --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/entry.go @@ -0,0 +1,264 @@ +package logrus + +import ( + "bytes" + "fmt" + "io" + "os" + "time" +) + +// Defines the key when adding errors using WithError. +var ErrorKey = "error" + +// An entry is the final or intermediate Logrus logging entry. It contains all +// the fields passed with WithField{,s}. It's finally logged when Debug, Info, +// Warn, Error, Fatal or Panic is called on it. These objects can be reused and +// passed around as much as you wish to avoid field duplication. +type Entry struct { + Logger *Logger + + // Contains all the fields set by the user. + Data Fields + + // Time at which the log entry was created + Time time.Time + + // Level the log entry was logged at: Debug, Info, Warn, Error, Fatal or Panic + Level Level + + // Message passed to Debug, Info, Warn, Error, Fatal or Panic + Message string +} + +func NewEntry(logger *Logger) *Entry { + return &Entry{ + Logger: logger, + // Default is three fields, give a little extra room + Data: make(Fields, 5), + } +} + +// Returns a reader for the entry, which is a proxy to the formatter. +func (entry *Entry) Reader() (*bytes.Buffer, error) { + serialized, err := entry.Logger.Formatter.Format(entry) + return bytes.NewBuffer(serialized), err +} + +// Returns the string representation from the reader and ultimately the +// formatter. +func (entry *Entry) String() (string, error) { + reader, err := entry.Reader() + if err != nil { + return "", err + } + + return reader.String(), err +} + +// Add an error as single field (using the key defined in ErrorKey) to the Entry. +func (entry *Entry) WithError(err error) *Entry { + return entry.WithField(ErrorKey, err) +} + +// Add a single field to the Entry. +func (entry *Entry) WithField(key string, value interface{}) *Entry { + return entry.WithFields(Fields{key: value}) +} + +// Add a map of fields to the Entry. +func (entry *Entry) WithFields(fields Fields) *Entry { + data := make(Fields, len(entry.Data)+len(fields)) + for k, v := range entry.Data { + data[k] = v + } + for k, v := range fields { + data[k] = v + } + return &Entry{Logger: entry.Logger, Data: data} +} + +// This function is not declared with a pointer value because otherwise +// race conditions will occur when using multiple goroutines +func (entry Entry) log(level Level, msg string) { + entry.Time = time.Now() + entry.Level = level + entry.Message = msg + + if err := entry.Logger.Hooks.Fire(level, &entry); err != nil { + entry.Logger.mu.Lock() + fmt.Fprintf(os.Stderr, "Failed to fire hook: %v\n", err) + entry.Logger.mu.Unlock() + } + + reader, err := entry.Reader() + if err != nil { + entry.Logger.mu.Lock() + fmt.Fprintf(os.Stderr, "Failed to obtain reader, %v\n", err) + entry.Logger.mu.Unlock() + } + + entry.Logger.mu.Lock() + defer entry.Logger.mu.Unlock() + + _, err = io.Copy(entry.Logger.Out, reader) + if err != nil { + fmt.Fprintf(os.Stderr, "Failed to write to log, %v\n", err) + } + + // To avoid Entry#log() returning a value that only would make sense for + // panic() to use in Entry#Panic(), we avoid the allocation by checking + // directly here. + if level <= PanicLevel { + panic(&entry) + } +} + +func (entry *Entry) Debug(args ...interface{}) { + if entry.Logger.Level >= DebugLevel { + entry.log(DebugLevel, fmt.Sprint(args...)) + } +} + +func (entry *Entry) Print(args ...interface{}) { + entry.Info(args...) +} + +func (entry *Entry) Info(args ...interface{}) { + if entry.Logger.Level >= InfoLevel { + entry.log(InfoLevel, fmt.Sprint(args...)) + } +} + +func (entry *Entry) Warn(args ...interface{}) { + if entry.Logger.Level >= WarnLevel { + entry.log(WarnLevel, fmt.Sprint(args...)) + } +} + +func (entry *Entry) Warning(args ...interface{}) { + entry.Warn(args...) +} + +func (entry *Entry) Error(args ...interface{}) { + if entry.Logger.Level >= ErrorLevel { + entry.log(ErrorLevel, fmt.Sprint(args...)) + } +} + +func (entry *Entry) Fatal(args ...interface{}) { + if entry.Logger.Level >= FatalLevel { + entry.log(FatalLevel, fmt.Sprint(args...)) + } + Exit(1) +} + +func (entry *Entry) Panic(args ...interface{}) { + if entry.Logger.Level >= PanicLevel { + entry.log(PanicLevel, fmt.Sprint(args...)) + } + panic(fmt.Sprint(args...)) +} + +// Entry Printf family functions + +func (entry *Entry) Debugf(format string, args ...interface{}) { + if entry.Logger.Level >= DebugLevel { + entry.Debug(fmt.Sprintf(format, args...)) + } +} + +func (entry *Entry) Infof(format string, args ...interface{}) { + if entry.Logger.Level >= InfoLevel { + entry.Info(fmt.Sprintf(format, args...)) + } +} + +func (entry *Entry) Printf(format string, args ...interface{}) { + entry.Infof(format, args...) +} + +func (entry *Entry) Warnf(format string, args ...interface{}) { + if entry.Logger.Level >= WarnLevel { + entry.Warn(fmt.Sprintf(format, args...)) + } +} + +func (entry *Entry) Warningf(format string, args ...interface{}) { + entry.Warnf(format, args...) +} + +func (entry *Entry) Errorf(format string, args ...interface{}) { + if entry.Logger.Level >= ErrorLevel { + entry.Error(fmt.Sprintf(format, args...)) + } +} + +func (entry *Entry) Fatalf(format string, args ...interface{}) { + if entry.Logger.Level >= FatalLevel { + entry.Fatal(fmt.Sprintf(format, args...)) + } + Exit(1) +} + +func (entry *Entry) Panicf(format string, args ...interface{}) { + if entry.Logger.Level >= PanicLevel { + entry.Panic(fmt.Sprintf(format, args...)) + } +} + +// Entry Println family functions + +func (entry *Entry) Debugln(args ...interface{}) { + if entry.Logger.Level >= DebugLevel { + entry.Debug(entry.sprintlnn(args...)) + } +} + +func (entry *Entry) Infoln(args ...interface{}) { + if entry.Logger.Level >= InfoLevel { + entry.Info(entry.sprintlnn(args...)) + } +} + +func (entry *Entry) Println(args ...interface{}) { + entry.Infoln(args...) +} + +func (entry *Entry) Warnln(args ...interface{}) { + if entry.Logger.Level >= WarnLevel { + entry.Warn(entry.sprintlnn(args...)) + } +} + +func (entry *Entry) Warningln(args ...interface{}) { + entry.Warnln(args...) +} + +func (entry *Entry) Errorln(args ...interface{}) { + if entry.Logger.Level >= ErrorLevel { + entry.Error(entry.sprintlnn(args...)) + } +} + +func (entry *Entry) Fatalln(args ...interface{}) { + if entry.Logger.Level >= FatalLevel { + entry.Fatal(entry.sprintlnn(args...)) + } + Exit(1) +} + +func (entry *Entry) Panicln(args ...interface{}) { + if entry.Logger.Level >= PanicLevel { + entry.Panic(entry.sprintlnn(args...)) + } +} + +// Sprintlnn => Sprint no newline. This is to get the behavior of how +// fmt.Sprintln where spaces are always added between operands, regardless of +// their type. Instead of vendoring the Sprintln implementation to spare a +// string allocation, we do the simplest thing. +func (entry *Entry) sprintlnn(args ...interface{}) string { + msg := fmt.Sprintln(args...) + return msg[:len(msg)-1] +} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/exported.go ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/exported.go b/newtmgr/vendor/github.com/Sirupsen/logrus/exported.go new file mode 100644 index 0000000..9a0120a --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/exported.go @@ -0,0 +1,193 @@ +package logrus + +import ( + "io" +) + +var ( + // std is the name of the standard logger in stdlib `log` + std = New() +) + +func StandardLogger() *Logger { + return std +} + +// SetOutput sets the standard logger output. +func SetOutput(out io.Writer) { + std.mu.Lock() + defer std.mu.Unlock() + std.Out = out +} + +// SetFormatter sets the standard logger formatter. +func SetFormatter(formatter Formatter) { + std.mu.Lock() + defer std.mu.Unlock() + std.Formatter = formatter +} + +// SetLevel sets the standard logger level. +func SetLevel(level Level) { + std.mu.Lock() + defer std.mu.Unlock() + std.Level = level +} + +// GetLevel returns the standard logger level. +func GetLevel() Level { + std.mu.Lock() + defer std.mu.Unlock() + return std.Level +} + +// AddHook adds a hook to the standard logger hooks. +func AddHook(hook Hook) { + std.mu.Lock() + defer std.mu.Unlock() + std.Hooks.Add(hook) +} + +// WithError creates an entry from the standard logger and adds an error to it, using the value defined in ErrorKey as key. +func WithError(err error) *Entry { + return std.WithField(ErrorKey, err) +} + +// WithField creates an entry from the standard logger and adds a field to +// it. If you want multiple fields, use `WithFields`. +// +// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal +// or Panic on the Entry it returns. +func WithField(key string, value interface{}) *Entry { + return std.WithField(key, value) +} + +// WithFields creates an entry from the standard logger and adds multiple +// fields to it. This is simply a helper for `WithField`, invoking it +// once for each field. +// +// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal +// or Panic on the Entry it returns. +func WithFields(fields Fields) *Entry { + return std.WithFields(fields) +} + +// Debug logs a message at level Debug on the standard logger. +func Debug(args ...interface{}) { + std.Debug(args...) +} + +// Print logs a message at level Info on the standard logger. +func Print(args ...interface{}) { + std.Print(args...) +} + +// Info logs a message at level Info on the standard logger. +func Info(args ...interface{}) { + std.Info(args...) +} + +// Warn logs a message at level Warn on the standard logger. +func Warn(args ...interface{}) { + std.Warn(args...) +} + +// Warning logs a message at level Warn on the standard logger. +func Warning(args ...interface{}) { + std.Warning(args...) +} + +// Error logs a message at level Error on the standard logger. +func Error(args ...interface{}) { + std.Error(args...) +} + +// Panic logs a message at level Panic on the standard logger. +func Panic(args ...interface{}) { + std.Panic(args...) +} + +// Fatal logs a message at level Fatal on the standard logger. +func Fatal(args ...interface{}) { + std.Fatal(args...) +} + +// Debugf logs a message at level Debug on the standard logger. +func Debugf(format string, args ...interface{}) { + std.Debugf(format, args...) +} + +// Printf logs a message at level Info on the standard logger. +func Printf(format string, args ...interface{}) { + std.Printf(format, args...) +} + +// Infof logs a message at level Info on the standard logger. +func Infof(format string, args ...interface{}) { + std.Infof(format, args...) +} + +// Warnf logs a message at level Warn on the standard logger. +func Warnf(format string, args ...interface{}) { + std.Warnf(format, args...) +} + +// Warningf logs a message at level Warn on the standard logger. +func Warningf(format string, args ...interface{}) { + std.Warningf(format, args...) +} + +// Errorf logs a message at level Error on the standard logger. +func Errorf(format string, args ...interface{}) { + std.Errorf(format, args...) +} + +// Panicf logs a message at level Panic on the standard logger. +func Panicf(format string, args ...interface{}) { + std.Panicf(format, args...) +} + +// Fatalf logs a message at level Fatal on the standard logger. +func Fatalf(format string, args ...interface{}) { + std.Fatalf(format, args...) +} + +// Debugln logs a message at level Debug on the standard logger. +func Debugln(args ...interface{}) { + std.Debugln(args...) +} + +// Println logs a message at level Info on the standard logger. +func Println(args ...interface{}) { + std.Println(args...) +} + +// Infoln logs a message at level Info on the standard logger. +func Infoln(args ...interface{}) { + std.Infoln(args...) +} + +// Warnln logs a message at level Warn on the standard logger. +func Warnln(args ...interface{}) { + std.Warnln(args...) +} + +// Warningln logs a message at level Warn on the standard logger. +func Warningln(args ...interface{}) { + std.Warningln(args...) +} + +// Errorln logs a message at level Error on the standard logger. +func Errorln(args ...interface{}) { + std.Errorln(args...) +} + +// Panicln logs a message at level Panic on the standard logger. +func Panicln(args ...interface{}) { + std.Panicln(args...) +} + +// Fatalln logs a message at level Fatal on the standard logger. +func Fatalln(args ...interface{}) { + std.Fatalln(args...) +} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/formatter.go ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/formatter.go b/newtmgr/vendor/github.com/Sirupsen/logrus/formatter.go new file mode 100644 index 0000000..b5fbe93 --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/formatter.go @@ -0,0 +1,45 @@ +package logrus + +import "time" + +const DefaultTimestampFormat = time.RFC3339 + +// The Formatter interface is used to implement a custom Formatter. It takes an +// `Entry`. It exposes all the fields, including the default ones: +// +// * `entry.Data["msg"]`. The message passed from Info, Warn, Error .. +// * `entry.Data["time"]`. The timestamp. +// * `entry.Data["level"]. The level the entry was logged at. +// +// Any additional fields added with `WithField` or `WithFields` are also in +// `entry.Data`. Format is expected to return an array of bytes which are then +// logged to `logger.Out`. +type Formatter interface { + Format(*Entry) ([]byte, error) +} + +// This is to not silently overwrite `time`, `msg` and `level` fields when +// dumping it. If this code wasn't there doing: +// +// logrus.WithField("level", 1).Info("hello") +// +// Would just silently drop the user provided level. Instead with this code +// it'll logged as: +// +// {"level": "info", "fields.level": 1, "msg": "hello", "time": "..."} +// +// It's not exported because it's still using Data in an opinionated way. It's to +// avoid code duplication between the two default formatters. +func prefixFieldClashes(data Fields) { + if t, ok := data["time"]; ok { + data["fields.time"] = t + } + + if m, ok := data["msg"]; ok { + data["fields.msg"] = m + } + + if l, ok := data["level"]; ok { + data["fields.level"] = l + } +} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/hooks.go ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/hooks.go b/newtmgr/vendor/github.com/Sirupsen/logrus/hooks.go new file mode 100644 index 0000000..3f151cd --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/hooks.go @@ -0,0 +1,34 @@ +package logrus + +// A hook to be fired when logging on the logging levels returned from +// `Levels()` on your implementation of the interface. Note that this is not +// fired in a goroutine or a channel with workers, you should handle such +// functionality yourself if your call is non-blocking and you don't wish for +// the logging calls for levels returned from `Levels()` to block. +type Hook interface { + Levels() []Level + Fire(*Entry) error +} + +// Internal type for storing the hooks on a logger instance. +type LevelHooks map[Level][]Hook + +// Add a hook to an instance of logger. This is called with +// `log.Hooks.Add(new(MyHook))` where `MyHook` implements the `Hook` interface. +func (hooks LevelHooks) Add(hook Hook) { + for _, level := range hook.Levels() { + hooks[level] = append(hooks[level], hook) + } +} + +// Fire all the hooks for the passed level. Used by `entry.log` to fire +// appropriate hooks for a log entry. +func (hooks LevelHooks) Fire(level Level, entry *Entry) error { + for _, hook := range hooks[level] { + if err := hook.Fire(entry); err != nil { + return err + } + } + + return nil +} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/json_formatter.go ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/json_formatter.go b/newtmgr/vendor/github.com/Sirupsen/logrus/json_formatter.go new file mode 100644 index 0000000..2ad6dc5 --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/json_formatter.go @@ -0,0 +1,41 @@ +package logrus + +import ( + "encoding/json" + "fmt" +) + +type JSONFormatter struct { + // TimestampFormat sets the format used for marshaling timestamps. + TimestampFormat string +} + +func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) { + data := make(Fields, len(entry.Data)+3) + for k, v := range entry.Data { + switch v := v.(type) { + case error: + // Otherwise errors are ignored by `encoding/json` + // https://github.com/Sirupsen/logrus/issues/137 + data[k] = v.Error() + default: + data[k] = v + } + } + prefixFieldClashes(data) + + timestampFormat := f.TimestampFormat + if timestampFormat == "" { + timestampFormat = DefaultTimestampFormat + } + + data["time"] = entry.Time.Format(timestampFormat) + data["msg"] = entry.Message + data["level"] = entry.Level.String() + + serialized, err := json.Marshal(data) + if err != nil { + return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err) + } + return append(serialized, '\n'), nil +} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/logger.go ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/logger.go b/newtmgr/vendor/github.com/Sirupsen/logrus/logger.go new file mode 100644 index 0000000..9052a80 --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/logger.go @@ -0,0 +1,212 @@ +package logrus + +import ( + "io" + "os" + "sync" +) + +type Logger struct { + // The logs are `io.Copy`'d to this in a mutex. It's common to set this to a + // file, or leave it default which is `os.Stderr`. You can also set this to + // something more adventorous, such as logging to Kafka. + Out io.Writer + // Hooks for the logger instance. These allow firing events based on logging + // levels and log entries. For example, to send errors to an error tracking + // service, log to StatsD or dump the core on fatal errors. + Hooks LevelHooks + // All log entries pass through the formatter before logged to Out. The + // included formatters are `TextFormatter` and `JSONFormatter` for which + // TextFormatter is the default. In development (when a TTY is attached) it + // logs with colors, but to a file it wouldn't. You can easily implement your + // own that implements the `Formatter` interface, see the `README` or included + // formatters for examples. + Formatter Formatter + // The logging level the logger should log at. This is typically (and defaults + // to) `logrus.Info`, which allows Info(), Warn(), Error() and Fatal() to be + // logged. `logrus.Debug` is useful in + Level Level + // Used to sync writing to the log. + mu sync.Mutex +} + +// Creates a new logger. Configuration should be set by changing `Formatter`, +// `Out` and `Hooks` directly on the default logger instance. You can also just +// instantiate your own: +// +// var log = &Logger{ +// Out: os.Stderr, +// Formatter: new(JSONFormatter), +// Hooks: make(LevelHooks), +// Level: logrus.DebugLevel, +// } +// +// It's recommended to make this a global instance called `log`. +func New() *Logger { + return &Logger{ + Out: os.Stderr, + Formatter: new(TextFormatter), + Hooks: make(LevelHooks), + Level: InfoLevel, + } +} + +// Adds a field to the log entry, note that it doesn't log until you call +// Debug, Print, Info, Warn, Fatal or Panic. It only creates a log entry. +// If you want multiple fields, use `WithFields`. +func (logger *Logger) WithField(key string, value interface{}) *Entry { + return NewEntry(logger).WithField(key, value) +} + +// Adds a struct of fields to the log entry. All it does is call `WithField` for +// each `Field`. +func (logger *Logger) WithFields(fields Fields) *Entry { + return NewEntry(logger).WithFields(fields) +} + +// Add an error as single field to the log entry. All it does is call +// `WithError` for the given `error`. +func (logger *Logger) WithError(err error) *Entry { + return NewEntry(logger).WithError(err) +} + +func (logger *Logger) Debugf(format string, args ...interface{}) { + if logger.Level >= DebugLevel { + NewEntry(logger).Debugf(format, args...) + } +} + +func (logger *Logger) Infof(format string, args ...interface{}) { + if logger.Level >= InfoLevel { + NewEntry(logger).Infof(format, args...) + } +} + +func (logger *Logger) Printf(format string, args ...interface{}) { + NewEntry(logger).Printf(format, args...) +} + +func (logger *Logger) Warnf(format string, args ...interface{}) { + if logger.Level >= WarnLevel { + NewEntry(logger).Warnf(format, args...) + } +} + +func (logger *Logger) Warningf(format string, args ...interface{}) { + if logger.Level >= WarnLevel { + NewEntry(logger).Warnf(format, args...) + } +} + +func (logger *Logger) Errorf(format string, args ...interface{}) { + if logger.Level >= ErrorLevel { + NewEntry(logger).Errorf(format, args...) + } +} + +func (logger *Logger) Fatalf(format string, args ...interface{}) { + if logger.Level >= FatalLevel { + NewEntry(logger).Fatalf(format, args...) + } + Exit(1) +} + +func (logger *Logger) Panicf(format string, args ...interface{}) { + if logger.Level >= PanicLevel { + NewEntry(logger).Panicf(format, args...) + } +} + +func (logger *Logger) Debug(args ...interface{}) { + if logger.Level >= DebugLevel { + NewEntry(logger).Debug(args...) + } +} + +func (logger *Logger) Info(args ...interface{}) { + if logger.Level >= InfoLevel { + NewEntry(logger).Info(args...) + } +} + +func (logger *Logger) Print(args ...interface{}) { + NewEntry(logger).Info(args...) +} + +func (logger *Logger) Warn(args ...interface{}) { + if logger.Level >= WarnLevel { + NewEntry(logger).Warn(args...) + } +} + +func (logger *Logger) Warning(args ...interface{}) { + if logger.Level >= WarnLevel { + NewEntry(logger).Warn(args...) + } +} + +func (logger *Logger) Error(args ...interface{}) { + if logger.Level >= ErrorLevel { + NewEntry(logger).Error(args...) + } +} + +func (logger *Logger) Fatal(args ...interface{}) { + if logger.Level >= FatalLevel { + NewEntry(logger).Fatal(args...) + } + Exit(1) +} + +func (logger *Logger) Panic(args ...interface{}) { + if logger.Level >= PanicLevel { + NewEntry(logger).Panic(args...) + } +} + +func (logger *Logger) Debugln(args ...interface{}) { + if logger.Level >= DebugLevel { + NewEntry(logger).Debugln(args...) + } +} + +func (logger *Logger) Infoln(args ...interface{}) { + if logger.Level >= InfoLevel { + NewEntry(logger).Infoln(args...) + } +} + +func (logger *Logger) Println(args ...interface{}) { + NewEntry(logger).Println(args...) +} + +func (logger *Logger) Warnln(args ...interface{}) { + if logger.Level >= WarnLevel { + NewEntry(logger).Warnln(args...) + } +} + +func (logger *Logger) Warningln(args ...interface{}) { + if logger.Level >= WarnLevel { + NewEntry(logger).Warnln(args...) + } +} + +func (logger *Logger) Errorln(args ...interface{}) { + if logger.Level >= ErrorLevel { + NewEntry(logger).Errorln(args...) + } +} + +func (logger *Logger) Fatalln(args ...interface{}) { + if logger.Level >= FatalLevel { + NewEntry(logger).Fatalln(args...) + } + Exit(1) +} + +func (logger *Logger) Panicln(args ...interface{}) { + if logger.Level >= PanicLevel { + NewEntry(logger).Panicln(args...) + } +} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/logrus.go ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/logrus.go b/newtmgr/vendor/github.com/Sirupsen/logrus/logrus.go new file mode 100644 index 0000000..e596691 --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/logrus.go @@ -0,0 +1,143 @@ +package logrus + +import ( + "fmt" + "log" + "strings" +) + +// Fields type, used to pass to `WithFields`. +type Fields map[string]interface{} + +// Level type +type Level uint8 + +// Convert the Level to a string. E.g. PanicLevel becomes "panic". +func (level Level) String() string { + switch level { + case DebugLevel: + return "debug" + case InfoLevel: + return "info" + case WarnLevel: + return "warning" + case ErrorLevel: + return "error" + case FatalLevel: + return "fatal" + case PanicLevel: + return "panic" + } + + return "unknown" +} + +// ParseLevel takes a string level and returns the Logrus log level constant. +func ParseLevel(lvl string) (Level, error) { + switch strings.ToLower(lvl) { + case "panic": + return PanicLevel, nil + case "fatal": + return FatalLevel, nil + case "error": + return ErrorLevel, nil + case "warn", "warning": + return WarnLevel, nil + case "info": + return InfoLevel, nil + case "debug": + return DebugLevel, nil + } + + var l Level + return l, fmt.Errorf("not a valid logrus Level: %q", lvl) +} + +// A constant exposing all logging levels +var AllLevels = []Level{ + PanicLevel, + FatalLevel, + ErrorLevel, + WarnLevel, + InfoLevel, + DebugLevel, +} + +// These are the different logging levels. You can set the logging level to log +// on your instance of logger, obtained with `logrus.New()`. +const ( + // PanicLevel level, highest level of severity. Logs and then calls panic with the + // message passed to Debug, Info, ... + PanicLevel Level = iota + // FatalLevel level. Logs and then calls `os.Exit(1)`. It will exit even if the + // logging level is set to Panic. + FatalLevel + // ErrorLevel level. Logs. Used for errors that should definitely be noted. + // Commonly used for hooks to send errors to an error tracking service. + ErrorLevel + // WarnLevel level. Non-critical entries that deserve eyes. + WarnLevel + // InfoLevel level. General operational entries about what's going on inside the + // application. + InfoLevel + // DebugLevel level. Usually only enabled when debugging. Very verbose logging. + DebugLevel +) + +// Won't compile if StdLogger can't be realized by a log.Logger +var ( + _ StdLogger = &log.Logger{} + _ StdLogger = &Entry{} + _ StdLogger = &Logger{} +) + +// StdLogger is what your logrus-enabled library should take, that way +// it'll accept a stdlib logger and a logrus logger. There's no standard +// interface, this is the closest we get, unfortunately. +type StdLogger interface { + Print(...interface{}) + Printf(string, ...interface{}) + Println(...interface{}) + + Fatal(...interface{}) + Fatalf(string, ...interface{}) + Fatalln(...interface{}) + + Panic(...interface{}) + Panicf(string, ...interface{}) + Panicln(...interface{}) +} + +// The FieldLogger interface generalizes the Entry and Logger types +type FieldLogger interface { + WithField(key string, value interface{}) *Entry + WithFields(fields Fields) *Entry + WithError(err error) *Entry + + Debugf(format string, args ...interface{}) + Infof(format string, args ...interface{}) + Printf(format string, args ...interface{}) + Warnf(format string, args ...interface{}) + Warningf(format string, args ...interface{}) + Errorf(format string, args ...interface{}) + Fatalf(format string, args ...interface{}) + Panicf(format string, args ...interface{}) + + Debug(args ...interface{}) + Info(args ...interface{}) + Print(args ...interface{}) + Warn(args ...interface{}) + Warning(args ...interface{}) + Error(args ...interface{}) + Fatal(args ...interface{}) + Panic(args ...interface{}) + + Debugln(args ...interface{}) + Infoln(args ...interface{}) + Println(args ...interface{}) + Warnln(args ...interface{}) + Warningln(args ...interface{}) + Errorln(args ...interface{}) + Fatalln(args ...interface{}) + Panicln(args ...interface{}) +} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_bsd.go ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_bsd.go b/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_bsd.go new file mode 100644 index 0000000..71f8d67 --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_bsd.go @@ -0,0 +1,9 @@ +// +build darwin freebsd openbsd netbsd dragonfly + +package logrus + +import "syscall" + +const ioctlReadTermios = syscall.TIOCGETA + +type Termios syscall.Termios http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_linux.go ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_linux.go b/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_linux.go new file mode 100644 index 0000000..a2c0b40 --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_linux.go @@ -0,0 +1,12 @@ +// Based on ssh/terminal: +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package logrus + +import "syscall" + +const ioctlReadTermios = syscall.TCGETS + +type Termios syscall.Termios http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_notwindows.go ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_notwindows.go b/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_notwindows.go new file mode 100644 index 0000000..b343b3a --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_notwindows.go @@ -0,0 +1,21 @@ +// Based on ssh/terminal: +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build linux darwin freebsd openbsd netbsd dragonfly + +package logrus + +import ( + "syscall" + "unsafe" +) + +// IsTerminal returns true if stderr's file descriptor is a terminal. +func IsTerminal() bool { + fd := syscall.Stderr + var termios Termios + _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0) + return err == 0 +} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_solaris.go ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_solaris.go b/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_solaris.go new file mode 100644 index 0000000..3e70bf7 --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_solaris.go @@ -0,0 +1,15 @@ +// +build solaris + +package logrus + +import ( + "os" + + "golang.org/x/sys/unix" +) + +// IsTerminal returns true if the given file descriptor is a terminal. +func IsTerminal() bool { + _, err := unix.IoctlGetTermios(int(os.Stdout.Fd()), unix.TCGETA) + return err == nil +} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_windows.go ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_windows.go b/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_windows.go new file mode 100644 index 0000000..0146845 --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/terminal_windows.go @@ -0,0 +1,27 @@ +// Based on ssh/terminal: +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build windows + +package logrus + +import ( + "syscall" + "unsafe" +) + +var kernel32 = syscall.NewLazyDLL("kernel32.dll") + +var ( + procGetConsoleMode = kernel32.NewProc("GetConsoleMode") +) + +// IsTerminal returns true if stderr's file descriptor is a terminal. +func IsTerminal() bool { + fd := syscall.Stderr + var st uint32 + r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, uintptr(fd), uintptr(unsafe.Pointer(&st)), 0) + return r != 0 && e == 0 +} http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/5528d6fc/newtmgr/vendor/github.com/Sirupsen/logrus/text_formatter.go ---------------------------------------------------------------------- diff --git a/newtmgr/vendor/github.com/Sirupsen/logrus/text_formatter.go b/newtmgr/vendor/github.com/Sirupsen/logrus/text_formatter.go new file mode 100644 index 0000000..6afd0e0 --- /dev/null +++ b/newtmgr/vendor/github.com/Sirupsen/logrus/text_formatter.go @@ -0,0 +1,161 @@ +package logrus + +import ( + "bytes" + "fmt" + "runtime" + "sort" + "strings" + "time" +) + +const ( + nocolor = 0 + red = 31 + green = 32 + yellow = 33 + blue = 34 + gray = 37 +) + +var ( + baseTimestamp time.Time + isTerminal bool +) + +func init() { + baseTimestamp = time.Now() + isTerminal = IsTerminal() +} + +func miniTS() int { + return int(time.Since(baseTimestamp) / time.Second) +} + +type TextFormatter struct { + // Set to true to bypass checking for a TTY before outputting colors. + ForceColors bool + + // Force disabling colors. + DisableColors bool + + // Disable timestamp logging. useful when output is redirected to logging + // system that already adds timestamps. + DisableTimestamp bool + + // Enable logging the full timestamp when a TTY is attached instead of just + // the time passed since beginning of execution. + FullTimestamp bool + + // TimestampFormat to use for display when a full timestamp is printed + TimestampFormat string + + // The fields are sorted by default for a consistent output. For applications + // that log extremely frequently and don't use the JSON formatter this may not + // be desired. + DisableSorting bool +} + +func (f *TextFormatter) Format(entry *Entry) ([]byte, error) { + var keys []string = make([]string, 0, len(entry.Data)) + for k := range entry.Data { + keys = append(keys, k) + } + + if !f.DisableSorting { + sort.Strings(keys) + } + + b := &bytes.Buffer{} + + prefixFieldClashes(entry.Data) + + isColorTerminal := isTerminal && (runtime.GOOS != "windows") + isColored := (f.ForceColors || isColorTerminal) && !f.DisableColors + + timestampFormat := f.TimestampFormat + if timestampFormat == "" { + timestampFormat = DefaultTimestampFormat + } + if isColored { + f.printColored(b, entry, keys, timestampFormat) + } else { + if !f.DisableTimestamp { + f.appendKeyValue(b, "time", entry.Time.Format(timestampFormat)) + } + f.appendKeyValue(b, "level", entry.Level.String()) + if entry.Message != "" { + f.appendKeyValue(b, "msg", entry.Message) + } + for _, key := range keys { + f.appendKeyValue(b, key, entry.Data[key]) + } + } + + b.WriteByte('\n') + return b.Bytes(), nil +} + +func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, timestampFormat string) { + var levelColor int + switch entry.Level { + case DebugLevel: + levelColor = gray + case WarnLevel: + levelColor = yellow + case ErrorLevel, FatalLevel, PanicLevel: + levelColor = red + default: + levelColor = blue + } + + levelText := strings.ToUpper(entry.Level.String())[0:4] + + if !f.FullTimestamp { + fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d] %-44s ", levelColor, levelText, miniTS(), entry.Message) + } else { + fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s] %-44s ", levelColor, levelText, entry.Time.Format(timestampFormat), entry.Message) + } + for _, k := range keys { + v := entry.Data[k] + fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=%+v", levelColor, k, v) + } +} + +func needsQuoting(text string) bool { + for _, ch := range text { + if !((ch >= 'a' && ch <= 'z') || + (ch >= 'A' && ch <= 'Z') || + (ch >= '0' && ch <= '9') || + ch == '-' || ch == '.') { + return true + } + } + return false +} + +func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key string, value interface{}) { + + b.WriteString(key) + b.WriteByte('=') + + switch value := value.(type) { + case string: + if !needsQuoting(value) { + b.WriteString(value) + } else { + fmt.Fprintf(b, "%q", value) + } + case error: + errmsg := value.Error() + if !needsQuoting(errmsg) { + b.WriteString(errmsg) + } else { + fmt.Fprintf(b, "%q", value) + } + default: + fmt.Fprint(b, value) + } + + b.WriteByte(' ') +}
![http://i.imgur.com/hTeVwmJ.png"](http://i.imgur.com/hTeVwmJ.png"){kind=link}
