class ElasticAPM::Transport::Serializers::SpanSerializer::ContextSerializer

def build(context)
  return unless context
  base = {}
  base[:tags] = mixed_object(context.labels) if context.labels.any?
  base[:sync] = context.sync unless context.sync.nil?
  base[:db] = build_db(context.db) if context.db
  base[:http] = build_http(context.http) if context.http
  if context.destination
    base[:destination] = build_destination(context.destination)
  end
  if context.message
    base[:message] = build_message(context.message)
  end
  if context.service
    base[:service] = build_service(context.service)
  end
  if context.links && !context.links.empty?
    base[:links] = build_links(context.links)
  end
  base
end

def build_db(db)
  {
    instance: db.instance,
    statement: Util.truncate(db.statement, max_length: 10_000),
    type: db.type,
    user: db.user,
    rows_affected: db.rows_affected
  }
end

def build_destination(destination)
  return unless destination
  base = {
    address: keyword_field(destination.address),
    port: destination.port
  }
  if (service = destination.service) && !service.empty?
    base[:service] = service.to_h
  end
  if (cloud = destination.cloud) && !cloud.empty?
    base[:cloud] = cloud.to_h
  end
  base
end

def build_http(http)
  {
    url: http.url,
    status_code: http.status_code.to_i,
    method: keyword_field(http.method)
  }
end

def build_links(links)
  {
    links: links.map do |link|
      {"trace_id" => link.trace_id, "span_id" => link.span_id}
    end
  }
end

def build_message(message)
  {
    queue: {
      name: keyword_field(message.queue_name)
    },
    age: {
      ms: message.age_ms.to_i
    }
  }
end

def build_service(service)
  {
    target: {
      name: keyword_field(service.target&.name),
      type: keyword_field(service.target&.type)
    }
  }
end