gitlab-fluent-plugin-redis-slowlog 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8fc7a7afc37728bd3e9ae94eeaa408103bf28f00a87c6e931a4568f675bab927
+  data.tar.gz: 3e7fc4b3bc8dbb082f84f211f4de09ceb9b415b2d9d7c0c59b67316498586730
+SHA512:
+  metadata.gz: 4e315c9db4c5d3b70c196fcb9dd912304ea8619766f8d9bbc8c00eeb1d4389f96fd37f1279f061e1c3d977944a972209763cadf417bb1dc18c98b12aceeeb9c9
+  data.tar.gz: 59f9771844039b0a250c9f6bcbf342ea42163d2710d79b9121f222c39736d3cb8f40e2978cf40a2e86496b507ef1da549fdfbeadea47098c9c6dc86efffb8739

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/.gitlab-ci.yml

@@ -0,0 +1,21 @@
+test:
+  image: ruby:2.6
+  stage: test
+  script:
+    - gem install bundler
+    - bundle install
+    - bundle exec rake
+
+deploy:
+  stage: deploy
+  script:
+    - tools/deploy-rubygem.sh
+  only:
+    - tags
+
+release:
+  stage: deploy
+  script:
+    - tools/update-changelog.rb "${CI_COMMIT_TAG}"
+  only:
+    - tags

data/.rubocop.yml

@@ -0,0 +1,17 @@
+inherit_gem:
+  gitlab-styles:
+    - rubocop-default.yml
+
+AllCops:
+  TargetRubyVersion: 2.6
+
+# Let's just pick something from the beginning
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+# This isn't Rails, so diable these
+Rails/RakeEnvironment:
+  Enabled: false
+CodeReuse/ActiveRecord:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,103 @@
+PATH
+  remote: .
+  specs:
+    gitlab-fluent-plugin-redis-slowlog (0.0.0)
+      fluentd (>= 0.14.10, < 2)
+      redis (>= 4.1.3, < 5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.0)
+    coderay (1.1.2)
+    concurrent-ruby (1.1.6)
+    cool.io (1.6.0)
+    diff-lcs (1.3)
+    fluentd (1.10.4)
+      cool.io (>= 1.4.5, < 2.0.0)
+      http_parser.rb (>= 0.5.1, < 0.7.0)
+      msgpack (>= 1.3.1, < 2.0.0)
+      serverengine (>= 2.0.4, < 3.0.0)
+      sigdump (~> 0.2.2)
+      strptime (>= 0.2.2, < 1.0.0)
+      tzinfo (>= 1.0, < 3.0)
+      tzinfo-data (~> 1.0)
+      yajl-ruby (~> 1.0)
+    gitlab-styles (3.2.0)
+      rubocop (~> 0.74.0)
+      rubocop-gitlab-security (~> 0.1.0)
+      rubocop-performance (~> 1.4.1)
+      rubocop-rails (~> 2.0)
+      rubocop-rspec (~> 1.36)
+    http_parser.rb (0.6.0)
+    jaro_winkler (1.5.4)
+    method_source (0.9.2)
+    msgpack (1.3.3)
+    parallel (1.19.1)
+    parser (2.7.1.2)
+      ast (~> 2.4.0)
+    power_assert (1.1.3)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rack (2.2.2)
+    rainbow (3.0.0)
+    rake (12.3.3)
+    redis (4.1.4)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+    rubocop (0.74.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.6)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 1.7)
+    rubocop-gitlab-security (0.1.1)
+      rubocop (>= 0.51)
+    rubocop-performance (1.4.1)
+      rubocop (>= 0.71.0)
+    rubocop-rails (2.4.0)
+      rack (>= 1.1)
+      rubocop (>= 0.72.0)
+    rubocop-rspec (1.37.0)
+      rubocop (>= 0.68.1)
+    ruby-progressbar (1.10.1)
+    serverengine (2.2.1)
+      sigdump (~> 0.2.2)
+    sigdump (0.2.4)
+    strptime (0.2.4)
+    test-unit (3.2.9)
+      power_assert
+    tzinfo (2.0.2)
+      concurrent-ruby (~> 1.0)
+    tzinfo-data (1.2020.1)
+      tzinfo (>= 1.0.0)
+    unicode-display_width (1.6.1)
+    yajl-ruby (1.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.1.4)
+  gitlab-fluent-plugin-redis-slowlog!
+  gitlab-styles (~> 3.2.0)
+  pry (~> 0.12.2)
+  rake (~> 12.0)
+  rspec (~> 3.9.0)
+  test-unit (~> 3.2.9)
+
+BUNDLED WITH
+   2.1.4

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016-2020 GitLab B.V.
+
+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.

data/README.md

@@ -0,0 +1,133 @@
+# fluent-plugin-redis-slowlog
+
+[Fluentd](https://fluentd.org/) input plugin to write redis-slowlog
+events to fluentd.
+
+The plugin works by issuing a
+[`SLOWLOG`](https://redis.io/commands/slowlog) command at an
+interval. The new slowlog entries will be emitted to fluentd.
+
+The output looks like this:
+
+```
+2020-05-26 10:52:27.000000000 +0200 redis.slowlog: {"id":21733,"timestamp":"2020-05-26 10:52:25 +0200","exec_time":5,"command":["SCAN","0"]}
+2020-05-26 10:52:37.000000000 +0200 redis.slowlog: {"id":21734,"timestamp":"2020-05-26 10:52:27 +0200","exec_time":197,"command":["slowlog","get","128"]}
+2020-05-26 10:52:37.000000000 +0200 redis.slowlog: {"id":21735,"timestamp":"2020-05-26 10:52:32 +0200","exec_time":3,"command":["SET","hello","world"]}
+2020-05-26 10:52:47.000000000 +0200 redis.slowlog: {"id":21736,"timestamp":"2020-05-26 10:52:37 +0200","exec_time":259,"command":["slowlog","get","128"]}
+2020-05-26 10:52:47.000000000 +0200 redis.slowlog: {"id":21737,"timestamp":"2020-05-26 10:52:42 +0200","exec_time":5,"command":["SCAN","0"]}
+```
+
+This is based on the work by @andrewn in
+https://github.com/suprememoocow/fluent-plugin-redis-slowlog, which
+was forked from https://github.com/mominosin/fluent-plugin-redis-slowlog
+
+## Installation
+
+### RubyGems
+
+```
+$ gem install fluent-plugin-redis-slowlog
+```
+
+### Bundler
+
+Add following line to your Gemfile:
+
+```ruby
+gem "fluent-plugin-redis-slowlog"
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+## Configuration
+
+### tag (string) (required)
+
+The tag to be used for the events
+
+#### Redis connection parameters
+
+This allows configuring the connection parameters. If nothing is
+configured, falling back to the default of localhost:6379.
+
+For more information see the
+[`redis-rb`](https://github.com/redis/redis-rb#getting-started).
+
+### url (string) (optional)
+
+A [`redis://`-URL](https://www.iana.org/assignments/uri-schemes/prov/redis).
+
+### path (string) (optional)
+
+Path to connect to Redis listening on a Unix socket
+
+### host (string) (optional)
+
+Host to connect to Redis
+
+Default value: `localhost`.
+
+### port (integer) (optional)
+
+Port to connect to Redis, used in combination with the `host` parameter
+
+Default value: `6379`.
+
+### password (string) (optional)
+
+The password to use for connecting to redis.
+
+Default value: `nil`.
+
+### logsize (integer) (optional)
+
+The number of slowlog entries to get in 1 call.
+
+Default value: `128`.
+
+### interval (integer) (optional)
+
+The time in seconds to wait between `SLOWLOG` commands.
+
+Default value: `10`.
+
+## Development
+
+After checking out the repository, run `bundle install` to install all
+dependencies.
+
+After that, you can run `bundle exec rake` to run all lints and
+specs.
+
+Other rake tasks:
+
+```
+rake build                # Build gitlab-fluent-plugin-redis-slowlog-0.gem into the pkg directory
+rake clean                # Remove any temporary products
+rake clobber              # Remove any generated files
+rake console              # Start an interactive console with the gem loaded
+rake install              # Build and install gitlab-fluent-plugin-redis-slowlog-0.gem into system gems
+rake install:local        # Build and install gitlab-fluent-plugin-redis-slowlog-0.gem into system gems without network access
+rake release[remote]      # Create tag v0 and build and push gitlab-fluent-plugin-redis-slowlog-0.gem to rubygems.org
+rake spec                 # Run RSpec code examples
+rake verify               # Run RuboCop
+rake verify:auto_correct  # Auto-correct RuboCop offenses
+```
+
+
+### Releasing a new version
+
+Releasing a new version can be done by pushing a new tag, or creating
+it from the
+[interface](https://gitlab.com/gitlab-org/fluent-plugin-redis-slowlog/-/tags).
+
+A new changelog will automatically be added to the release on Gitlab.
+
+The new version will automatically be published to
+[rubygems](https://rubygems.org/gems/gitlab-labkit) when the pipeline
+for the tag completes. It might take a few minutes before the update
+is available.

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new(:verify)
+
+desc "Start an interactive console with the gem loaded"
+task :console do
+  require "pry"
+  require "fluent/env"
+  require "fluent/plugin/in_redis_slowlog"
+
+  Pry.start
+end
+
+task default: [:verify, :spec]

data/gitlab-fluent-plugin-redis-slowlog.gemspec

@@ -0,0 +1,35 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name    = "gitlab-fluent-plugin-redis-slowlog"
+  spec.version = "0.0.0" # `git describe --tags`.chomp.gsub(/^v/, "")
+  spec.metadata = { "source_code_uri" => "https://gitlab.com/gitlab-org/fluent-plugin-redis-slowlog" }
+  spec.authors = ["Bob Van Landuyt"]
+  spec.email   = ["bob@gitlab.com"]
+
+  spec.required_ruby_version = ">= 2.6"
+
+  spec.summary       = "Emit redis slowlog entries into fluentd"
+  spec.homepage      = "http://gitlab.com/gitlab-org/gitlab-fluent-plugin-redis-slowlog"
+  spec.license       = "MIT"
+
+  test_files, files  = `git ls-files -z`.split("\x0").partition do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.files         = files
+  spec.executables   = files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = test_files
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.1.4"
+  spec.add_development_dependency "gitlab-styles", "~> 3.2.0"
+  spec.add_development_dependency "pry", "~> 0.12.2"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "rspec", "~> 3.9.0"
+  # required for the fluent test helpers
+  spec.add_development_dependency "test-unit", "~> 3.2.9"
+
+  spec.add_runtime_dependency "fluentd", [">= 0.14.10", "< 2"]
+  spec.add_runtime_dependency "redis", [">= 4.1.3", "< 5"]
+end

data/lib/fluent/plugin/in_redis_slowlog.rb

@@ -0,0 +1,93 @@
+require "fluent/plugin/input"
+require "redis"
+
+module Fluent
+  module Plugin
+    class RedisSlowlogInput < Fluent::Plugin::Input
+      Fluent::Plugin.register_input("redis_slowlog", self)
+
+      config_param :tag,      :string
+      config_param :url,      :string,  default: nil
+      config_param :path,     :string,  default: nil
+      config_param :host,     :string,  default: "localhost"
+      config_param :port,     :integer, default: 6379
+      config_param :password, :string,  default: nil
+      config_param :logsize,  :integer, default: 128
+      config_param :interval, :integer, default: 10
+
+      def initialize
+        super
+
+        @current_log_id = 0
+      end
+
+      def configure(conf)
+        super
+
+        @redis = Redis.new(
+          url: url,
+          host: host,
+          port: port,
+          path: path,
+          password: password
+        )
+      end
+
+      def start
+        super
+
+        if redis.ping != "PONG"
+          raise Redis::CannotConnectError,
+                "Could not connect to redis"
+        end
+
+        self.watching = true
+        self.watcher = Thread.new(&method(:watch))
+      end
+
+      def shutdown
+        super
+
+        self.watching = false
+        redis.quit
+      end
+
+      private
+
+      attr_reader :redis, :interval
+      attr_accessor :watcher, :watching, :current_log_id
+
+      def watch
+        while watching
+          sleep interval
+
+          self.current_log_id = output(current_log_id)
+        end
+      end
+
+      def output(last_id = 0)
+        slowlogs = redis.slowlog("get", logsize)
+        return last_id if slowlogs.empty?
+
+        emit_slowlog(slowlogs)
+
+        # Return the id of the last slowlog entry we've logged
+        # The first entry is the one that occurred last
+        slowlogs.first.first
+      end
+
+      def emit_slowlog(slowlogs)
+        slowlogs.reverse_each do |log|
+          # Don't emit logs for entries we've already logged
+          next if log.first <= current_log_id
+
+          log_hash = { "id" => log[0],
+                       "timestamp" => Time.at(log[1]),
+                       "exec_time" => log[2],
+                       "command" => log[3] }
+          router.emit(tag, Time.now.to_i, log_hash)
+        end
+      end
+    end
+  end
+end

data/spec/fluent/plugin/redis_slowlog_input_spec.rb

@@ -0,0 +1,119 @@
+require "spec_helper"
+
+describe Fluent::Plugin::RedisSlowlogInput do
+  let(:config) do
+    { tag: "redis.slowlog" }
+  end
+
+  let(:plugin) { driver.instance }
+  let(:slowlog) { [] }
+  let(:fake_redis) { instance_double(Redis, ping: "PONG", quit: "OK", slowlog: slowlog) }
+
+  subject(:driver) do
+    config_string = config.map { |key, value| "#{key} #{value}" }.join("\n")
+    Fluent::Test::Driver::Input.new(described_class).configure(config_string)
+  end
+
+  before do
+    Fluent::Test.setup
+  end
+
+  context "when redis can't be reached" do
+    it "raises an error" do
+      expect { driver.run }.to raise_error(Redis::CannotConnectError)
+    end
+  end
+
+  context "when specifying redis connection attributes" do
+    let(:config) do
+      { tag: "redis.slowlog",
+        url: "redis://:p4ssw0rd@10.0.1.1:6380/15",
+        path: "/path/to/redis.sock",
+        host: "localhost",
+        port: 1234,
+        password: "5iveL!fe" }
+    end
+
+    it "delegates all of them to redis-rb" do
+      redis_params = [:url, :path, :host, :port, :password]
+
+      expect(Redis).to receive(:new).with(config.slice(*redis_params)).and_return(fake_redis)
+
+      driver.run
+    end
+  end
+
+  context "when redis is available" do
+    let(:config) do
+      {
+        tag: "redis.slowlog",
+        interval: 0,
+        logsize: 10
+      }
+    end
+
+    before do
+      allow(plugin).to receive(:redis).and_return(fake_redis)
+    end
+
+    after do
+      # Wait for the thread polling redis to finish
+      plugin.__send__(:watcher).join
+    end
+
+    it "does not raise errors" do
+      expect { driver.run }.not_to raise_error
+    end
+
+    it "polls the slowlog at with the configured interval and size" do
+      expect(plugin).to receive(:sleep).with(0).ordered
+      expect(fake_redis).to receive(:slowlog).with("get", 10).ordered
+      expect(plugin).to receive(:sleep).with(0).ordered
+      expect(fake_redis).to receive(:slowlog).with("get", 10).ordered
+
+      # Limit to 2 cycles
+      allow(plugin).to receive(:watching).thrice.and_return(true, true, false)
+
+      driver.run
+    end
+
+    context "when the slowlog returns entries" do
+      let(:slowlog) do
+        [
+          [25640, 1590522258, 1, %w[ping]],
+          [25639, 1590522249, 1, %w[ping]],
+          [25638, 1590522208, 5, %w[SCAN 0]]
+        ]
+      end
+
+      let(:expected_entries) do
+        slowlog.map(&method(:log_entry)).sort_by { |event| event["id"] }
+      end
+
+      let(:emitted_entries) { driver.events.map(&:last) }
+
+      it "emits an event for each slowlog in reverse order" do
+        driver.run(expect_emits: 3)
+
+        expect(driver.events.size).to eq(3)
+        expect(emitted_entries).to eq(expected_entries)
+      end
+
+      it "does not log the same event twice" do
+        expect(fake_redis).to receive(:slowlog).and_return(slowlog.last(1), slowlog)
+
+        driver.run(expect_emits: 3)
+
+        expect(driver.events.size).to eq(3)
+        expect(emitted_entries).to eq(expected_entries)
+      end
+    end
+  end
+
+  def log_entry(slowlog_entry)
+    { "id" => slowlog_entry.first,
+      "timestamp" => Time.at(slowlog_entry[1]),
+      "exec_time" => slowlog_entry[2],
+      "command" => slowlog_entry.last }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require "rspec"
+require "fluent/test"
+require "fluent/test/driver/input"
+require "fluent/test/helpers"
+require "pry"
+
+Dir.glob(File.expand_path("../lib/**/*.rb", __dir__)).each(&method(:require))
+
+# Test::Unit is required for fluent/test, but we don't want it to autorun when
+# required
+Test::Unit::AutoRunner.need_auto_run = false
+
+RSpec.configure do |config|
+  config.include Fluent::Test::Helpers
+end

data/tools/deploy-rubygem.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+IFS=$'\n\t'
+
+mkdir -p ~/.gem/
+temp_file=$(mktemp)
+
+# Revert change the credentials file
+function revert_gem_cred_switch {
+  mv "$temp_file" ~/.gem/credentials
+}
+
+if [[ -f ~/.gem/credentials ]]; then
+  echo "Temporarily moving existing credentials to $temp_file"
+  mv ~/.gem/credentials "$temp_file"
+  trap revert_gem_cred_switch EXIT
+fi
+
+cat <<EOD > ~/.gem/credentials
+---
+:rubygems_api_key: $RUBYGEMS_API_KEY
+EOD
+chmod 600 ~/.gem/credentials
+
+set -x
+rm -rf pkg/
+mkdir -p pkg/
+bundle install
+bundle exec rake verify build
+gem push pkg/*.gem

data/tools/update-changelog.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+
+require "uri"
+require "net/http"
+require "openssl"
+require "json"
+require "optparse"
+
+GitlabError = Class.new(StandardError)
+GitlabClientError = Class.new(GitlabError)
+
+def gitlab_client(path, method, body = nil)
+  url = URI("https://gitlab.com#{path}")
+
+  http = Net::HTTP.new(url.host, url.port)
+  http.use_ssl = true
+
+  request = case method
+            when :get
+              Net::HTTP::Get.new(url)
+            when :post
+              Net::HTTP::Post.new(url)
+            when :put
+              Net::HTTP::Put.new(url)
+            else
+              raise "Unknown method: #{method}"
+            end
+
+  request["content-type"] = "application/json"
+  request["PRIVATE-TOKEN"] = ENV["GITLAB_TOKEN"]
+  request.body = JSON.dump(body) if body
+
+  response = http.request(request)
+
+  case response
+  when Net::HTTPSuccess
+    JSON.parse(response.read_body)
+  when Net::HTTPClientError
+    raise GitlabClientError, "HTTP #{response.code} for #{method} #{url}: #{response.read_body}"
+  else
+    raise GitLabError, "HTTP #{response.code} for #{method} #{url}: #{response.read_body}"
+  end
+end
+
+def list_commits_for_tag(tag)
+  commits = `git rev-list --no-merges $(git describe --tags --abbrev=0 #{tag}^)..#{tag}`.lines
+  commits.map(&:chomp)
+end
+
+def get_mrs_for_commit(commit_id)
+  gitlab_client("/api/v4/projects/gitlab-org%2ffluent-plugin-redis-slowlog/repository/commits/#{commit_id}/merge_requests", :get)
+end
+
+def create_release_for_tag(tag, description)
+  req_body = { tag_name: tag, description: description }
+  gitlab_client("/api/v4/projects/gitlab-org%2ffluent-plugin-redis-slowlog/releases", :post, req_body)
+end
+
+def update_release_for_tag(tag, description)
+  req_body = { description: description }
+  gitlab_client("/api/v4/projects/gitlab-org%2ffluent-plugin-redis-slowlog/releases/#{tag}", :put, req_body)
+end
+
+def get_unique_mrs_for_tag(tag)
+  commit_ids = list_commits_for_tag(tag)
+  dup_mrs = commit_ids.map { |commit_id| get_mrs_for_commit(commit_id) }.flatten
+  uniq_mrs = dup_mrs.uniq { |mr| mr["iid"] }
+
+  uniq_mrs.sort { |mr| mr["iid"] }.reverse
+end
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: update-changelog.rb [options] tag"
+
+  opts.on("-d", "--[no-]dry-run", "Display only. Do not update release notes.") do |d|
+    options[:dry_run] = d
+  end
+end.parse!
+
+# Check required conditions
+unless ARGV.length == 1
+  puts optparse
+  exit(-1)
+end
+
+tag = ARGV.first
+
+changelog = get_unique_mrs_for_tag(tag).map { |mr| "* #{mr['web_url']}: #{mr['title']}" }.join("\n")
+
+raise "No new changes found" if changelog.empty?
+
+changelog = "## Changes in #{tag}\n\n" + changelog
+
+if options[:dry_run]
+  puts changelog
+  exit
+end
+
+begin
+  create_release_for_tag(tag, changelog)
+  puts "Created release: https://gitlab.com/gitlab-org/fluent-plugin-redis-slowlog/-/releases##{tag}"
+rescue GitlabClientError
+  update_release_for_tag(tag, changelog)
+  puts "Updated release: https://gitlab.com/gitlab-org/fluent-plugin-redis-slowlog/-/releases##{tag}"
+end

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification
+name: gitlab-fluent-plugin-redis-slowlog
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Bob Van Landuyt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.4
+- !ruby/object:Gem::Dependency
+  name: gitlab-styles
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.9
+- !ruby/object:Gem::Dependency
+  name: fluentd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.10
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.10
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+description: 
+email:
+- bob@gitlab.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitlab-ci.yml"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- gitlab-fluent-plugin-redis-slowlog.gemspec
+- lib/fluent/plugin/in_redis_slowlog.rb
+- spec/fluent/plugin/redis_slowlog_input_spec.rb
+- spec/spec_helper.rb
+- tools/deploy-rubygem.sh
+- tools/update-changelog.rb
+homepage: http://gitlab.com/gitlab-org/gitlab-fluent-plugin-redis-slowlog
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://gitlab.com/gitlab-org/fluent-plugin-redis-slowlog
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Emit redis slowlog entries into fluentd
+test_files:
+- spec/fluent/plugin/redis_slowlog_input_spec.rb
+- spec/spec_helper.rb