Could we drop the regex here?

What's your suggestion instead?

I was going to suggest the same :-)

Simply find the index of ':' and if such index exist make a substring until that index.

Is it faster than using a Regex?

Yes, using Regex is almost always slower than not using Regex. Specially if this is just a char index lookup. Matching a regex involves much more logic than just a char index, and also allocated memory for the match results (and I don't know if PCRE allocates memory for that too).

Try this:

require "benchmark"

def regex(string)
  string.sub(/:\d+\z/, "")
end

def index(string)
  index = string.index(':')
  index ? string[0...index] : string
end

# This is so LLVM can't optimize it that easily
string = String.build { |str| str << "www.google.com:80" }

pp regex(string)
pp index(string)

Benchmark.ips do |x|
  x.report("regex") { regex(string) }
  x.report("index") { index(string) }
end

I get:

regex(string) # => "www.google.com"
index(string) # => "www.google.com"
regex   1.41M (±14.83%)  4.38× slower
index   6.18M (±15.03%)       fastest

(though I must admit that I expected it to be much slower with regex)

Thanks for the detailed benchmark @asterite 🙏

Please assign @headers["Host"] to a local variable, otherwise we have 2 lookups inside that hash.

Done 👍

Still 2 lookups :)

Yes, this should be something like:

host = @headers["Host"]?
return unless host
# etc.

Updated 👍

You can replace this by:

host_with_port.try &.split(':').[0]

and add, for completeness:

def port
  host_with_port.try &.split(':').[1]
end

But split will create an array and two strings, which will be slower. Like this is fine.

I'm not sure whether the Host header can ever contain an ipv6 address, (formatted [1234:5678::1]:80?) but if it does, this code will break.

String#rindex should work regardless.
Update: how about using URI.parse("//#{@headers["Host"]}").host?

I think we can consider the index of ] first, and compute the index of : after it if it's there, and then split.

   URI 232.25k (±57.98%)  1.64× slower
custom 380.77k (±25.71%)       fastest
 regex   26.4k (±16.06%) 14.43× slower

Using

/\A(?<host>[^:]+?|\[.+?\])(?::(?<port>\d+))?\z/

@RX14 It's less about guessing intent as more about preventing false positives.

Thanks for the benchmark results. For increased redability and reduced complexity (and all the maintenance and security benefits that come with it), I'm in favor of using URI. A 1.64x slowdown compared to the custom implementation is nothing. In terms of Moore's Law, this performance drawback will be amortized in less than a year. ;-)

Speed benchmarks don't tell everything. What about memory usage? We merely want to return the Host header and want to be nice to the developer by extracting/skipping the :port part out of it. It's definitely not an URI, just a host:port definition.

Using URI.parse means that we instantiate an URI object on the Heap (it puts pressure on the GC) just to discard it immediately because we're only interested in the Host and maybe the Port values.

I believe reproducing URI::Parse#parse_host (which looks like what NGINX is doing) or the more straightforward solution from @RX14 would be more correct, and achieve the same.

Don't know if this is anything useful, but I played around a bit with different implementations and benchmarking using @jhass's example host strings.