Jaeger is a Distributed Tracing System in #golang

Jaeger, inspired by Dapper and OpenZipkin, is a distributed tracing system released as open source by Uber Technologies and written in Golang .

https://github.com/uber/jaeger

It can be used for monitoring microservice-based architectures:

  • Distributed context propagation
  • Distributed transaction monitoring
  • Root cause analysis
  • Service dependency analysis
  • Performance / latency optimization

Share This:

A fast #golang reverse proxy to help you expose a local server behind a NAT or firewall to the internet.

frp is a fast reverse proxy to help you expose a local server behind a NAT or firewall to the internet. Now, it supports tcp, udp, http and https protocol when requests can be forwarded by domains to backward web services.

https://github.com/fatedier/frp

Share This:

Smartcrop finds good image crops for arbitrary crop sizes #golang

Ssmartcrop finds good image crops for arbitrary sizes. It is a pure Go implementation, based on Jonas Wagner’s smartcrop.js

https://github.com/muesli/smartcrop

 

Share This:

#golang build system with file watcher, live reload and output streams

Realize is the Go tool that is focused to speed up and improve developers workflow.

https://github.com/tockins/realize

Automate your work pipeline, integrate additional tools of third party, define custom cli commands and reload projects at each changed without stop to write code.

Features

  • Highly customizable
  • Setup step by step
  • Live reload
  • Support for multiple projects
  • Save logs on files
  • Web panel for a smart view
  • Build, install, run, test, fmt, generate, vet and much more
  • Watch custom paths and specific file extensions
  • Multiple watching methods (Polling, File watcher)
  • Docker support

Share This:

TiDB is a distributed #NewSQL database compatible with #MySQL protocol written in #golang

What is TiDB?

https://github.com/pingcap/tidb

TiDB (The pronunciation is: /’taɪdiːbi:/ tai-D-B, etymology: titanium) is a distributed SQL database. Inspired by the design of Google F1 and Google Spanner, TiDB supports the best features of both traditional RDBMS and NoSQL.

  • Horizontal scalability Grow TiDB as your business grows. You can increase the capacity simply by adding more machines.
  • Asynchronous schema changes Evolve TiDB schemas as your requirement evolves. You can add new columns and indices without stopping or affecting the on-going operations.
  • Consistent distributed transactions Think of TiDB as a single-machine RDBMS. You can start a transaction that crosses multiple machines without worrying about consistency. TiDB makes your application code simple and robust.
  • Compatible with MySQL protocol Use TiDB as MySQL. You can replace MySQL with TiDB to power your application without changing a single line of code in most cases.
  • NewSQL over TiKV Turn TiKV into NewSQL database.
  • Multiple storage engine support Power TiDB with your most favorite engines. TiDB supports many popular storage engines in single-machine mode. You can choose from GolevelDB, LevelDB, RocksDB, LMDB, BoltDB and even more to come.

 

Share This:

A collection of tools and libraries for working with #golang code, including linters and static analysis

A collection of tools and libraries for working with Go code, including linters and static analysis:

https://github.com/dominikh/go-tools

Tool Description
gosimple Detects code that could be rewritten in a simpler way.
keyify Transforms an unkeyed struct literal into a keyed one.
rdeps Find all reverse dependencies of a set of packages
staticcheck Detects a myriad of bugs and inefficiencies in your code.
structlayout Displays the layout (field sizes and padding) of structs.
structlayout-optimize Reorders struct fields to minimize the amount of padding.
structlayout-pretty Formats the output of structlayout with ASCII art.
unused Reports unused identifiers (types, functions, …) in your code.
megacheck Run staticcheck, gosimple and unused in one go

Libraries

In addition to the aforementioned tools, this repository contains the libraries necessary to implement these tools.

Share This:

A Distributed Cron-Style Job System in #golang

cronsun is a distributed golang based cron-style job system. It’s similar with crontab on stand-alone *nix.

https://github.com/shunfei/cronsun

Purpose

The goal of this project is to make it much easier to manage jobs on lots of machines and provides high availability. cronsun is different from Azkaban, Chronos, Airflow.

Features

  • Easy manage jobs on multiple machines
  • Managemant panel
  • Mail service
  • Multi-language support
  • Simple authentication and accounts manager(default administrator email and password: admin@admin.com/admin)

Share This:

A lightweight, distributed relational database built on SQLite with #golang

https://github.com/rqlite/rqlite

rqlite is a distributed relational database, which uses SQLite as its storage engine. rqlite uses Raft to achieve consensus across all the instances of the SQLite databases, ensuring that every change made to the system is made to a quorum of SQLite databases, or none at all. It also gracefully handles leader elections, and tolerates failures of machines, including the leader. rqlite is available for Linux, OSX, and Microsoft Windows.

Why?

rqlite gives you the functionality of a rock solid, fault-tolerant, replicated relational database, but with very easy installation, deployment, and operation. With it you’ve got a lightweight and reliable distributed relational data store. Think etcd or Consul, but with relational data modelling also available.

You could use rqlite as part of a larger system, as a central store for some critical relational data, without having to run a heavier solution like MySQL.

Key features

  • Very easy deployment, with no need to separately install SQLite.
  • Fully replicated production-grade SQL database.
  • Production-grade distributed consensus system.
  • An easy-to-use HTTP(S) API, including leader-redirection and bulk-update support. A CLI is also available.
  • Discovery Service support, allowing clusters to be dynamically created.
  • Extensive security and encryption support, including node-to-node encryption.
  • Choice of read consistency levels.
  • Transaction support.
  • Hot backups.

Share This:

Writing a Static Blog Generator in #golang

Cool Blog Post about writing a static blog generator with Go.

https://zupzup.org/static-blog-generator-go/

A static-site-generator is a tool which, given some input (e.g. markdown) generates a fully static website using HTML, CSS and JavaScript.

Code: https://github.com/zupzup/blog-generator

Share This:

#golang tool for static analysis, unit testing, code review and generate code quality report.

A Golang tool that does static analysis, unit testing, code review and generate code quality report. This is a tool that concurrently runs a whole bunch of those linters and normalizes their output to a report

https://github.com/wgliang/goreporter

Supported linters

  • unittest – Golang unit test status.
  • deadcode – Finds unused code.
  • gocyclo – Computes the cyclomatic complexity of functions.
  • varcheck – Find unused global variables and constants.
  • structcheck – Find unused struct fields.
  • aligncheck – Warn about un-optimally aligned structures.
  • errcheck – Check that error return values are used.
  • copycode(dupl) – Reports potentially duplicated code.
  • gosimple – Report simplifications in code.
  • staticcheck – Statically detect bugs, both obvious and subtle ones.
  • godepgraph – Godepgraph is a program for generating a dependency graph of Go packages.
  • misspell – Correct commonly misspelled English words… quickly.
  • countcode – Count lines and files of project.

 

Share This: