insights-api-common 3.0.0

data/lib/insights/api/common/graphql/generator.rb

@@ -0,0 +1,148 @@
+require "erb"
+
+module Insights
+  module API
+    module Common
+      module GraphQL
+        module Generator
+          PARAMETERS_PATH = "/components/parameters".freeze
+          SCHEMAS_PATH = "/components/schemas".freeze
+
+          def self.openapi_schema(openapi_doc, klass_name)
+            schemas = openapi_doc.content.dig(*path_parts(SCHEMAS_PATH))
+            [klass_name, "#{klass_name}Out"].each do |name|
+              schema = schemas[name]
+              return [name, schema] if schema
+            end
+          end
+
+          def self.path_parts(openapi_path)
+            openapi_path.split("/")[1..-1]
+          end
+
+          def self.template(type)
+            File.read(Pathname.new(__dir__).join(File.expand_path("templates", __dir__), "#{type}.erb").to_s)
+          end
+
+          def self.graphql_type(property_name, property_format, property_type)
+            return "!types.ID" if property_name == "id"
+
+            case property_type
+            when "string"
+              property_format == "date-time" ? "::Insights::API::Common::GraphQL::Types::DateTime" : "types.String"
+            when "number"
+              "types.Float"
+            when "boolean"
+              "types.Boolean"
+            when "integer"
+              "::Insights::API::Common::GraphQL::Types::BigInt"
+            end
+          end
+
+          def self.resource_associations(openapi_content, collection)
+            collection_is_associated = openapi_content["paths"].keys.any? do |path|
+              path.match?("^/[^/]*/{[[a-z]*_]*id}/#{collection}$") &&
+                openapi_content.dig("paths", path, "get").present?
+            end
+            collection_associations = []
+            openapi_content["paths"].keys.each do |path|
+              subcollection_match = path.match("^/#{collection}/{[[a-z]*_]*id}/([^/]*)$")
+              next unless subcollection_match
+
+              subcollection = subcollection_match[1]
+              next unless openapi_content["paths"].keys.any? do |subcollection_path|
+                subcollection_path.match?("^/#{subcollection}/{[[a-z]*_]*id}$") &&
+                openapi_content.dig("paths", subcollection_path, "get").present?
+              end
+
+              collection_associations << subcollection
+            end
+            [collection_is_associated ? true : false, collection_associations.sort]
+          end
+
+          def self.collection_field_resolvers(schema_overlay, collection)
+            field_resolvers = {}
+            schema_overlay.keys.each do |collection_regex|
+              next unless collection.match(collection_regex)
+
+              field_resolvers.merge!(schema_overlay.fetch_path(collection_regex, "field_resolvers") || {})
+            end
+            field_resolvers
+          end
+
+          def self.collection_schema_overlay(schema_overlay, collection)
+            schema_overlay.keys.each_with_object({}) do |collection_regex, collection_schema_overlay|
+              next unless collection.match?(collection_regex)
+
+              collection_schema_overlay.merge!(schema_overlay[collection_regex] || {})
+            end
+          end
+
+          def self.init_schema(request, schema_overlay = {})
+            api_version       = ::Insights::API::Common::GraphQL.version(request)
+            version_namespace = "V#{api_version.tr('.', 'x')}"
+            openapi_doc       = ::Insights::API::Common::OpenApi::Docs.instance[api_version]
+            openapi_content   = openapi_doc.content
+
+            graphql_namespace = if ::Insights::API::Common::GraphQL::Api.const_defined?(version_namespace, false)
+                                  ::Insights::API::Common::GraphQL::Api.const_get(version_namespace)
+                                else
+                                  ::Insights::API::Common::GraphQL::Api.const_set(version_namespace, Module.new)
+                                end
+
+            return graphql_namespace.const_get("Schema") if graphql_namespace.const_defined?("Schema", false)
+
+            resources = openapi_content["paths"].keys.sort
+            collections = []
+            resources.each do |resource|
+              next unless openapi_content.dig("paths", resource, "get") # we only care for queries
+
+              rmatch = resource.match("^/(.*/)?([^/]*)/{[[a-z]*_]*id}$")
+              next unless rmatch
+
+              collection = rmatch[2]
+              klass_name = collection.camelize.singularize
+              next if graphql_namespace.const_defined?("#{klass_name}Type", false)
+
+              _schema_name, this_schema = openapi_schema(openapi_doc, klass_name)
+              next if this_schema.nil? || this_schema["type"] != "object" || this_schema["properties"].nil?
+
+              collections << collection
+
+              model_class = klass_name.constantize
+              model_encrypted_columns_set = (model_class.try(:encrypted_columns) || []).to_set
+
+              model_properties = []
+              properties = this_schema["properties"]
+              properties.keys.sort.each do |property_name|
+                next if model_encrypted_columns_set.include?(property_name)
+
+                property_schema = properties[property_name]
+                property_schema = openapi_content.dig(*path_parts(property_schema["$ref"])) if property_schema["$ref"]
+                property_format = property_schema["format"] || ""
+                property_type   = property_schema["type"]
+                description     = property_schema["description"]
+
+                property_graphql_type = graphql_type(property_name, property_format, property_type)
+                model_properties << [property_name, property_graphql_type, description] if property_graphql_type
+              end
+
+              field_resolvers = collection_field_resolvers(schema_overlay, klass_name)
+              model_is_associated, model_associations = resource_associations(openapi_content, collection)
+
+              graphql_model_type_template = ERB.new(template("model_type"), nil, '<>').result(binding)
+              graphql_namespace.module_eval(graphql_model_type_template)
+            end
+
+            graphql_query_type_template = ERB.new(template("query_type"), nil, '<>').result(binding)
+            graphql_namespace.module_eval(graphql_query_type_template)
+
+            graphql_schema_template = ERB.new(template("schema"), nil, '<>').result(binding)
+            graphql_namespace.module_eval(graphql_schema_template)
+            graphql_namespace.const_get("Schema")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/insights/api/common/graphql/templates/model_type.erb

@@ -0,0 +1,35 @@
+<%= klass_name %>Type = ::GraphQL::ObjectType.define do
+  name "<%= klass_name %>"
+  description "A <%= klass_name %>"
+
+<% model_properties.each do |property| %>
+<%   property_name, property_type, property_description = property %>
+<%   field_description = property_description.nil? ? "" : ", \"#{property_description}\"" %>
+<%   field_resolver = "" %>
+<%   if field_resolvers[property_name].present? %>
+<%     field_resolver = "do\n    resolve ->(obj, args, ctx) #{field_resolvers[property_name].strip}\n  end"%>
+<%   end%>
+  field :<%= property_name %>, <%=property_type%> <%=field_description%> <%=field_resolver%>
+<% end %>
+<% if model_associations.present? %>
+<%   model_associations.each do |association| %>
+<%     associations = association.pluralize %>
+<%     association_class_name  = association.camelize.singularize %>
+
+  field :<%= associations %> do
+    description "The <%= associations %> associated with this <%= klass_name %>"
+    type types[<%= "#{association_class_name}Type" %>]
+
+    argument :id, types.ID
+    argument :offset, types.Int, "The number of <%= associations %> to skip before starting to collect the result set"
+    argument :limit,  types.Int, "The number of <%= associations %> to return"
+
+    preload :<%= associations %>
+
+    resolve lambda { |obj, args, _ctx|
+      ::Insights::API::Common::GraphQL::AssociationLoader.new(<%= klass_name.constantize %>, "<%= associations %>", args).load(obj)
+    }
+  end
+<%   end %>
+<% end %>
+end

data/lib/insights/api/common/graphql/templates/query_type.erb

@@ -0,0 +1,49 @@
+QueryType = ::GraphQL::ObjectType.define do
+  name "Query"
+  description "The query root of this schema"
+
+  [
+    <%= collections.map { |c| ":#{c}" }.join(", ") %>
+  ].each do |collection|
+
+    klass_names   = collection.to_s.camelize
+    klass_name    = klass_names.singularize
+    model_class   = klass_name.constantize
+    resource_type = "::Insights::API::Common::GraphQL::Api::#{version_namespace}::#{klass_name}Type".constantize
+
+    collection_schema_overlay = ::Insights::API::Common::GraphQL::Generator.collection_schema_overlay(schema_overlay, collection)
+    base_query                = collection_schema_overlay["base_query"]
+
+    field collection do
+      description "List available #{collection}"
+      type types[resource_type]
+
+      argument :id,      types.ID
+      argument :offset,  types.Int, "The number of #{collection} to skip before starting to collect the result set"
+      argument :limit,   types.Int, "The number of #{collection} to return"
+      argument :filter,  ::Insights::API::Common::GraphQL::Types::QueryFilter, "The Query Filter for querying the #{collection}"
+      argument :sort_by, ::Insights::API::Common::GraphQL::Types::QuerySortBy, "The optional attributes to sort by. Provided as an array of attr[:asc] and attr:desc values"
+
+      resolve lambda { |_obj, args, ctx|
+        if base_query.present?
+          scope = base_query.call(model_class, ctx)
+        else
+          scope = model_class
+        end
+
+        if args[:filter]
+          openapi_doc = ::Insights::API::Common::OpenApi::Docs.instance["<%= api_version %>"]
+          openapi_schema_name, _schema = ::Insights::API::Common::GraphQL::Generator.openapi_schema(openapi_doc, klass_name)
+          scope = ::Insights::API::Common::Filter.new(
+            scope,
+            ActionController::Parameters.new(args[:filter]),
+            openapi_doc.definitions[openapi_schema_name]).apply
+        end
+        scope = ::Insights::API::Common::GraphQL.search_options(scope, args)
+        ::Insights::API::Common::PaginatedResponse.new(
+          base_query: scope, request: nil, limit: args[:limit], offset: args[:offset], sort_by: args[:sort_by]
+        ).records
+      }
+    end
+  end
+end

data/lib/insights/api/common/graphql/templates/schema.erb

@@ -0,0 +1,6 @@
+Schema = ::GraphQL::Schema.define do
+  use ::GraphQL::Batch
+  enable_preloading
+
+  query QueryType
+end

data/lib/insights/api/common/graphql/types/big_int.rb

@@ -0,0 +1,23 @@
+module Insights
+  module API
+    module Common
+      module GraphQL
+        module Types
+          class BigInt < ::GraphQL::Schema::Scalar
+            description "Represents non-fractional signed whole numeric values. Since the value may exceed the size of a 32-bit integer, it's encoded as a string."
+
+            def self.coerce_input(value, _ctx)
+              Integer(value)
+            rescue ArgumentError
+              nil
+            end
+
+            def self.coerce_result(value, _ctx)
+              value.to_i.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/insights/api/common/graphql/types/date_time.rb

@@ -0,0 +1,16 @@
+module Insights
+  module API
+    module Common
+      module GraphQL
+        module Types
+          DateTime = ::GraphQL::ScalarType.define do
+            name "DateTime"
+            description "An ISO-8601 encoded UTC date string."
+
+            coerce_input ->(value, _ctx) { Time.zone.parse(value) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/insights/api/common/graphql/types/query_filter.rb

@@ -0,0 +1,16 @@
+module Insights
+  module API
+    module Common
+      module GraphQL
+        module Types
+          QueryFilter = ::GraphQL::ScalarType.define do
+            name "QueryFilter"
+            description "The Query Filter"
+
+            coerce_input ->(value, _ctx) { JSON.parse(value.to_json) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/insights/api/common/graphql/types/query_sort_by.rb

@@ -0,0 +1,16 @@
+module Insights
+  module API
+    module Common
+      module GraphQL
+        module Types
+          QuerySortBy = ::GraphQL::ScalarType.define do
+            name "QuerySortBy"
+            description "The Query SortBy"
+
+            coerce_input ->(value, _ctx) { JSON.parse(value.to_json) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/insights/api/common/inflections.rb

@@ -0,0 +1,28 @@
+module Insights
+  module API
+    module Common
+      module Inflections
+        def self.load_inflections
+          @loaded ||= begin
+            load_common_inflections
+            true
+          end
+        end
+
+        def self.load_common_inflections
+          # Add new inflection rules using the following format
+          # (all these examples are active by default):
+          # ActiveSupport::Inflector.inflections do |inflect|
+          #   inflect.plural /^(ox)$/i, '\1en'
+          #   inflect.singular /^(ox)en/i, '\1'
+          #   inflect.irregular 'person', 'people'
+          #   inflect.uncountable %w( fish sheep )
+          # end
+          ActiveSupport::Inflector.inflections do |inflect|
+            inflect.acronym('ManageIQ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/insights/api/common/logging.rb

@@ -0,0 +1,17 @@
+module Insights
+  module API
+    module Common
+      class Logging
+        def self.activate(config)
+          require 'manageiq/loggers'
+          config.logger = if Rails.env.production?
+                            config.colorize_logging = false
+                            ManageIQ::Loggers::CloudWatch.new
+                          else
+                            ManageIQ::Loggers::Base.new(Rails.root.join("log", "#{Rails.env}.log"))
+                          end
+        end
+      end
+    end
+  end
+end

data/lib/insights/api/common/metrics.rb

@@ -0,0 +1,39 @@
+module Insights
+  module API
+    module Common
+      class Metrics
+        def self.activate(config, prefix)
+          require 'prometheus_exporter'
+          require 'prometheus_exporter/client'
+
+          ensure_exporter_server
+          enable_in_process_metrics
+          enable_web_server_metrics(prefix)
+        end
+
+        private_class_method def self.ensure_exporter_server
+          require 'socket'
+          TCPSocket.open("localhost", 9394) {}
+        rescue Errno::ECONNREFUSED
+          require 'prometheus_exporter/server'
+          server = PrometheusExporter::Server::WebServer.new(port: 9394)
+          server.start
+
+          PrometheusExporter::Client.default = PrometheusExporter::LocalClient.new(collector: server.collector)
+        end
+
+        private_class_method def self.enable_in_process_metrics
+          require 'prometheus_exporter/instrumentation'
+
+          # this reports basic process metrics such as RSS and Ruby metrics
+          PrometheusExporter::Instrumentation::Process.start
+        end
+
+        private_class_method def self.enable_web_server_metrics(prefix)
+          require "insights/api/common/middleware/web_server_metrics"
+          Rails.application.middleware.unshift(Insights::API::Common::Middleware::WebServerMetrics, :metrics_prefix => prefix)
+        end
+      end
+    end
+  end
+end

data/lib/insights/api/common/middleware/web_server_metrics.rb

@@ -0,0 +1,62 @@
+module Insights
+  module API
+    module Common
+      module Middleware
+        class WebServerMetrics
+          def initialize(app, options = {})
+            @app            = app
+            @metrics_prefix = options[:metrics_prefix] || "http_server"
+
+            require 'prometheus_exporter/client'
+            require 'prometheus_exporter/metric'
+
+            PrometheusExporter::Metric::Base.default_prefix = "#{@metrics_prefix}_"
+
+            @puma_busy_threads = PrometheusExporter::Client.default.register(:gauge, "puma_busy_threads", "The number of threads currently handling HTTP requests.")
+            @puma_max_threads  = PrometheusExporter::Client.default.register(:gauge, "puma_max_threads", "The total number of threads able to handle HTTP requests.")
+            @request_counter   = PrometheusExporter::Client.default.register(:counter, "requests_total", "The total number of HTTP requests handled by the Rack application.")
+            @request_histogram = PrometheusExporter::Client.default.register(:histogram, "request_duration_seconds", "The HTTP response duration of the Rack application.")
+          end
+
+          def call(env)
+            @puma_busy_threads.increment
+
+            result = nil
+            duration = Benchmark.realtime { result = @app.call(env) }
+            result
+          rescue => error
+            @error = error
+            raise
+          ensure
+            duration_labels = {
+              :method => env['REQUEST_METHOD'].downcase,
+              :path   => strip_ids_from_path(env['PATH_INFO']),
+            }
+
+            counter_labels = duration_labels.merge(:code => result.first.to_s).tap do |labels|
+              labels[:exception] = @error.class.name if @error
+            end
+
+            @request_counter.increment(counter_labels)
+            @request_histogram.observe(duration, duration_labels)
+
+            @puma_max_threads.observe(puma_stats["max_threads"])
+            @puma_busy_threads.decrement
+          end
+
+          private
+
+          def strip_ids_from_path(path)
+            path.gsub(%r{/\d+(/|$)}, '/:id\\1')
+          end
+
+          def puma_stats
+            JSON.parse(Puma.stats)
+          rescue NoMethodError
+            {}
+          end
+        end
+      end
+    end
+  end
+end