logstash-output-loki 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9dd08c392ec88148a6f410e159169b3a19f877a25174fa3f43b2fdeb7fe16128
+  data.tar.gz: 34aaf03576d8fbbb97aab02013113254734984ee1744c2ab4e8438bd51657569
+SHA512:
+  metadata.gz: 3520ab5618092976cfe771ad4f9ddea4aca3b96efe75d322c2f505e7fd6e642f3cee4775eb1ef0514c9db360a3c36b138e9f1426f6de9b625945cafdafb0b27d
+  data.tar.gz: 6c7bb11d79fe0828e629bc27771a4f63584ea76af2ddb69eac950e5c7e3b115b62b674be28e8a828c97d8d3d851406748f0c83d49d9147080f0cc593ad1a076f

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+logstash_path = ENV["LOGSTASH_PATH"] || "logstash-libs"
+use_logstash_source = ENV["LOGSTASH_SOURCE"] && ENV["LOGSTASH_SOURCE"].to_s == "1"
+
+if Dir.exist?(logstash_path) && use_logstash_source
+  gem 'logstash-core', :path => "#{logstash_path}/logstash-core"
+  gem 'logstash-core-plugin-api', :path => "#{logstash_path}/logstash-core-plugin-api"
+end

data/README.md

@@ -0,0 +1,66 @@
+# Loki Logstash Output Plugin
+
+Logstash plugin to send logstash aggregated logs to Loki.
+
+## Install dependencies
+
+First you need to setup JRuby environment to build this plugin. Refer https://github.com/rbenv/rbenv for setting up your rbenv environment.
+
+After setting up `rbenv`. Install JRuby
+
+```bash
+rbenv install jruby-9.2.10.0
+rbenv local jruby-9.2.10.0
+```
+
+Check that the environment is configured
+
+```bash
+ruby --version
+jruby 9.2.10
+```
+
+You should use make sure you are running jruby and not ruby. If the command below still shows ruby and not jruby, check that PATH contains `$HOME/.rbenv/shims` and `$HOME/.rbenv/bin`. Also verify that you have this in your bash profile:
+
+```bash
+export PATH="$HOME/.rbenv/bin:$PATH"
+eval "$(rbenv init -)"
+```
+
+Then install bundler
+`gem install bundler:2.1.4`
+
+Follow those instructions to [install logstash](https://www.elastic.co/guide/en/logstash/current/installing-logstash.html) before moving to the next section.
+
+## Install dependencies and Build plugin
+
+### Install required packages
+
+```bash
+git clone git@github.com:elastic/logstash.git
+cd logstash
+git checkout tags/v7.6.2
+export LOGSTASH_PATH=`pwd`
+export LOGSTASH_SOURCE="1"
+export GEM_PATH=$LOGSTASH_PATH/vendor/bundle/
+export GEM_HOME=$LOGSTASH_PATH/vendor/bundle/
+cd ..
+ruby -S bundle install --path
+ruby -S bundle exec rake vendor
+```
+
+### Build the plugin
+
+`gem build logstash-output-loki.gemspec`
+
+### Test
+
+`bundle exec rspec`
+
+## Install plugin to local logstash
+
+`bin/logstash-plugin install --no-verify --local logstash-output-loki-1.0.0.gem`
+
+## Send sample event and check plugin is working
+
+`bin/logstash -f loki.conf`

data/lib/logstash/outputs/loki.rb

@@ -0,0 +1,308 @@
+# encoding: utf-8
+require "logstash/outputs/base"
+require "logstash/namespace"
+require 'net/http'
+require 'concurrent-edge'
+require 'time'
+require 'uri'
+require 'json'
+
+class LogStash::Outputs::Loki < LogStash::Outputs::Base
+  require 'logstash/outputs/loki/batch'
+  require 'logstash/outputs/loki/entry'
+
+  config_name "loki"
+
+  ## 'A single instance of the Output will be shared among the pipeline worker threads'
+  concurrency :single
+
+  ## 'Loki URL'
+  config :url, :validate => :string, :required => true
+
+  ## 'BasicAuth credentials'
+  config :username, :validate => :string, :required => false
+  config :password, :validate => :string, secret: true, :required => false
+
+  ## 'Client certificate'
+  config :cert, :validate => :path, :required => false
+  config :key, :validate => :path, :required => false
+
+  ## 'TLS'
+  config :ca_cert, :validate => :path, :required => false
+
+  ## 'Loki Tenant ID'
+  config :tenant_id, :validate => :string, :required => false
+
+  ## 'Maximum batch size to accrue before pushing to loki. Defaults to 102400 bytes'
+  config :batch_size, :validate => :number, :default => 102400, :required => false
+
+  ## 'Interval in seconds to wait before pushing a batch of records to loki. Defaults to 1 second'
+  config :batch_wait, :validate => :number, :default => 1, :required => false
+
+  ## 'Array of label names to include in all logstreams'
+  config :include_labels, :validate => :array, :default => [], :required => true
+
+  ## 'Extra labels to add to all log streams'
+  config :external_labels, :validate => :hash,  :default => {}, :required => false
+
+  ## 'Log line field to pick from logstash. Defaults to "message"'
+  config :message_field, :validate => :string, :default => "message", :required => false
+
+  ## 'Backoff configuration. Initial backoff time between retries. Default 1s'
+  config :min_delay, :validate => :number, :default => 1, :required => false
+
+   ## 'Backoff configuration. Maximum backoff time between retries. Default 300s'
+   config :max_delay, :validate => :number, :default => 300, :required => false
+
+  ## 'Backoff configuration. Maximum number of retries to do'
+  config :retries, :validate => :number, :default => 10, :required => false
+
+  public
+  def register
+    @uri = URI.parse(@url)
+    unless @uri.is_a?(URI::HTTP) || @uri.is_a?(URI::HTTPS)
+      raise LogStash::ConfigurationError, "url parameter must be valid HTTP, currently '#{@url}'"
+    end
+
+    if @include_labels.empty?
+      raise LogStash::ConfigurationError, "include_labels should contain atleast one label, currently '#{@include_labels}'"
+    end
+
+    if @min_delay > @max_delay
+      raise LogStash::ConfigurationError, "Min delay should be less than Max delay, currently 'Min delay is #{@min_delay} and Max delay is #{@max_delay}'"
+    end
+
+    @logger.info("Loki output plugin", :class => self.class.name)
+
+    # intialize channels
+    @Channel = Concurrent::Channel
+    @entries = @Channel.new
+
+    # excluded message and timestamp from labels
+    @exclude_labels = ["message", "@timestamp"]
+
+    # create nil batch object.
+    @batch = nil
+
+    # validate certs
+    if ssl_cert?
+      load_ssl
+      validate_ssl_key
+    end
+
+    @Channel.go{run()}
+  end
+
+  def ssl_cert?
+    !@key.nil? && !@cert.nil?
+  end
+
+  def load_ssl
+    @cert = OpenSSL::X509::Certificate.new(File.read(@cert)) if @cert
+    @key = OpenSSL::PKey.read(File.read(@key)) if @key
+  end
+
+  def validate_ssl_key
+    if !@key.is_a?(OpenSSL::PKey::RSA) && !@key.is_a?(OpenSSL::PKey::DSA)
+      raise LogStash::ConfigurationError, "Unsupported private key type '#{@key.class}''"
+    end
+  end
+
+  def ssl_opts(uri)
+    opts = {
+      use_ssl: uri.scheme == 'https'
+    }
+
+    if !@cert.nil? && !@key.nil?
+      opts = opts.merge(
+        verify_mode: OpenSSL::SSL::VERIFY_PEER,
+        cert: @cert,
+        key: @key
+      )
+    end
+
+    unless @ca_cert.nil?
+      opts = opts.merge(
+        ca_file: @ca_cert
+      )
+    end
+    opts
+  end
+
+  def run()
+	  min_wait_checkfrequency = 1/1000 #1 millisecond
+	  max_wait_checkfrequency = @batch_wait
+	  if max_wait_checkfrequency < min_wait_checkfrequency
+		  max_wait_checkfrequency = min_wait_checkfrequency
+    end
+
+    @max_wait_check = Concurrent::Channel.tick(max_wait_checkfrequency)
+    loop do
+      Concurrent::Channel.select do |s|
+        s.take(@entries) { |e|
+          if @batch.nil?
+            @batch = Batch.new(e)
+            next
+          end
+
+          line = e.entry['line']
+          if @batch.size_bytes_after(line) > @batch_size
+            @logger.debug("Max batch_size is reached. Sending batch to loki")
+            send(@tenant_id, @batch)
+            @batch = Batch.new(e)
+            next
+          end
+          @batch.add(e)
+        }
+        s.take(@max_wait_check) {
+          # Send batch if max wait time has been reached
+          if !@batch.nil?
+            if @batch.age() < @batch_wait
+              next
+            end
+
+            @logger.debug("Max batch_wait time is reached. Sending batch to loki")
+            send(@tenant_id, @batch)
+            @batch = nil
+          end
+        }
+      end
+    end
+  end
+
+  ## Receives logstash events
+  public
+  def receive(event)
+    labels = {}
+    event_hash = event.to_hash
+    lbls = handle_labels(event_hash, labels, "")
+
+    data_labels, entry_hash = build_entry(lbls, event)
+    @entries << Entry.new(data_labels, entry_hash)
+
+  end
+
+  def close
+    @logger.info("Closing loki output plugin. Flushing all pending batches")
+    send(@tenant_id, @batch) if !@batch.nil?
+    @entries.close
+    @max_wait_check.close if !@max_wait_check.nil?
+  end
+
+  def build_entry(lbls, event)
+    labels = lbls.merge(@external_labels)
+    entry_hash = {
+      "ts" => event.get("@timestamp").to_i * (10**9),
+      "line" => event.get(@message_field).to_s
+    }
+    return labels, entry_hash
+  end
+
+  def handle_labels(event_hash, labels, parent_key)
+    event_hash.each{ |key,value|
+      if !@exclude_labels.include?(key)
+        if value.is_a?(Hash)
+          if parent_key != ""
+            handle_labels(value, labels, parent_key + "_" + key)
+          else
+            handle_labels(value, labels, key)
+          end
+        else
+          if parent_key != ""
+            labels[parent_key + "_" + key] = value.to_s
+          else
+            labels[key] = value.to_s
+          end
+        end
+      end
+    }
+    return extract_labels(labels)
+  end
+
+  def extract_labels(extracted_labels)
+    labels = {}
+    extracted_labels.each { |key, value|
+      if @include_labels.include?(key)
+        key = key.gsub("@", '')
+        labels[key] = value
+      end
+    }
+    return labels
+  end
+
+  def send(tenant_id, batch)
+    payload = build_payload(batch)
+    res = loki_http_request(tenant_id, payload, @min_delay, @max_delay, @retries)
+
+    if res.is_a?(Net::HTTPSuccess)
+      @logger.debug("Successfully pushed data to loki")
+      return
+    else
+      @logger.error("failed to write post to ", :uri => @uri, :code => res.code, :body => res.body, :message => res.message) if !res.nil?
+      @logger.debug("Payload object ", :payload => payload)
+    end
+  end
+
+  def loki_http_request(tenant_id, payload, min_delay, max_delay, retries)
+    req = Net::HTTP::Post.new(
+      @uri.request_uri
+    )
+    req.add_field('Content-Type', 'application/json')
+    req.add_field('X-Scope-OrgID', tenant_id) if tenant_id
+    req.basic_auth(@username, @password) if @username
+    req.body = payload
+
+    opts = ssl_opts(@uri)
+
+    @logger.debug("sending #{req.body.length} bytes to loki")
+    retry_count = 0
+    delay = min_delay
+    begin
+      res = Net::HTTP.start(@uri.host, @uri.port, **opts) { |http| http.request(req) }
+    rescue Net::HTTPTooManyRequests, Net::HTTPServerError, Errno::ECONNREFUSED => e
+      unless retry_count < retries
+        @logger.error("Error while sending data to loki. Tried #{retry_count} times\n. :error => #{e}")
+        return res
+      end
+
+      retry_count += 1
+      @logger.warn("Trying to send again. Attempt number: #{retry_count}. Retrying in #{delay}s")
+      sleep delay
+
+      if (delay * 2 - delay) > max_delay
+        delay = delay
+      else
+        delay = delay * 2
+      end
+
+      retry
+    rescue StandardError => e
+      @logger.error("Error while connecting to loki server ", :error_inspect => e.inspect, :error => e)
+      return res
+    end
+    return res
+  end
+
+  def build_payload(batch)
+    payload = {}
+    payload['streams'] = []
+    batch.streams.each { |labels, stream|
+        stream_obj = get_stream_obj(stream)
+        payload['streams'].push(stream_obj)
+    }
+    return payload.to_json
+  end
+
+  def get_stream_obj(stream)
+    stream_obj = {}
+    stream_obj['stream'] = stream['labels']
+    stream_obj['values'] = []
+    values = []
+    stream['entries'].each { |entry|
+        values.push(entry['ts'].to_s)
+        values.push(entry['line'])
+    }
+    stream_obj['values'].push(values)
+    return stream_obj
+  end
+end

data/lib/logstash/outputs/loki/batch.rb

@@ -0,0 +1,47 @@
+require 'time'
+
+module LogStash
+    module Outputs
+        class Loki 
+            class Batch
+                attr_reader :streams
+                def initialize(e)
+                    @bytes = 0
+                    @createdAt = Time.now
+                    @streams = {}
+                    add(e)
+                end 
+
+                def size_bytes()
+                    return @bytes
+                end
+
+                def add(e)
+                    @bytes = @bytes + e.entry['line'].length
+
+                    # Append the entry to an already existing stream (if any)
+                    labels = e.labels.to_s
+                    if @streams.has_key?(labels)
+                        stream = @streams[labels]
+                        stream['entries'] = stream['entries'] + e.entry
+                        return
+                    else  
+                        # Add the entry as a new stream
+                        @streams[labels] = {
+                            "labels" => e.labels,
+                            "entries" => [e.entry],
+                        }
+                    end
+                end 
+
+                def size_bytes_after(line)
+                    return @bytes + line.length
+                end 
+
+                def age()
+                    return Time.now - @createdAt
+                end
+            end 
+        end 
+    end 
+end 

data/lib/logstash/outputs/loki/entry.rb

@@ -0,0 +1,13 @@
+module LogStash
+    module Outputs
+        class Loki 
+            class Entry
+                attr_reader :labels, :entry
+                def initialize(labels, entry)
+                    @labels   = labels
+                    @entry = entry
+                end 
+            end 
+        end 
+    end 
+end 

data/logstash-output-loki.gemspec

@@ -0,0 +1,27 @@
+Gem::Specification.new do |s|
+  s.name = 'logstash-output-loki'
+  s.version         = '1.0.0'
+  s.authors = ['Aditya C S']
+  s.email   = ['aditya.gnu@gmail.com']
+
+  s.summary       = 'Output plugin to ship logs to a Grafana Loki server'
+  s.description   = 'Output plugin to ship logs to a Grafana Loki server'
+  s.homepage      = 'https://github.com/grafana/loki/'
+  s.license       = 'Apache-2.0'
+  s.require_paths = ["lib"]
+
+  # Files
+  s.files = Dir['lib/**/*','spec/**/*','vendor/**/*','*.gemspec','*.md','CONTRIBUTORS','Gemfile','LICENSE','NOTICE.TXT']
+   # Tests
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+
+  # Special flag to let us know this is actually a logstash plugin
+  s.metadata = { "logstash_plugin" => "true", "logstash_group" => "output" }
+
+  # Gem dependencies
+  #
+  s.add_runtime_dependency "logstash-core-plugin-api", ">= 1.60", "<= 2.99"
+  s.add_runtime_dependency "logstash-codec-plain", "3.0.6"
+  s.add_runtime_dependency "concurrent-ruby-edge", "0.6.0"
+  s.add_development_dependency 'logstash-devutils', "2.0.2"
+end

data/spec/outputs/loki_spec.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/outputs/loki"
+require "logstash/codecs/plain"
+require "logstash/event"
+require "net/http"
+
+describe LogStash::Outputs::Loki do
+  let (:simple_loki_config) {{'url' => 'http://localhost:3100', 'include_labels' => ["test_key", "other_key"], 'external_labels' => {"test" => "value"}}}
+
+  context 'when initializing' do
+    it "should register" do
+      loki = LogStash::Plugin.lookup("output", "loki").new(simple_loki_config)
+      expect { loki.register }.to_not raise_error
+    end
+
+    it 'should populate loki config with default or intialized values' do
+      loki = LogStash::Outputs::Loki.new(simple_loki_config)
+      expect(loki.url).to eql 'http://localhost:3100'
+      expect(loki.tenant_id).to eql nil
+      expect(loki.batch_size).to eql 102400
+      expect(loki.batch_wait).to eql 1
+      expect(loki.include_labels).to eql ["test_key", "other_key"]
+      expect(loki.external_labels).to include("test" => "value")
+    end
+  end
+
+  context 'test labels' do
+      let (:simple_loki_config) {{'url' => 'http://localhost:3100', 'include_labels' => ["@version", 'log_file_@path', 'host']}}
+      let (:event) { LogStash::Event.new({'message' => 'hello', '@version' => '1', 'agent' => 'filebeat', 'log' => {'file' => {'@path' => '/path/to/file.log'}}, 'host' => '172.0.0.1',
+                                      '@timestamp' => LogStash::Timestamp.now}) }
+      let(:loki) { LogStash::Plugin.lookup("output", "loki").new(simple_loki_config) }
+
+      before do
+        loki.register
+        loki.close
+      end
+
+      it 'labels extracted should have only included labels' do
+        labels = {}
+        event_hash = event.to_hash
+        expected_labels = {"version" => "1", "host" => "172.0.0.1", "log_file_path" => '/path/to/file.log'}
+        expect(loki.handle_labels(event_hash, labels, "")).to eql expected_labels
+      end
+  end
+
+  context 'validate entries' do
+    let(:timestamp) {LogStash::Timestamp.now}
+    let (:simple_loki_config) {{'url' => 'http://localhost:3100', 'include_labels' => ["version", "host", "test"], 'external_labels' => {"test" => "value"}}}
+    let (:event) { LogStash::Event.new({'message' => 'hello', '@version' => '1', 'agent' => 'filebeat', 'host' => '172.0.0.1',
+                                    '@timestamp' => timestamp}) }
+    let(:loki) { LogStash::Plugin.lookup("output", "loki").new(simple_loki_config) }
+
+    before do
+      loki.register
+      loki.close
+    end
+
+    it 'validate expected entries are added to entries stream' do
+      labels = {"version" => "1", "host" => "172.0.0.1"}
+      expected_labels = {"version" => "1", "host" => "172.0.0.1", "test" => "value"}
+      expected_entry_hash = {
+        "ts" => timestamp.to_i * (10**9),
+        "line" => "hello".to_s
+      }
+      expected_labels_and_entry_hash = [{"version" => "1", "host" => "172.0.0.1", "test" => "value"}, expected_entry_hash]
+      expect(loki.build_entry(labels, event)).to eq(expected_labels_and_entry_hash)
+    end
+  end
+
+  context 'test http requests' do
+    let (:simple_loki_config) {{'url' => 'http://localhost:3100', 'include_labels' => ["@version", "host", "test"],}}
+    let (:event) { LogStash::Event.new({'message' => 'hello', '@version' => '1', 'host' => '172.0.0.1',
+                                      '@timestamp' => LogStash::Timestamp.now}) }
+    let(:loki) { LogStash::Plugin.lookup("output", "loki").new(simple_loki_config) }
+
+    before do
+      loki.register
+      loki.close
+    end
+
+    it 'test http requests and raise_error when requests are not successful' do
+      labels = {}
+      event_hash = event.to_hash
+      lbls = loki.handle_labels(event_hash, labels, "")
+      entry_hash = {
+        "ts" => event.get("@timestamp").to_i * (10**9),
+        "line" => event.get("message").to_s
+      }
+      e = LogStash::Outputs::Loki::Entry.new(lbls, entry_hash)
+      batch = LogStash::Outputs::Loki::Batch.new(e)
+      payload = loki.build_payload(batch)
+
+      # response should be nil on connection error
+      expect(loki.loki_http_request("fake", payload, 1, 2, 3)).to eql nil
+
+      success = Net::HTTPSuccess.new(1.0, 200, 'OK')
+      allow(loki).to receive(:loki_http_request) { success }
+      allow(success).to receive(:payload).and_return('fake body')
+      expect(loki.loki_http_request("fake", batch, 1, 300, 10).class).to eql Net::HTTPSuccess
+
+      too_many_requests = Net::HTTPTooManyRequests.new(1.0, 429, 'OK')
+      allow(loki).to receive(:loki_http_request) { too_many_requests }
+      allow(too_many_requests).to receive(:payload).and_return('fake body')
+      expect(loki.loki_http_request("fake", batch, 1, 300, 10).class).to eql Net::HTTPTooManyRequests
+
+      server_error = Net::HTTPServerError.new(1.0, 429, 'OK')
+      allow(loki).to receive(:loki_http_request) { server_error }
+      allow(server_error).to receive(:payload).and_return('fake body')
+      expect(loki.loki_http_request("fake", batch, 1, 300, 10).class).to eql Net::HTTPServerError
+    end
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: logstash-output-loki
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Aditya C S
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-07-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.60'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '2.99'
+  name: logstash-core-plugin-api
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.60'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '2.99'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.6
+  name: logstash-codec-plain
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.6
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  name: concurrent-ruby-edge
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  name: logstash-devutils
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+description: Output plugin to ship logs to a Grafana Loki server
+email:
+- aditya.gnu@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- lib/logstash/outputs/loki.rb
+- lib/logstash/outputs/loki/batch.rb
+- lib/logstash/outputs/loki/entry.rb
+- logstash-output-loki.gemspec
+- spec/outputs/loki_spec.rb
+homepage: https://github.com/grafana/loki/
+licenses:
+- Apache-2.0
+metadata:
+  logstash_plugin: 'true'
+  logstash_group: output
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key:
+specification_version: 4
+summary: Output plugin to ship logs to a Grafana Loki server
+test_files:
+- spec/outputs/loki_spec.rb