Version 1.1.1

See merge request !96

Rate limit builds register

Previously we were rate-limiting `/api` and `/ci/api`. This makes the it more targeted to only limit the capacity given to `builds/register.json` as this seems to be a main culprit of our stability problems.

@jacobvosmaer-gitlab @stanhu @pcarranza What do you think?

See merge request !95

Put archive tests in their own file

Felt like an easy way to trim down main_test.go a little.

See merge request !93

Test for tags

This would make it visible if we used a lightweight tag by accident.

See merge request !92

Version 1.1.0

See merge request !91

Prometheus metrics

Closes https://gitlab.com/gitlab-org/gitlab-workhorse/issues/61

This adds two metrics to begin with: total requests served,
partitioned by method/code, and the number of currently active
requests.

Things to check:

- [x] are the names of the metrics OK
- [x] is the access mechanism (unauthenticated HTTP at /metrics ) OK
- [x] check licenses of new dependencies: a mix of MIT, Apache 2.0, and BSD 3-clause

Note to reviewers: only the first four files in the GitLab diff are
outside vendor/. No need to scroll through the other 87 files.

See merge request !86

Disable NGINX response buffering when not proxying

Closes https://gitlab.com/gitlab-org/gitlab-workhorse/issues/78

See merge request !87

Too many things on prometheus.gitlab.com are already called
'http_requests_total'.

Avoid setting multiple values for certain headers

Content-Type, Content-Disposition and other headers were being given multiple values in some workhorse responses, causes problems with, e.g., archive downloads.

This MR refactors the tests somewhat, and replaces calls to `Header().Add()` with `Header().Set()` where appropriate.

Closes #76

See merge request !84

Release v1.0.0

See merge request !82

Add "quick facts" section

Towards https://gitlab.com/gitlab-org/gitlab-workhorse/issues/75

See merge request !79

Adds Unix signal to reopen log file

This MR adds a command line flag to provide a log file and creates a handler to reopen the log file upon receiving a SIGHUP signal.

A new dependency is also added: [github.com/client9/reopen](https://github.com/client9/reopen)

Relevant Issue: [#52](https://gitlab.com/gitlab-org/gitlab-workhorse/issues/52)

cc: @jacobvosmaer-gitlab, @smcgivern 

See merge request !77

  - Adds new logFile flag
  - Adds client9/reopen dependency
  - Enables log file reopening on SIGHUP
  - Adds a custom response logger

Improve error messages

Less noise from 'deepen' inspection. Better grouping of 'bad gateway' errors.

See merge request !76

Hopefully this will lead to better grouping of errors in Sentry.

They are just noise.

Change the revspec for `git format-patch`

For merge requests, GitLab currently sends:

* ShaFrom == tip of target branch
* ShaTo == tip of source branch

This MR adds tests for this scenario and the alternative:

* ShaFrom == base SHA
* ShaTo == tip of source branch

It then makes the test for the first case pass by altering the revspec. 

What to do with diffs is still an open question, so we leave those untouched for the moment.

See https://gitlab.com/gitlab-org/gitlab-ce/issues/22229

See merge request !68

Print go version during CI build



See merge request !74

Resolve "http.StatusTooManyRequests breaks Go 1.5 compatibility"

This merge request replaces a constant introduced in go1.6 with its literal value, as we need go1.5 support. No other changes are required.

It also modifies .gitlab-ci.yml to test against go1.5, 1.6 and 1.7, to prevent future regressions.

Closes #69

See merge request !73

Allow to queue API requests and limit given capacity

This MR implements an API queueing on Workhorse side.
It's meant to better control given capacity for different resources.

This is meant to solve: https://gitlab.com/gitlab-com/infrastructure/issues/320.

And make a large number of requests easier to handle: https://gitlab.com/gitlab-org/gitlab-ce/issues/21698

It fulfils these requirements:
- allow to limit capacity given to API, specifically to allow to process up to N-number of requests at single time,
- allow to queue API requests and timeout them, specifically it allows to slow down processing of API calls if the Unicorn can process the current API requests in reasonable time

The implementation is made as constant cost and it's dead simple.
It should not inflate the memory / CPU usage of Workhorse.

It works like this:
- we hook into processing of requests,
- we try to acquire slot for our request by pushing to buffered channel. The buffered channel actually limits number of processed requests at single time,
- if we can't push to channel it means that all concurrent slots are in use and we have to wait,
- we block on buffered channel for the free a slot, secondly we wait on timer to timeout on channel,
- we generate 502 if timeout occurs,
- we process request if we manage to push to channel,
- we pop from channel when we finish processing of requests, allowing other requests to fire,
- if there's already too many request (over `apiQueueLimit`) we return 429,

This introduces 3 extra parameters (off by default):
- `apiLimit` - limit number of concurrent API requests,
- `apiQueueLimit` - limit the backlog for queueing,
- `apiQueueTimeout` - duration after we timeout requests if they sit too long in queue.

This allows:
- limit used capacity to any number of available workers, ex. allowing for API to use at most 25% of capacity,
- slowly process requests in case of slowness,
- better manage the API calls then rate limiting requests,
- by slowing down we are automatically backing off all services using API,


See merge request !65