
Git log – The good parts - okket
https://zwischenzugs.com/2018/03/26/git-log-the-good-parts/
======
TeMPOraL
For those increasingly rare times I'm not using Magit[0], I have a "git lg"
alias I found once through HN[1]:

    
    
      git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"
    

I strongly recommend both.

\--

[0] - [https://magit.vc/](https://magit.vc/)

[1] - [https://coderwall.com/p/euwpig/a-better-git-
log](https://coderwall.com/p/euwpig/a-better-git-log)

~~~
peff
You should probably avoid `--color`, as it turns on color unconditionally,
even if output is going to a file. In older versions of Git the %C color
placeholders were unconditional anyway. In modern Git, they respect the normal
auto-coloring settings.

You can also drop `--abbrev-commit`, since `%h` abbreviates by default (use
`%H` if you want the full hash).

~~~
dalore
For the lazy:

    
    
      git config --global alias.lg "log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset'"

~~~
knux
You can still add color when not piping or writing to a file with
`--color=auto`.

    
    
          git config --global alias.lg "log --color=auto --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset'"

~~~
yes_or_gnome
This is likely to be said, "`--color=auto` is the default setting, so it's not
needed." However, it's good to include it here because some users may have
changed their default configuration to disable colors. This way `git log`
works as their standard workflow and `git lg` for when they need a bit of
color.

------
anonova
I would recommend tig for anyone looking for a cli git repo browser:
[https://jonas.github.io/tig/](https://jonas.github.io/tig/) Then there's no
need to mess with git log and all its options.

~~~
aequitas
Second that, I love tig as a history browser. However for Git tree
manipulation I find it a little disappointing. A lot can be customised with
shortcuts, but it feels a little cumbersome and you need to restart for some
changes to be visible.

------
susam
In case anyone finds these useful, here are some git log aliases I use
everyday.

    
    
        FORMAT="%C(auto)%h %C(magenta)%ad %C(cyan)%an%C(auto)%d %s"
        PRETTY="--pretty=format:'$FORMAT' --date=short"
        git config --global alias.lga "log --graph --all $PRETTY"
        git config --global alias.lg "log --graph $PRETTY"
        git config --global alias.la "log --all $PRETTY"
        git config --global alias.ll "log $PRETTY"
        git config --global alias.lf "log --pretty=fuller --stat"
    

There are two interesting things to note here:

• Since the --decorate option is now enabled by default (at least since Git
2.13), I don't have the --decorate option in my aliases. You may have to add
them if you are using an older version of Git.

• Often while looking at the commit log, I need to know the commit date and
the committer name which --oneline option does not show by default, so instead
of using the --oneline option, I am formatting the one-liner logs myself with
the `--pretty=format:` option to see these details.

The --simplify-by-decoration option is a nice one, something I can add to my
list of aliases.

I have these aliases and a few other useful aliases documented in a bonus
section named "Nifty Commands" in a fork and pull request workflow document I
shared on Hacker News about a month ago. Here is the URL:
[https://github.com/susam/gitpr](https://github.com/susam/gitpr).

~~~
alxndr
Git has a built-in way of achieving what you've done with the $FORMAT and
$PRETTY variables; look at @twic's comment on this story.

------
zwischenzug
Commands in the article:

    
    
        git clone https://github.com/ianmiell/cookbook-openshift3-frozen
        cd cookbook-openshift3-frozen
        git log
        git log --oneline
        git log --oneline --decorate
        git log --oneline --decorate --all
        git log --oneline --decorate --all --graph
        git log --oneline --decorate --all --graph --simplify-by-decoration
        git log --oneline --decorate --all --graph --stat
        git log -G 'chef-client' --graph --oneline --stat
        git log -G 'chef-client' --graph --oneline --stat --pickaxe-all

~~~
MayeulC
A quick mnemonic I read on StackOverflow[1] some time ago:

    
    
       When using git log, do it like "a dog"
       git log --all --decorate --oneline --graph
    

I must say I had forgotten about the `--all` part, but the article mentions
that it should be on by default if running interactively in the terminal, at
least with recent versions of git.

[1]It might have been [https://stackoverflow.com/questions/1057564/pretty-git-
branc...](https://stackoverflow.com/questions/1057564/pretty-git-branch-
graphs) but I am not 100% sure.

~~~
jwilk
I don't believe the article's claim about --all being on by default is true.

~~~
zwischenzug
It's not, it was a typo I've corrected.

------
jordigh
This reminds me a bit of my `hg wip` command:

[http://jordi.inversethought.com/blog/customising-
mercurial-l...](http://jordi.inversethought.com/blog/customising-mercurial-
like-a-pro/)

It eventually got mainlined into Mercurial as the `hg show` command:

[https://www.mercurial-
scm.org/wiki/WhatsNew#Mercurial_4.3_.2...](https://www.mercurial-
scm.org/wiki/WhatsNew#Mercurial_4.3_.2F_4.3.1_.282017-08-10.29)

------
thiht
An unappreciated flag of git is `--no-pager`. It allows, as said in the name,
to execute a git command without using a pager.

Using this flag, my git log aliases to: `git --no-pager log --pretty=oneline
-n30 --abbrev-commit`. It just shows the 30 last commits directly in my
command line

------
legec
Another useful option is '\--first-parent'

One use case is : "when did branchA fork from master ?"

git log --graph --oneline --... --first-parent branchA master

~~~
zwischenzug
That's a good one... I'll probably add that tonight after work.

------
Ruphin
This is my preferred git log command:

    
    
      git config --global alias.lg "log --graph --abbrev-commit --decorate --date=relative --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(bold yellow)%d%C(reset)' --all"
    

Of all the git log variants that I have come across I find this one the most
clean, easy to parse, and nicely formatted. I think I found it on HN
somewhere. Maybe someone finds it as useful as I did

------
samuell
You don't need fancy GUI's, nor do you need to remember long flag names, when
there is tig - text mode interface to git. You only need to remember it's
"git" backwards:

[https://jonas.github.io/tig/](https://jonas.github.io/tig/)

Screenshot of main view:

[https://www.flickr.com/photos/jonasfonseca/3316428644/in/alb...](https://www.flickr.com/photos/jonasfonseca/3316428644/in/album-72157614470764617/)

Available in most repos (ubuntu, homebrew I think, etc). Never understood why
it's not more widely known than it is.

------
MattyRad
I like this the idea of showing the most common use cases for a git command
(or at the very least, a valuable use case), separating the sections by
building out the flags and options.

The git man pages, while thorough, don't provide anything this concise. I
could easily add these commands as aliases, which I appreciate.

------
dahart
I wish git log had a native columnized one-line output, it's hard to read with
variable length fields. You can (and I did) use the --pretty option to format
the log output, and columnize it. But that's involved (my git 'columnized log'
script is ~100 lines long) and hard to share.

------
hungerstrike
I like Tortoisegit. No commands to memorize and the entire product can be
worked via the keyboard.

[https://i.stack.imgur.com/Xc9vb.png](https://i.stack.imgur.com/Xc9vb.png)

~~~
evfanknitram
I like GitExtensions. I cringe when i see people manually entering hashes when
they want to do stuff such as simple diffs. It's busy work. Hammering away on
the keyboard but actually accomplishing so little.

~~~
hungerstrike
Thanks! I would really like something that integrates with Finder on the Mac
and I see that it is cross platform, so I will have to try that out.

------
RobertRoberts
I just spent 15 minutes entering different Git log commands. Good times.

------
pkamb
I can't imagine developing or sorting out repo issues without a full tree-view
of the last hundred commits showing branches, merges, SHAs, tags, authors,
commit messages, etc.

But it's just another tab in my GUI app (sourcetree), not a complicated set of
flags that needs a blog post to explain.

The use of git as a command-line-only tool is completely strange and alien to
me. It works so well as a full-fledged graphical app.

~~~
OskarS
I work for a small game studio with a couple of programmers and artists, and
we use git for source control (which works for us, our binary assets aren't
big enough to make git too much trouble). Most of our team is non-programmers,
and I've become the "go-to git guy" at my company. All the others use
Sourcetree, so I have lots of experience with it, and I can tell you: I would
never pick Sourcetree over command line git.

Sourcetree is an okay piece of software, but command-line git is so much
faster to use. Even doing simple things like adding, committing, pulling and
pushing takes half the time on the command line for me compared to Sourcetree.
For this particular logging issue, you don't actually type up all those flags
every time, you make an alias and it takes no time at all. If you're trying to
do anything marginally complicated (say, bisecting or using the reflog),
Sourcetree is all but useless.

Command line git is harder to learn and harder to use in the beginning (and
virtually impossible to use unless you're comfortable with the terminal), but
if you're using the terminal a significant amount anyway, it's just a better
solution.

I will say: the last couple of weeks, I've been trying to get into the habit
of using magit, and it's the only git client I've used that can compete with
the command line. Sourcetree certainly can't, not for me.

~~~
pkamb
My experience is coworker developers struggling-at-best to use git from the
command line in the simple case, and having almost no visibility into the
tree/history of the repository for use in debugging. Or being unaware of
useful git features such as line-by-line selective staging (that I consider
absolutely essential for dev teams).

I don't particularly like SourceTree, and it is slow and annoying in certain
ways. But I'm extremely productive with it as a poweruser, and it's much
better for beginners as well.

------
erikb
"git log" was yesterday, "git lol" is the new hip thing. Give it a shot:
[https://github.com/erikbgithub/dot-
files/blob/master/.gitcon...](https://github.com/erikbgithub/dot-
files/blob/master/.gitconfig#L38)

------
js2
Sometimes I like to generate a summary for release note purposes. The shortlog
command (which is what git merge uses) is good for that. [https://git-
scm.com/docs/git-shortlog](https://git-scm.com/docs/git-shortlog)

------
zestyping
I can't use git without "git gl":

    
    
        [alias]
        gl = log --pretty=format:\"%x1b[33m%h%x1b[36m%d %Cgreen%ae %Cred%ad%Creset%n%s%n\" --graph --date=local
    

Try this in your .gitconfig. I highly recommend it.

------
elteto
I don't see it mentioned anywhere, but

    
    
        git log -N (where N is 1, 2, 3, 4...)
    

will show the last N commits only. I find myself doing `git log -1` pretty
often to see what was the last commit, so I imagine I'm not the only one.

~~~
wging
'git show' does that too.

------
thriftwy
The best part of git log is git reflog. It's like suddently having eyes to
see.

~~~
knux
My personal favorite is `git log -p --` because it actually shows you the
content that changed.

Or, to show you what changed on each given single line, use `git log -p
--color-words --`. Far more useful for long lines, IMO.

I'm also a fan of `git log -LN,N:filename`, where N is a line number. It gives
you a log of that particular line number. It's like `git blame` but better.

------
rom1v
I discovered --simplify-by-decoration thanks to the article. Thank you :)

------
ibdf
Thanks for sharing. I've been forcing myself to be independent from a git GUI,
and just learn the commands. I didn't even know that was a --graph option to
git log.

------
pwneduser
Quote from article:

"Remember that your version might do --all by default when output goes to the
terminal instead of a file"

Which version of Git does --all by default?

~~~
peff
I think they meant to say "might do --decorate by default" (which Git does
since v2.13.0).

~~~
zwischenzug
Indeed, have updated - the all and decorate sections got jumbled up in an edit
earlier.

------
bitpow
> 15-team project that doesn’t rebase

Holy un-scalable code base Batman.

------
awake
Or use sourcetree

~~~
ozim
Sourcetree is awful and slow. There is git gui by default, which is not
perfect but IMO better that cli. I actually use Git Extensions for years now
and could not find anything better.

~~~
pwneduser
Which Git GUI present by default do you find better than CLI? gitk? Or do you
have something else in mind?

~~~
ozim
This one where you just type in 'git gui' and it pops up. [https://git-
scm.com/docs/git-gui](https://git-scm.com/docs/git-gui)

~~~
majewsky
`git gui` is not a commit tree browser though. It's used for making commits.

~~~
ozim
Menu -> Repository -> Visualize

You can visualize current branch or all branches. It also has search, diffs
and quite some options.

