tasklog: don't log progress status when stdout is not a tty

[steffengodskesen]

To avoid filling logs with progress status when running git/git-lfs inside tools and services where the output does not go to a terminal.

The behaviour is overridable by either

• setting lfs.forceprogress 1
• setting GIT_LFS_FORCE_PROGRESS=1

Ideally this should be controllable by command line args (like git push --progress) but passing command line args down to filters and hooks is not really an option.

[bk2204]

Overall, this looks good. Thanks for the patch, and welcome to Git LFS!

There are a few things we should probably fix that I've mentioned below. I'm also interested to know how this will work on Windows both with and without Git Bash.

[bk2204]

Typo: ”make“ instead of ”makes”

[bk2204]

We generally want to vendor these dependencies. Could you run make vendor to pull those into the tree?

[bk2204]

I don't see this used anywhere. Should it be removed?

[ttaylorr]

Hi @steffengodskesen, thanks for sending this along -- and welcome to Git LFS! I agree with what @bk2204 has recommended thus far, and I have a couple of additional suggestions of my own. Let me know what you think of them, and I'd be happy to share my thoughts as well.

[ttaylorr]

I think that it may be good to adopt the same pattern of option functions here, too, even though there is only one option that we'd be supporting. I suggest this, because I think the "extra baggage" of option functions is worth the tradeoff to remove a boolean argument. Perhaps:

type optionFn func(l *Logger)

var (
        forced optionFn = func(l *Logger) {
                l.forceProgress = true
        }
)

// NB: this prevents mutating the underlying variable, which _can_ be changed at runtime.
func Forced() optionFn { return forced }

func NewLogger(sink io.Writer, fns ...optionFn) {
        l := &Logger{...}
        for _, fn := range fns {
                fn(l)
        }

        // ...
}

Then to call this (with forcing) you would instead say:

l := tasklog.NewLogger(os.Stderr, tasklog.Forced())

I think that you would want a helper function that calls that ☝️, since it removes the convenience of simply passing along cfg.ForceProgress().

[steffengodskesen]

Agree. Nice pattern; hadn't seen that before. Thanks for the pointer.

I'm not sure I understand the "NB: this prevents mutating the underlying variable" comment, though.

[ttaylorr]

Does isatty cache this result? If not, and if it's expensive to compute, we should cache it ourselves, since this loop is expected to run many times.

On another note, I don't think that this is quite what we want: indeed this checks whether we can write to stdout, but stdout is not always the io.Writer we are writing to. Could you instead say:

type Logger struct {
        ttyOnce sync.Once
        tty bool
}

func (l *Logger) tty() bool {
        l.ttyOnce.Do(func() {
                if f, ok := l.sink.(interface{ // <- could use `*os.File`, too 
                        Fd() uintptr
                }); ok {
                        l.tty = isatty.IsTerminal(f.Fd())
                        return
                }
        })
        return l.tty
}

And then rewrite this line to:

if !(l.tty() || l.forceProgress) {
        continue
}

[steffengodskesen]

Checking the (possibly non-existing) Fd() on the actual Writer makes good sense. Won't work in the cases where the sink is a io.MultiWriter (command_fetch.go and command_prune.go does this), but I'll try to come up with a solution to that. Maybe wrapping the io.MultiWriter in a type that exposes the Fd() of its first writer.

The sink won't change during the lifetime of the logger, so could we not cache result of the call to isatty on instantiation of the logger?

[ttaylorr]

This looks great; thanks for addressing all of mine and @bk2204's changes!