Ensure code block after every request - finally block

[myxoh]

Motive: Sometime we do things like logging, or open sessions, or other actions during an API request and we want to make sure those actions are wrapped up afterwards.

This introduces a DSL way of handling this after every request on an API

I've made an attempt at it:
#1864

[dm1try]

as I already mentioned in the referenced PR, this could be solved by using an endpoint middleware.

I agree that it could be sorted by Middleware @dm1try but I do feel like having an after block that always run should be a feature in Grape regardless.

it looks like the default behaviour mimics ROR after_filter(AFAIK things are different in sinatra)
it could be made configurable

after(run_on_exceptions: true) do
end

[myxoh]

I'd rather have a version that keeps current behaviour and one that doesn't, as I feel they are very different.
The point of it is having every other bit of grape's helpers which makes it more useful than just an endpoint middleware.
However, I'm fine if the majority consensus is against the feature

[dm1try]

I'd rather have a version that keeps current behaviour and one that doesn't, as I feel they are very different.

could you please elaborate?
I see the only one difference: in one case the code that placed in the after callback does not run if an exception occurs, in other case the code is run anyway.

def run
  before_logic
  logic
  after_logic
end

def run
  before_logic
  begin
    logic
  ensure
    after_logic_that_always_run
  end
end

def run
  before_logic
  begin
    logic
    after_logic
  ensure
    after_logic_that_always_run
  end
end

and the use one or another certainly depends on the logic that placed in the callbacks.

The point of it is having every other bit of grape's helpers which makes it more useful than just an endpoint middleware.

actually, a middleware looks more suitable for logging. as I already mentioned in the referenced PR, an exception can be raised in the middleware stack before an endpoint run. I think, in that case, users expect that the request will be logged also.

[myxoh]

I see the only one difference: in one case the code that placed in the after callback does not run if an exception occurs, in other case the code is run anyway.

I feel like the use cases after a successful request and after every request are different enough to entitle different method names (As usually the point of a DSL library should be to make the intent clear)

While it's technically true that an exception might be caught by middleware, it's also true that unless you ensure that logging is the first middleware to run you'll always face this problem.

Regardless, having a block of text that always runs after the API call and shares a context with the before block sounds fairly useful to me (Generically I'd rather use this for some types of logging than middleware because it's more easily readable on the endpoints and a lot less verbose)

i.e.

class mainAPI < Grape::API
  before do
    start_general_api_call_log
  end

  finally do
    finish_general_api_call_log
  end
end

class FinancialEndpoint < Grape::API
  before do
    start_financial_transaction_log
  end
  finally do
    finish_financial_transaction_log
  end
end

class SomeOtherEndpoint
  get 'unique_financial' do
    start_financial_transaction_log
    # ...
    finish_financial_transaction_log
  end
end

In that example I can use this log in a pick_and_choose, and because it is just a helper I can use it on some endpoints granularly.
Also because it's a helper it could contain information from other helpers (for example, the user_name)

Sure I can use Middleware to accomplish all of the following but it gets noisy and less dry really quickly for some use cases.

I'll let you and @dblock make the final call however as to whether or not to merge it

[dblock]

I think @myxoh's explanation of the motivations for the finally block is very compelling. It's also very Ruby-like and Grape-like to give people a few different ways to accomplish the same thing, especially by offering a DSL. So by the powers vested in my self inflicted benevolent dictatorship I shall merge #1864.